Sanity CMS Rehberi: 10 Dilde Yayın Yapmak İçin Nasıl Kullanıyoruz

Sanity CMS Rehberi: 10 Dilde Yayın Yapmak İçin Nasıl Kullanıyoruz

4 web sitesinde ve 10 dilde 400'ü aşkın içerik parçasını Sanity CMS aracılığıyla yayımladık. Şema tasarımından otomatik çok dilli yayıncılığa kadar öğrendiklerimiz burada.

Sanity CMS, yapılandırılmış içerik, gerçek zamanlı Content Lake ve Sanity Studio adı verilen özelleştirilebilir React tabanlı bir editör üzerine kurulu headless bir içerik platformudur. Sorgulama için GROQ, zengin içerik için Portable Text ve içerik modelleme için şema-kod-olarak yaklaşımı kullanır. Bu rehber kurulum, şema tasarımı, GROQ, Portable Text, çok dilli mimari ve fiyatlandırmayı kapsamaktadır.

Sanity CMS Nedir?

Sanity, yapılandırılmış bir içerik platformudur — Sanity.io ekibinin "içerik işletim sistemi" olarak tanımladığı bir yapı. Veritabanında HTML blob'ları saklayan geleneksel CMS'lerin aksine, Sanity her içerik parçasını Content Lake adı verilen yönetilen bir backend'de yapılandırılmış JSON olarak depolar. GROQ veya GraphQL ile sorgulayabilir, içeriği istediğiniz herhangi bir frontend'de render edebilirsiniz: Next.js, React Native, Svelte, bir mobil uygulama, bir CLI aracı — fark etmez.

Kullanan şirketler geniş bir yelpazeyi kapsıyor. Nike, Figma, Puma ve Cloudflare, Sanity'yi kurumsal ölçekte kullanıyor. Startuplar, ücretsiz katmanın gerçekten kullanılabilir olması nedeniyle tercih ediyor (fiyatlandırmaya daha sonra değineceğiz). Biz ise tam otomatik 10 dilli yayın pipeline'ı oluşturacak esnekliği başka hiçbir yerde bulamadığımız için kullanıyoruz.

Content Lake Mimarisi

Content Lake, Sanity'nin yönetilen backend'idir. Bağlı tüm istemcilerde gerçek zamanlı senkronize olan, barındırılan bir doküman deposu olarak düşünebilirsiniz. Bir editör Sanity Studio'da bir paragrafı değiştirdiğinde, diğer editör bunu anında görür — kaydet düğmesi yok, birleştirme çakışması yok, veritabanı migrasyonu yok.

Arka planda, dokümanlar yazılan alanlarla birlikte yapılandırılmış JSON olarak saklanır. Her mutasyon bir işlem günlüğüyle izlenir, dolayısıyla varsayılan olarak tam sürüm geçmişi elde edersiniz. Gerçek zamanlı senkronizasyon, (Sanity'nin GitHub mimari belgelerinde açıklanan) listener tabanlı bir mimari kullanır ve RxJS observable'ları aracılığıyla tüm abonelere değişiklikleri iletir.

Bu, REST API'li bir PostgreSQL veritabanından ne açıdan farklı? Content Lake; içerik modellemeyi, erişim kontrolünü, CDN önbelleklemesini, görüntü dönüşümlerini ve gerçek zamanlı işbirliğini tek bir yönetilen hizmet olarak sunuyor. Migrasyon çalıştırmıyorsunuz. Replica yönetmiyorsunuz. Sadece şemaları tanımlıyor ve içeriği sorguluyorsunuz.

Sanity Studio: Özelleştirilebilir Editörünüz

Sanity Studio, düzenleme arayüzünüz olarak işlev gören açık kaynaklı bir React uygulamasıdır. Barındırılan bir yönetim paneli değil — kod tabanınızda yaşayan bir React uygulaması. Her yönüyle özelleştirebilirsiniz: özel girdi bileşenleri, koşullu alanlar, doküman işlemleri, yapı oluşturucu kalıpları ve eklentiler.

Gerçek zamanlı işbirliği yerleşik olarak geliyor. Birden fazla editör, varlık göstergeleri ve canlı güncellemelerle aynı doküman üzerinde eş zamanlı çalışabilir. Google Dokümanlar kullandıysanız deneyim benzer — diğer kişilerin imleçlerini ve değişikliklerini gerçek zamanlı görürsünüz.

Studio'yu npx sanity deploy ile Sanity'nin CDN'inde özel bir alt alan adında barındırıyoruz. Studio yalnızca bir React uygulaması olduğundan kendiniz de barındırabilirsiniz. Sanity'yi headless CMS karşılaştırmamızda yüksek puan almasının büyük nedeni Studio'nun esnekliğidir.

Sanity Projesi Nasıl Kurulur

Sanity CMS kurmak için CLI'yi npm create sanity@latest ile yükleyin, bir proje şablonu seçin, şema dosyalarınızı yapılandırın ve Studio'yu yerel olarak başlatmak için npx sanity dev çalıştırın. Tüm süreç 5 dakikadan az sürer.

Ön Koşullar ve Kurulum

Node.js 18+ ve npm (veya pnpm) gerekiyor. Hepsi bu kadar. Init komutunu çalıştırın:

npm create sanity@latest

# Şunlar sorulacak:
# - Oturum açma yöntemi (Google, GitHub, e-posta)
# - Proje adı
# - Veri seti adı (varsayılan: "production")
# - Proje şablonu (blog, eticaret, temiz)
# - TypeScript? (önerilen: evet)

CLI, ihtiyacınız olan her şeyle birlikte bir proje oluşturur. Proje yapısı şöyle görünür:

Proje Yapısı Açıklaması

my-sanity-project/
├── schemas/              # İçerik şemalarınız (zamanınızı burada geçireceksiniz)
│   ├── index.ts          # Şema kaydı -- tüm türleri içe ve dışa aktarır
│   ├── post.ts           # Doküman türü tanımları
│   └── blockContent.ts   # Zengin metin / Portable Text yapılandırması
├── sanity.config.ts      # Ana yapılandırma -- eklentiler, Studio yapısı, veri seti
├── sanity.cli.ts         # CLI yapılandırması -- proje ID, veri seti
├── package.json
└── tsconfig.json

sanity.config.ts dosyası giriş noktanızdır. Minimal bir örnek:

// sanity.config.ts
import { defineConfig } from 'sanity'
import { structureTool } from 'sanity/structure'
import { visionTool } from '@sanity/vision'
import { schemaTypes } from './schemas'

export default defineConfig({
  name: 'default',
  title: 'My Blog',
  projectId: 'your-project-id',
  dataset: 'production',
  plugins: [structureTool(), visionTool()],
  schema: { types: schemaTypes },
})

visionTool() eklentisi, Studio içinde bir GROQ playground sağlar — geliştirme sırasında sürekli kullanacaksınız.

Studio'nuzu Dağıtma

npx sanity dev ile yerel olarak başlatın (localhost:3333 üzerinde çalışır). Editörlerle paylaşmaya hazır olduğunuzda Sanity'nin CDN'ine dağıtın:

npx sanity deploy
# Bir ana makine adı sorar, örn. "my-blog"
# https://my-blog.sanity.studio adresine dağıtır

İpucu: Her şema değişikliğinin ardından npx sanity@latest schema deploy çalıştırın. Bu, şemanızı Sanity'nin API'sine yükler ve GraphQL API ile şema-farkında araçlar (daha sonra ele alacağımız MCP sunucusu dahil) gibi özellikleri etkinleştirir.

Sanity CMS'de Şema Tasarımı

Sanity şemaları, kod tabanınızda JavaScript veya TypeScript nesneleri olarak tanımlanır. Her şema, alanlar, doğrulama kuralları ve özel girdi bileşenleriyle bir doküman türü belirtir. Şema değişiklikleri anlıktır — veritabanı migrasyonu gerekmez. Bu "şema-kod-olarak" yaklaşımı, bizi Contentful yerine Sanity'yi seçmeye ikna eden şeydir.

Alan Türleri ve Doğrulama

Sanity, zengin bir alan türleri seti sunar. En çok kullandıklarımız:

Her alan, validation geri çağrısı aracılığıyla doğrulamayı destekler. Zorunlu alanlar, min/maks değerler, regex kalıpları ve özel kurallar zorunlu kılınabilir:

defineField({
  name: 'seoDescription',
  title: 'Meta Description',
  type: 'string',
  validation: (Rule) =>
    Rule.required()
      .min(145)
      .max(160)
      .warning('Meta description should be 145-160 characters'),
})

Özel Blok Türleri (Prodüksiyon Örneklerimiz)

İşte Sanity'nin ilginçleştiği yer — ve 6 rakip rehberin hiçbirinin kod göstermediği nokta. Prodüksiyon şemamızda gövde dizisi içinde beş özel blok türü tanımlıyoruz: block (standart metin), table, codeBlock, chartBlock ve inlineImage.

codeBlock tanımımız:

// schemas/objects/codeBlock.ts
import { defineType } from 'sanity'

export const codeBlock = defineType({
  name: 'codeBlock',
  title: 'Code Block',
  type: 'object',
  fields: [
    {
      name: 'language',
      title: 'Language',
      type: 'string',
      options: {
        list: [
          { title: 'JavaScript', value: 'javascript' },
          { title: 'TypeScript', value: 'typescript' },
          { title: 'Python', value: 'python' },
          { title: 'Bash', value: 'bash' },
          { title: 'JSON', value: 'json' },
          { title: 'GROQ', value: 'groq' },
        ],
      },
    },
    {
      name: 'code',
      title: 'Code',
      type: 'text',
    },
  ],
})

Gövde alanının tüm özel türlerimize birlikte nasıl başvurduğu:

// schemas/fields/body.ts
defineField({
  name: 'body',
  title: 'Body',
  type: 'array',
  of: [
    { type: 'block' },         // Standart Portable Text (paragraflar, başlıklar, listeler)
    { type: 'table' },         // @sanity/table eklentisi
    { type: 'codeBlock' },     // Özel kod bloğumuz
    { type: 'chartBlock' },    // Veri görselleştirme (çubuk, çizgi, pasta)
    { type: 'inlineImage' },   // Alt metin ve altyazılı görseller
  ],
})

Bu, editörlerimize zengin bir içerik araç seti sunarken her öğeyi yazılmış ve sorgulanabilir kılar. Bir chartBlock, opak bir HTML gömülü içeriği değil — chartType, title, dataPoints ve dataLabels alanlarına sahip yapılandırılmış veridir. Web, e-posta ve mobil genelinde aynı içeriği render etmeye çalışırken bu önemli.

Şema Organizasyonu En İyi Uygulamaları

Şemaları modüler tutun. Bizimkini türe göre dosyalara bölüyoruz: schemas/documents/post.ts, schemas/objects/codeBlock.ts, schemas/objects/chartBlock.ts. Hepsini schemas/index.ts içinde içe aktarın:

// schemas/index.ts
import { post } from './documents/post'
import { codeBlock } from './objects/codeBlock'
import { chartBlock } from './objects/chartBlock'
import { inlineImage } from './objects/inlineImage'

export const schemaTypes = [post, codeBlock, chartBlock, inlineImage]

Yapılandırılmış içerikle çalışmaktan edindiğimiz temel fikir şu: şemanız İÇERİK MODELİNİZDİR. Bunu, içerik ekibiniz için context engineering olarak düşünürseniz daha iyi tasarım kararları alırsınız. Eklediğiniz her alan bir amaca hizmet etmeli — editörler, render veya sorgulama için.

GROQ: Sanity'nin Sorgu Dili

GROQ (Graph-Relational Object Queries), JSON dokümanlarını filtrelemek, birleştirmek ve yansıtmak için Sanity'nin açık kaynaklı sorgu dilidir. Temel sözdizimi *[filter]{projection} şeklindedir — bir filtreyle eşleşen tüm dokümanları seçin, ardından çıktıyı şekillendirin. Sanity'ye özgü sorgular için GraphQL'den daha kısa ve deneyimimize göre öğrenmesi daha hızlı.

Temel Sorgular: Filtrele ve Yansıt

En basit sorgu, belirli türdeki tüm dokümanları getirir:

// Tüm gönderileri getir -- sadece başlık ve slug
*[_type == "post"]{
  title,
  "slug": slug.current
}

// Dile göre filtrele, yazar referansını genişlet
*[_type == "post" && language == "en"]{
  title,
  "slug": slug.current,
  "authorName": author->name,
  "authorImage": author->image,
  "categoryTitle": category->title,
  publishedAt
}

-> operatörü referansları takip eder. author->name, "yazar referansını takip et ve ad alanını döndür" anlamına gelir. Ayrı sorgular yok, N+1 sorunu yok, JOIN yok — hepsi tek bir ifade.

Birleştirmeler, Sıralama ve Sayfalandırma

Blog dizin sayfalarımız için genişletilmiş referanslarla sıralı, sayfalandırılmış gönderiler gerekiyor:

// Tam meta veriyle sayfalandırılmış gönderiler
*[_type == "post" && language == "en"] | order(publishedAt desc) [0...10] {
  title,
  "slug": slug.current,
  excerpt,
  publishedAt,
  readTime,
  "author": author->{name, image},
  "category": category->{title, "slug": slug.current},
  "coverImage": coverImage{
    "src": asset->url,
    alt
  }
}

[0...10] ilk 10 sonucu verir (0 indeksli, hariç tutulan son). | order(publishedAt desc) en yeniden eskiye sıralar. Projeksiyon, çıktıyı frontend'inizin ihtiyaç duyduğu şeyle tam olarak eşleşecek biçimde şekillendirir — fazlasını değil.

Tüm bu sorguları Sanity Studio içindeki Vision eklentisini kullanarak etkileşimli biçimde test edebilirsiniz. Geliştirme sırasında paha biçilmez. Daha fazla kalıp için GROQ kopya kağıdına bakın.

GROQ ve GraphQL

Sanity hem GROQ hem de GraphQL'i destekler. Hangisini ne zaman kullanmalısınız?

GROQ, Sanity'nin yerel dilidir. Birleştirmeleri, projeksiyonları ve hesaplanmış alanları tek bir sorgu dizisinde ele alır. Content Lake'in optimize edildiği dildir.

GraphQL, şemanızı dağıttıktan sonra (npx sanity@latest schema deploy) kullanılabilir. Standartlaşmış araçlara ihtiyacınız olduğunda kullanın — örneğin, frontend'inizde zaten Apollo Client kullanıyorsanız ya da ekibiniz GROQ'u değil GraphQL'i biliyorsa.

Biz yalnızca GROQ kullanıyoruz. Sanity verileri için daha ifade gücü yüksek ve Vision eklentisi hata ayıklamayı kolaylaştırıyor.

Portable Text: Zengin İçerik Doğru Yapıldığında

Portable Text, yapılandırılmış zengin metin için Sanity'nin spesifikasyonudur. İçeriği HTML dizileri olarak saklamak yerine, yazılmış blok dizisi olarak depolar — paragraflar, başlıklar, görseller, kod parçacıkları, tablolar — her biri JSON nesnesi olarak. Bu, içeriği herhangi bir framework'te, herhangi bir platformda, herhangi bir formatta render edilebilir kılar.

Veri Yapısı

Bir paragraf ve kod bloğunun Portable Text JSON olarak görünümü:

[
  {
    "_type": "block",
    "_key": "a1b2c3",
    "style": "normal",
    "markDefs": [],
    "children": [
      {
        "_type": "span",
        "_key": "d4e5f6",
        "text": "Here's an example of our pipeline config:",
        "marks": []
      }
    ]
  },
  {
    "_type": "codeBlock",
    "_key": "g7h8i9",
    "language": "typescript",
    "code": "export default defineConfig({ ... })"
  }
]

Her bloğun bir _type ve _key'i vardır. Standart metin blokları, alt span'larla birlikte (kalın, italik ve bağlantılar gibi işaretleri destekleyen) "block" kullanır. Özel bloklar — codeBlock, chartBlock, table ve inlineImage gibi — kendi _type'larını ve yapılandırılmış alanlarını taşır.

Bu neden önemli? Çünkü HTML bir depolama formatı değil, render formatıdır. Veritabanınızda <h2>Title</h2><p>Some <strong>text</strong></p> saklarsanız, kendinizi web render'ına kilitlersiniz. Bunu bir mobil uygulama, e-posta bülteni, PDF veya yapay zeka ajanının bağlam penceresi için temiz biçimde çıkaramazsınız. Portable Text, içeriği sunumdan ayırır. Portable Text spesifikasyonu açık kaynaklıdır — Sanity'ye özgü bir kilitleme değil.

Prodüksiyonda Özel Bloklar

Pipeline'ımız, Markdown'ı bir Python betiği (scripts/md_to_portable_text.py) kullanarak Portable Text'e dönüştürür. Dönüştürücü standart blokları ve dört özel türümüzü işler:

• table -- @sanity/table eklenti şemasını kullanır. Satırlar ve hücreler yapılandırılmış veri olarak saklanır.
• codeBlock -- Dil ve kod ayrı alanlar olarak, render sırasında sözdizimi vurgulamayı sağlar.
• chartBlock -- Grafik türü, başlık, eksen etiketleri, seri adları ve veri noktaları yapılandırılmış JSON olarak. Frontend bunları Chart.js ile render eder.
• inlineImage -- Alt metin, kaynak ve isteğe bağlı altyazı ayrı alanlar olarak.

Bu yapı, bloğumuzdaki tüm kod örneklerini sorgulamamızı (*[body[]._type == "codeBlock"]), grafik içeren gönderileri bulmamızı veya eksik alt metin içeren tüm görselleri çıkarmamızı sağlar — hepsi GROQ aracılığıyla.

Portable Text'i Render Etmek

Frontend'de @portabletext/react (veya Svelte/Vue eşdeğerlerini) kullanın. Her blok türü için özel bileşenler kayıt edersiniz:

import { PortableText } from '@portabletext/react'

const components = {
  types: {
    codeBlock: ({ value }) => (
      <pre className={`language-${value.language}`}>
        <code>{value.code}</code>
      </pre>
    ),
    chartBlock: ({ value }) => <Chart data={value} />,
    inlineImage: ({ value }) => (
      <figure>
        <img src={value.src} alt={value.alt} />
        {value.caption && <figcaption>{value.caption}</figcaption>}
      </figure>
    ),
  },
}

// Bileşeninizde:
<PortableText value={post.body} components={components} />

Render pipeline'ının tamamı bu kadar. PortableText bileşeni, standart blokları (paragraflar, başlıklar, listeler, işaretler) otomatik olarak ele alır. Yalnızca özel türleriniz için özel bileşenler tanımlarsınız.

Sanity CMS ile Çok Dilli İçerik

Sanity, çok dilli içeriği doküman düzeyi yerelleştirme (kanonik referansla bağlantılı dil başına ayrı dokümanlar) veya alan düzeyi yerelleştirme (tek doküman içinde çevrilmiş alanlar) aracılığıyla destekler. SEO ve büyük ölçekli yayıncılık için doküman düzeyi daha iyi çalışır — 10 dilli pipeline'ımızda kullandığımız yöntem budur.

Doküman Düzeyi ve Alan Düzeyi Yerelleştirme

Doküman düzeyi yerelleştirmeyi seçtik çünkü her çeviri kendi slug'ını, kendi URL'sini ve kendi meta verisini alıyor. Supabase - Firebase karşılaştırmasına ilişkin bir gönderinin Türkçe versiyonu supabase-firebase-karsilastirma slug'ını alıyor — düzgün Türkçe, URL parametresi hilesi değil.

10 Dilli Pipeline Mimarimiz

Otomatik pipeline'ımız şöyle çalışıyor: İngilizce bir gönderi yazıyoruz, ardından 9 ek dile çeviriyoruz (Almanca, Fransızca, Felemenkçe, İspanyolca, Türkçe, İtalyanca, İsveççe, Norveççe, Arapça). Her çeviri, Markdown dönüşümü, Portable Text üretimi ve Sanity API yayınlamasından geçiyor.

Mimari şöyle görünüyor:

1. Yaz -- YAML ön matter'lı İngilizce Markdown
2. Çevir -- 9 dile yapay zeka çevirisi (tamlık ve diakritikler için doğrulandı)
3. Dönüştür -- Python betiği her .md dosyasını Portable Text JSON'a çevirir
4. Yayımla -- Sanity'ye API çağrıları: doküman oluştur, görsel yükle, referansları bağla

Her dokümanın bir language alanı ve İngilizce orijinalini işaret eden bir canonicalPost referansı var. Bir gönderiyi ve tüm çevirilerini getiren GROQ sorgusu:

// Bir gönderiyi ve tüm çevirilerini getir
*[_type == "post" && slug.current == "sanity-cms-guide" && language == "en"][0]{
  title,
  language,
  "translations": *[
    _type == "post" &&
    canonicalPost._ref == ^._id
  ]{
    title,
    language,
    "slug": slug.current
  }
}

Şema tarafı basit — desteklenen dillerin enum'unu içeren bir language alanı:

defineField({
  name: 'language',
  title: 'Language',
  type: 'string',
  options: {
    list: [
      { title: 'English', value: 'en' },
      { title: 'German', value: 'de' },
      { title: 'French', value: 'fr' },
      { title: 'Dutch', value: 'nl' },
      { title: 'Spanish', value: 'es' },
      { title: 'Turkish', value: 'tr' },
      { title: 'Italian', value: 'it' },
      { title: 'Swedish', value: 'sv' },
      { title: 'Norwegian', value: 'no' },
      { title: 'Arabic', value: 'ar' },
    ],
  },
  validation: (Rule) => Rule.required(),
})

Zor yoldan öğrendiğimiz bir şey: İngilizce dokümanı önce yayımlayın, ardından çevirilerdeki canonicalPost referanslarını drafts. öneki olmadan yayımlanmış doküman ID'si kullanarak bağlayın. Sanity, taslak ve yayımlanmış dokümanları dahili olarak ayrı varlıklar olarak ele alır.

Bu pipeline'ın Model Context Protocol ile nasıl bağlandığı hakkında daha fazla ayrıntı için sonraki bölüme bakın.

Sanity Yapay Zeka Özellikleri: MCP, Canvas ve Agent Context

Sanity, kendisini yapay zeka çağının içerik işletim sistemi olarak konumlandırıyor. Temel yapay zeka özellikleri şunlar: yapay zeka ajanlarının içeriği okuyup yazması için bir MCP sunucusu, Studio içinde yapay zeka destekli düzenleme için Canvas ve prodüksiyon yapay zeka ajanlarının yapılandırılmış içeriği şema farkındalığıyla sorgulaması için Agent Context.

MCP Sunucu Entegrasyonu

Sanity MCP sunucusu, yapay zeka ajanlarının — Claude Code, Cursor, Windsurf ve diğerlerinin — Sanity çalışma alanınızla programatik olarak etkileşime girmesini sağlar. Ajanlar, şemaları okuyabilir, GROQ sorguları çalıştırabilir, doküman oluşturabilir ve özel API sarmalayıcıları olmaksızın içeriği yönetebilir.

Sanity MCP sunucusunu içerik pipeline'ımızda her gün kullanıyoruz. Yapay zeka ajanlarımız, doküman yapısını anlamak için şemayı sorgular, iç bağlantı fırsatları bulmak için mevcut gönderileri getirir ve yeni dokümanlar yayımlar. MCP protokolü ajanlara şema farkındalığı sağlar — hangi alanların var olduğunu, hangi türleri beklediklerini ve hangi doğrulama kurallarının geçerli olduğunu bilirler. İşletmeler için yapay zeka ajanları iş akışları oluşturuyorsanız, bu güçlü bir kalıp.

Prodüksiyon Yapay Zeka için Agent Context

Agent Context, prodüksiyon düzeyindeki yapay zeka entegrasyonları için ayrı bir özelliktir. MCP sunucusundan (geliştirici araçları için tasarlanmış) farklı olarak, Agent Context; çalışma zamanında içeriğinizi sorgulaması gereken yapay zeka ajanları için salt okunur, kapsamlı erişim sağlar — chatbot'lar, öneri motorları veya içerik kişiselleştirme sistemleri düşünün.

Fark önemlidir: MCP, derleme zamanı ve editoryal iş akışları içindir (şema-farkında geliştirme araçları), Agent Context ise uygun kimlik doğrulama ve hız sınırlamasıyla çalışma zamanı içerik erişimi içindir.

Sanity'nin yapılandırılmış içeriği burada gerçek bir avantaj sağlıyor. WordPress sitesi içeriği HTML blob'ları olarak depolar — bir yapay zeka ajanının içeriği anlaması için HTML'i ayrıştırması gerekir. Sanity, tanımlanmış şemalarla yazılmış JSON dokümanları depolar. Bir ajan *[_type == "product" && category == "electronics"]{name, price, features} sorgulayabilir ve temiz, yapılandırılmış veri alır. Kazıma yok, ayrıştırma yok, tahmin yok.

Sanity'yi Techsy'de Nasıl Kullanıyoruz

Bu hipotetik bir bölüm değil. Sanity CMS'i 4 prodüksiyon web sitesinde, geçtiğimiz yıl boyunca oluşturduğumuz otomatik pipeline ile 10 dilde yayın yaparak çalıştırıyoruz. Mimari şöyle:

İçerik Pipeline Mimarimiz

Pipeline, araştırmadan tüm 10 dilde yayımlanmış gönderiye kadar gidiyor:

1. Araştır -- anahtar kelime analizi, rakip boşluk tespiti, SERP kalıpları
2. Brifing -- bölüm rehberliği, kelime sayıları, iç bağlantılarla yapılandırılmış yazı spesifikasyonu
3. Yaz -- YAML ön matter'lı İngilizce Markdown üret
4. Dönüştür -- Python betiği Markdown'ı 5 özel blok türümüzle Portable Text JSON'a çevirir
5. Yayımla -- Sanity'ye API çağrıları: createOrReplace doküman, görselleri Sanity CDN'e yükle, yazar/kategori referanslarını bağla
6. Çevir -- 9 dile yapay zeka çevirisi, tamlık için doğrulandı
7. Çevirileri yayımla -- dil başına aynı dönüştür/yayımla akışı, canonicalPost referansı İngilizce orijinaline bağlı

Özel şema, block, table, codeBlock, chartBlock ve inlineImage türlerini destekler — hepsi doğrulama kurallarıyla prodüksiyon Sanity şema nesneleri olarak tanımlanmış. Test ettiğimiz startuplar için en iyi yapay zeka araçları arasında bu Sanity tabanlı pipeline, ölçekte yapılandırılmış içerik için en güvenilir oldu.

400'den Fazla Yayımlanmış İçerikten Öğrendiklerimiz

Keşke biri başta söyleseydi dediğimiz birkaç şey:

Referans bağlama sırası önemlidir. Sanity referansları henüz mevcut olmayan dokümanlara işaret edemez. Önce İngilizce gönderiyi yayımlayın, ardından çevirileri İngilizce dokümanın yayımlanmış ID'sine işaret eden canonicalPost ile oluşturun. Bunu başlangıçta defalarca bozduk.

Şema dağıtımı çalışma alanı başınadır. Birden fazla Sanity projesi çalıştırıyorsanız (biz 4 çalıştırıyoruz), şemaları her birine ayrı ayrı dağıtmanız gerekir: proje yapılandırması başına npx sanity@latest schema deploy.

Ücretsiz katman gerçek. Dört sitemizin ikisini aylarca ücretsiz planda çalıştırdık. 20 kullanıcı, ayda 500K API isteği, 100K CDN isteği — bir oyuncak proje için değil, gerçek bir prodüksiyon sitesi için yeterli.

Portable Text dönüşümü darboğazdır. Markdown'dan Portable Text'e geçiş önemsiz değil. Blok alıntılar içindeki iç içe listeler, tablolar, özel karakterli kod blokları — her yerde sınır durumlar. Dönüştürücü betiğimizi aylarca geliştirmeye devam ettik.

Projeniz için Sanity kurulumunda yardıma mı ihtiyacınız var? 4 prodüksiyon sitesi için çok dilli içerik pipeline'ları oluşturduk. Ücretsiz danışmanlık alın

Sanity CMS Fiyatlandırma Analizi

Sanity üç plan sunuyor: Ücretsiz (20 kullanıcı, ayda 500K API isteği), Growth (kullanıcı başına 15$/ay, gelişmiş roller ve zamanlanmış taslaklar) ve Kurumsal (SLA ve uyumluluk özellikleriyle özel fiyatlandırma). Ücretsiz katman, headless CMS pazarındaki en cömert ücretsiz plandır.

Ücretsiz katmanda, iki sitemizi limitlere ulaşmadan çalıştırıyoruz. Kullanıcı başına 15$/ay'lık Growth planı, rol tabanlı erişim (teknik olmayan editörlerimiz olduğunda önemli olan) ve zamanlanmış yayın ekledi. Growth'ta izleyiciler ücretsiz — bu güzel bir dokunuş, paydaşlara okuma erişimi vermek için ceza ödenmiyorsunuz.

Rakiplerle karşılaştırıldığında:

Sanity'nin 20 kullanıcılı ücretsiz katmanı istisnai. Contentful ücretsiz sürümde sizi 1 kullanıcıyla sınırlıyor ve Team planı için 300$/aya çıkıyor. Bir startup veya küçük ekipseniz, Sanity'nin ücretsiz planı herhangi bir şey ödemeden gerçek prodüksiyon iş yüklerini çalıştırmanıza izin veriyor.

Sanity ayrıca, uygun startuplara bir yıl ücretsiz Growth erişimi veren bir startup programı sunuyor. Hak kazanıyorsanız başvurmaya değer.

Sıkça Sorulan Sorular

Sanity CMS nedir ve nasıl çalışır?

Sanity CMS, yapılandırılmış JSON dokümanlarını Content Lake adı verilen yönetilen bir backend'de depolayan headless bir içerik platformudur. İçeriği Sanity Studio (özelleştirilebilir bir React uygulaması) aracılığıyla düzenler, GROQ veya GraphQL ile sorgular ve herhangi bir frontend framework'ünde render edersiniz. İçerik, bağlı tüm istemcilerde gerçek zamanlı senkronize olur.

Sanity CMS ücretsiz mi?

Evet. Sanity'nin ücretsiz katmanı, ayda 20 kullanıcı, 500K API isteği ve 100K CDN isteği içeriyor — headless CMS platformları arasındaki en cömert ücretsiz plan. Growth planı, kullanıcı başına aylık 15$ olup rol tabanlı erişim, zamanlanmış yayın ve daha yüksek limitler ekler. Kurumsal fiyatlandırma ise özeldir.

Sanity ve Contentful arasındaki fark nedir?

Sanity, şema-kod-olarak yaklaşımı (şemalar kod tabanınızda yaşar), GROQ sorgulama ve tam özelleştirilebilir açık kaynaklı Studio kullanır. Contentful, GUI tabanlı içerik modelleme, GraphQL ve daha az özelleştirmeyle barındırılan bir editör kullanır. Sanity'nin ücretsiz katmanında Contentful'un 1'ine karşılık 20 kullanıcı var. Contentful'un daha büyük bir eklenti pazaryeri var.

Sanity CMS yeni başlayanlar için uygun mu?

Sanity Studio, içerik editörleri için sezgiseldir — düzenleme deneyimi teknik bilgi gerektirmez. Ancak şema kurulumu JavaScript veya TypeScript yetkinliği gerektirir. Sanity, mükemmel belgeler, proje şablonları ve aktif destek içeren bir topluluk Slack'i sunuyor. npm create sanity@latest ve blog şablonuyla başlayın.

Sanity'yi kendi sunucumda barındırabilir miyim?

Sanity Studio tamamen kendi başınıza barındırılabilir çünkü açık kaynaklı bir React uygulaması. Vercel, Netlify veya herhangi bir statik barındırma sağlayıcısına dağıtabilirsiniz. Content Lake backend'i yönetilen bir hizmettir — veri katmanı için kendi sunucunuzda barındırma seçeneği yoktur. Bu bir ödünleşimdir: sıfır altyapı yönetimi elde edersiniz ancak şirket içi veri kontrolü elde edemezsiniz.

Sanity hangi tür veritabanı kullanır?

Sanity'nin Content Lake'i geleneksel bir SQL veya NoSQL veritabanı değil. Üzerinde GROQ sorgu katmanıyla yapılandırılmış JSON olarak içerik depolayan yönetilen bir doküman deposudur. Temel veritabanıyla doğrudan etkileşime girmezsiniz — Sanity'nin API'leri aracılığıyla etkileşirsiniz. Dokümanlar, yerleşik olarak tam sürüm geçmişi ve gerçek zamanlı senkronizasyona sahip.

Sanity CMS açık kaynak mı?

Sanity Studio, MIT lisansı altında açık kaynaklıdır — onu fork'layabilir, özelleştirebilir ve kendi başınıza barındırabilirsiniz. Content Lake backend, tescilli SaaS'tır. GROQ sorgu dili spesifikasyonu da açık kaynaklıdır, GitHub'da yayımlanmıştır. Portable Text spesifikasyonu da açık kaynaklıdır, portabletext.org adresinde korunmaktadır.

Sanity'de Portable Text nedir?

Portable Text, yapılandırılmış zengin metin için Sanity'nin spesifikasyonudur. İçeriği HTML dizileri olarak saklamak yerine, paragrafları, başlıkları, görselleri ve özel blokları bir dizideki yazılmış JSON nesneleri olarak temsil eder. Bu, içeriği framework'ler ve platformlar arasında taşınabilir kılar. Kod parçacıkları, grafikler ve tablolar gibi özel blok türlerini kendi yapılandırılmış alanlarıyla tanımlayabilirsiniz.

GROQ nedir ve GraphQL'den farkı nedir?

GROQ (Graph-Relational Object Queries), Sanity'nin yerel sorgu dilidir. *[filter]{projection} sözdizimi, Sanity verileri için GraphQL'den daha kısadır; -> operatörü aracılığıyla birleştirme ve hesaplanmış alanlara yerleşik destek sunar. GraphQL, standartlaşmış araçları tercih eden ya da Apollo Client'ı kullanan ekipler için de mevcuttur.

Sanity çok dilli içeriği nasıl ele alır?

Sanity, doküman düzeyi yerelleştirmeyi (kanonik referanslarla bağlantılı dil başına ayrı dokümanlar) ve alan düzeyi yerelleştirmeyi (tek doküman içinde çevrilmiş alanlar) destekler. Her çeviri kendi URL'sini ve meta verisini aldığından, doküman düzeyi SEO için daha iyidir. Otomatik çeviri ve yayın pipeline'larıyla 10 dilde yayın yapmak için doküman düzeyi yerelleştirme kullanıyoruz.