<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Zeynep Sevgi on Medium]]></title>
        <description><![CDATA[Stories by Zeynep Sevgi on Medium]]></description>
        <link>https://medium.com/@zeyneppsevgi?source=rss-f9bd6e56f8cf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dd7ah16UirYyxXSrU-wwmw.png</url>
            <title>Stories by Zeynep Sevgi on Medium</title>
            <link>https://medium.com/@zeyneppsevgi?source=rss-f9bd6e56f8cf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 21:22:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@zeyneppsevgi/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Aynı Event Birden Fazla Kez Geldiğinde Ne Yaparsınız?]]></title>
            <link>https://medium.com/@zeyneppsevgi/ayn%C4%B1-event-birden-fazla-kez-geldi%C4%9Finde-ne-yapars%C4%B1n%C4%B1z-bc08a4a9f2d4?source=rss-f9bd6e56f8cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc08a4a9f2d4</guid>
            <category><![CDATA[kafka]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Zeynep Sevgi]]></dc:creator>
            <pubDate>Wed, 24 Jun 2026 09:00:41 GMT</pubDate>
            <atom:updated>2026-06-24T09:00:41.883Z</atom:updated>
            <content:encoded><![CDATA[<h3>Aynı Event Birden Fazla Kez Geldiğinde Ne Yaparsınız? Kafka Consumer Tasarımında Güvenilirlik: Idempotency, Retry, DLQ ve Inbox Pattern</h3><p><em>Daha önce yayımladığım “Mikro Servislerde Veri Kaybını Önleme: Go ile Transactional Outbox, Saga ve Idempotency” başlıklı yazımda, mikro servis mimarilerinde veri tutarlılığı ve güvenilir mesajlaşma problemlerini ele almıştım.</em></p><p><em>Bu yazıda ise odağı Kafka consumer tarafına çevirerek; duplicate event’ler, retry mekanizmaları, Dead Letter Queue (DLQ), offset yönetimi, idempotent consumer tasarımı ve Inbox Pattern gibi konular üzerinden güvenilir event tüketimini inceleyeceğim.</em></p><p><a href="https://medium.com/@zeyneppsevgi/mikro-servislerde-veri-kayb%C4%B1n%C4%B1-%C3%B6nleme-go-ile-transactional-outbox-saga-ve-idempotency-d3da76b54ea1"><strong><em>Önceki yazıya bağlantıdan ulaşabilirsiniz.</em></strong></a></p><p>Modern e-ticaret platformlarında kullanıcıların ürün satın almadan önce soru sorabilmesi, hem kullanıcı deneyimini güçlendiren hem de satın alma kararını doğrudan etkileyen önemli bir özellik haline geldi. İlk bakışta bu süreç yalnızca kullanıcının soru oluşturması ve satıcının cevap vermesinden ibaret gibi görünse de, işin arka planında moderasyon süreçleri, bildirim mekanizmaları ve çeşitli iş kuralları gibi birçok bileşen birlikte çalışıyor.</p><p>Geliştirdiğim ürün soru-cevap sistemi üzerinde çalışırken, bu akışın yalnızca fonksiyonel gereksinimlerden ibaret olmadığını; aynı zamanda dağıtık sistemlerde güvenilir veri işleme problemlerini de beraberinde getirdiğini gördüm. Özellikle kullanıcıya gönderilecek bildirimlerin kaçırılmaması, aynı olayın birden fazla kez işlenmesinin engellenmesi ve servisler arası iletişimin dayanıklı hale getirilmesi kritik önem taşıyordu.</p><p>Bu yazıda, ürün soru-cevap sisteminin teknik altyapısını anlatırken Kafka consumer tarafında uyguladığımız güvenilir tüketim yaklaşımını ele alacağım. Özellikle retry mekanizmaları, Dead Letter Queue (DLQ), offset yönetimi, idempotent işlem tasarımı ve Inbox Pattern gibi dağıtık sistemlerde sıkça kullanılan yöntemlerin gerçek bir senaryo üzerindeki kullanımını paylaşacağım.</p><p>İş Akışı</p><p>Sistemde kullanıcılar ürünler hakkında soru oluşturabiliyor, satıcılar ise bu soruları cevaplayabiliyor. Ancak hem sorular hem de cevaplar doğrudan yayınlanmıyor. İçerikler önce moderasyon sürecinden geçiyor.</p><p>Basitleştirilmiş akış şu şekilde:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b_FunjW2wMEcOwH3xd6NlA.png" /></figure><p>Admin cevabı reddederse cevap kullanıcıya gösterilmez ve satıcı panelinde reddedildi bilgisi görüntülenir.</p><p>Bu akış ilk bakışta basit görünse de sistemin yalnızca soru ve cevap kaydetmekten ibaret olmadığını kısa sürede görürüz. Çünkü işin içinde moderasyon, kullanıcı deneyimi, bildirim, cache invalidation, arama indekslerinin güncellenmesi ve domain kuralları vardır.</p><h3>Domain Kuralları Mimariyi Nasıl Etkiler?</h3><p>Backend geliştirme süreçlerinde çoğu zaman teknik problemlerden önce iş kurallarıyla karşılaşırız. Bu sistemde bunun en belirgin örneklerinden biri, kullanıcıların aynı ürün için sınırsız sayıda bekleyen soru oluşturamamasıydı.</p><p>Tanımladığımız iş kuralı şuydu:</p><p>Bir kullanıcı, aynı ürün için cevap bekleyen aktif bir sorusu varken yeni bir soru oluşturamaz.</p><p>Bu kuralın birkaç temel amacı var:</p><ul><li>Spam içerik oluşumunu engellemek</li><li>Satıcıların aynı kullanıcıdan gelen çok sayıda bekleyen soruyla karşılaşmasını önlemek</li><li>Moderasyon yükünü azaltmak</li><li>Soru-cevap kalitesini artırmak</li></ul><p>Bu nedenle soru oluşturma süreci yalnızca bir INSERT işleminden ibaret değildir. Yeni soru oluşturulmadan önce sistemin şu kontrolleri yapması gerekir:</p><ul><li>Kullanıcının ilgili ürün için aktif bir sorusu var mı?</li><li>Bu soru cevap bekliyor mu?</li><li>Moderasyon süreci devam ediyor mu?</li></ul><p>Ancak bu kontroller başarıyla geçildikten sonra yeni soru oluşturulabilir.</p><h3>Neden Asenkron Bir Yapı Tercih Ettik?</h3><p>Admin bir cevabı onayladığında sistemde birden fazla işlem tetiklenir:</p><ul><li>Veritabanında cevap yayınlanabilir hale getirilir.</li><li>Kullanıcıya bilgilendirme e-postası gönderilir.</li><li>Arama indeksleri güncellenir.</li><li>Redis cache’i temizlenir veya yeniden oluşturulur.</li></ul><p>İlk bakışta tüm bu işlemler senkron şekilde yapılabilir gibi görünebilir. Ancak sistem büyüdükçe bu yaklaşım bazı riskler doğurur.</p><p>Örneğin mail servisi geçici olarak yavaşlayabilir, Elasticsearch kısa süreli erişilemez hale gelebilir veya cache temizleme sırasında timeout oluşabilir. Bu tarz yan etkilerin cevap yayınlama akışını bloklamasını istemedik.</p><p>Bu nedenle cevap onaylandığında sistem bir event üretir:</p><pre>AnswerApproved</pre><p>Bu event’i farklı consumer’lar dinler:</p><pre>Mail Consumer   → Kullanıcıya bilgilendirme e-postası gönderir<br>Search Consumer → Elasticsearch indeksini günceller<br>Cache Consumer  → İlgili cache kayıtlarını temizler</pre><blockquote><strong>Bu yapı servisleri birbirinden ayırır ve sistemi daha ölçeklenebilir hale getirir. Fakat burada yeni bir problem ortaya çıkar:</strong></blockquote><p><strong>Bir consumer aynı event’i birden fazla kez işlerse ne olur?</strong></p><p><strong>Ya da mail gönderimi başarılı olduktan sonra consumer offset commit edemeden çökerse?</strong></p><p>Güvenilir consumer tasarımının asıl önemi burada başlar.</p><h3>Duplicate Event Problemi</h3><p>Event-driven mimarilerde en sık karşılaşılan problemlerden biri aynı event’in birden fazla kez işlenmesidir.</p><p>Kafka kullanıldığında her mesajın yalnızca bir kez işleneceği düşünülebilir. Fakat pratikte network problemleri, consumer restart’ları, rebalance, servis çökmesi veya offset commit zamanlaması nedeniyle aynı event tekrar işlenebilir.</p><p>Örneğin AnswerApproved event&#39;ini dinleyen bir mail consumer olduğunu düşünelim.</p><p>Normal akış şu şekilde olabilir:</p><pre>Event Kafka&#39;ya yazılır<br>↓<br>Consumer event&#39;i alır<br>↓<br>Kullanıcıya e-posta gönderilir<br>↓<br>Offset commit edilir</pre><p>Ancak production ortamında şu senaryo yaşanabilir:</p><pre>Consumer event&#39;i aldı<br>↓<br>E-posta başarıyla gönderildi<br>↓<br>Consumer offset commit etmeden hemen önce çöktü</pre><p>Consumer tekrar ayağa kalktığında Kafka aynı event’i yeniden verebilir. Sonuç olarak kullanıcı aynı e-postayı ikinci kez alabilir.</p><p>Benzer şekilde duplicate event’ler şu problemlere yol açabilir:</p><ul><li>Aynı bildirimin birden fazla kez oluşturulması</li><li>Elasticsearch indeksinin gereksiz yere tekrar güncellenmesi</li><li>Cache invalidation işlemlerinin tekrar çalışması</li><li>Gereksiz kaynak tüketimi</li><li>Kullanıcı deneyiminin bozulması</li></ul><p>Bu yüzden consumer geliştirirken temel varsayımımız şu olmalıdır:</p><p>Bir event en az bir kez teslim edilebilir ve aynı event birden fazla kez işlenmeye çalışılabilir.</p><h3>Exactly Once Beklentisi Neden Tehlikelidir?</h3><p>Kafka tarafında exactly-once semantics gibi mekanizmalar bulunsa da, işin içine dış sistemler girdiğinde bu garanti tek başına yeterli olmaz. Özellikle e-posta gönderimi, SMS servisleri veya üçüncü parti entegrasyonlar gibi işlemler Kafka’nın kontrol alanının dışındadır.</p><p>Ürün soru-cevap sistemi üzerinde çalışırken bizim için de kritik noktalardan biri buydu. Event’in Kafka içerisinde yalnızca bir kez işlenmesi ile dış dünyada yalnızca bir kez yan etki oluşturulması aynı şey değildir.</p><p>Örneğin kullanıcıya bilgilendirme e-postası gönderdiğimizi düşünelim. Mail servisi isteği başarıyla işlemiş olabilir ancak tam bu noktada consumer kapanabilir veya offset commit işlemi gerçekleşemeyebilir. Consumer yeniden ayağa kalktığında Kafka aynı event’i tekrar teslim edebilir ve aynı e-postanın ikinci kez gönderilmesine neden olabilir.</p><pre>Mail gönderildi<br>↓<br>Consumer çöktü<br>↓<br>Kafka offset commit edilemedi<br>↓<br>Aynı event tekrar işlendi</pre><p>Bu durumda Kafka tarafında ne kadar dikkatli olursak olalım, dış dünyaya yapılan yan etkinin tekrar oluşma ihtimali vardır.</p><p>Bu yüzden pratik hedef çoğu zaman “mutlak exactly-once” değildir. Daha gerçekçi hedef şudur:</p><p>Consumer’ları idempotent ve tekrar çalıştırılabilir tasarlamak.</p><p>At-least-once delivery yaklaşımında ise dikkate alınması gereken konu event versiyonlamasıdır. Ürün soru-cevap sistemi gibi senaryolarda bu her zaman kritik olmayabilir. Ancak stok, fiyat veya ürün durumu gibi sürekli değişen verilerde yalnızca event’in işlenmiş olması yeterli değildir; doğru versiyonun işlenmiş olması gerekir.</p><p>Örneğin bir ürünün stok bilgisi için sırasıyla versiyon 10 ve versiyon 11 event’leri üretilmiş olsun. Çeşitli nedenlerle versiyon 11 önce işlenip daha sonra versiyon 10 işlenirse sistem eski veriye geri dönebilir.</p><p>Bu nedenle bu tip domain’lerde event’lere versiyon bilgisi eklenmesi ve consumer tarafında son işlenen versiyonun takip edilmesi önemlidir. Gelen event’in versiyonu mevcut versiyondan eskiyse event güvenli şekilde yok sayılabilir. Böylece yalnızca event’in işlenmesi değil, en güncel durumun korunması da garanti altına alınmış olur.</p><p>Yani aynı event tekrar geldiğinde sistemin aynı sonucu üretmesini ve kullanıcıya zarar veren yan etkiler oluşturmamasını hedefleriz.</p><h3>Idempotency Neden Gereklidir?</h3><p>Bir işlemin idempotent olması, aynı event kaç kez işlenirse işlensin sistemde aynı sonucu üretmesi anlamına gelir.</p><p>Örneğin admin tarafından onaylanan bir cevap için aşağıdaki event üretilmiş olsun:</p><pre>{<br>  &quot;eventId&quot;: &quot;8f4b3c12&quot;,<br>  &quot;eventType&quot;: &quot;AnswerApproved&quot;,<br>  &quot;questionId&quot;: &quot;q-1234&quot;,<br>  &quot;answerId&quot;: &quot;a-456&quot;,<br>  &quot;userId&quot;: &quot;u-789&quot;,<br>  &quot;productId&quot;: &quot;p-111&quot;<br>}</pre><p>Mail consumer bu event’i işlediğinde önce event’in daha önce işlenip işlenmediğini kontrol eder. Eğer daha önce işlenmişse tekrar mail göndermez.</p><p>Basit bir yaklaşımda aşağıdaki gibi bir tablo kullanılabilir:</p><pre>CREATE TABLE processed_events (<br>    event_id VARCHAR PRIMARY KEY,<br>    processed_at TIMESTAMP NOT NULL<br>);</pre><p>Consumer akışı ilk bakışta şöyle düşünülebilir:</p><pre>Event alınır<br>↓<br>event_id kontrol edilir<br>↓<br>Kayıt varsa işlem sonlandırılır<br>↓<br>Kayıt yoksa iş mantığı çalıştırılır<br>↓<br>Event işlenmiş olarak kaydedilir</pre><p>Bu yaklaşım duplicate event problemini azaltır. Ancak burada dikkat edilmesi gereken önemli bir nokta vardır.</p><p>Eğer önce event_id kontrol edilip sonra kayıt atılıyorsa, eş zamanlı çalışan iki consumer instance aynı anda event_idkaydını göremeyebilir. İkisi de event&#39;in işlenmediğini düşünüp aynı işi başlatabilir.</p><p>Bu yüzden idempotency kontrolü mümkün olduğunca atomic yapılmalıdır.</p><p>Örneğin veritabanında:</p><pre>INSERT INTO processed_events (event_id, processed_at)<br>VALUES ($1, NOW())<br>ON CONFLICT (event_id) DO NOTHING;</pre><p>atomik işlemler tercih edilebilir.</p><p>Buradaki amaç “önce kontrol et, sonra yaz” yaklaşımından kaçınmaktır. Çünkü distributed sistemlerde check-then-act akışı race condition üretmeye çok müsaittir.</p><h3>Offset Commit Stratejisi</h3><p>Kafka consumer tasarımında offset’in ne zaman commit edildiği oldukça kritiktir.</p><p>Basitleştirilmiş olarak iki riskten bahsedebiliriz:</p><ul><li>Offset çok erken commit edilirse event kaybedilebilir.</li><li>Offset çok geç commit edilirse event tekrar işlenebilir.</li></ul><p>Örneğin consumer event’i aldıktan hemen sonra offset commit ederse ve iş mantığı sırasında çökerse, Kafka bu event’i tekrar göndermeyebilir. Bu durumda event kaybedilmiş olur.</p><p>Diğer taraftan consumer iş mantığını tamamladıktan sonra offset commit etmeden çökerse, event tekrar okunabilir. Bu durumda duplicate processing oluşabilir.</p><p>Bu nedenle consumer tasarımında duplicate event ihtimali bir istisna değil, beklenen bir durum olarak ele alınmalıdır.</p><p>Genel yaklaşım şu şekilde olabilir:</p><pre>Inbox Pattern kullandığımız senaryoda akış biraz farklıdır:<br><br>Event Kafka&#39;dan alınır<br>↓<br>Payload validate edilir<br>↓<br>Geçersiz event ise DLQ&#39;ya gönderilir<br>↓<br>Offset commit edilir<br><br>Geçerli event ise<br>↓<br>Inbox tablosuna atomic şekilde kaydedilir<br>↓<br>Offset commit edilir<br>↓<br>Inbox Worker event&#39;i işler<br>↓<br>Başarılı olursa status = PROCESSED<br>↓<br>Geçici hata oluşursa retry edilir<br>↓<br>Retry limiti aşılırsa DLQ&#39;ya taşınır<br></pre><blockquote>Bu yaklaşımda Kafka consumer’ın sorumluluğu event’i güvenli şekilde inbox’a kaydetmektir. İş mantığı ise daha sonra worker tarafından yürütülür.</blockquote><p>Fakat burada da şunu unutmamak gerekir:</p><p>Offset commit ile dış sistemlere yapılan işlemleri tek bir transaction içinde garanti etmek çoğu zaman mümkün değildir. Bu yüzden idempotency ve retry mekanizmaları consumer tasarımının temel parçası olmaya devam eder.</p><p>Bu akış tek bir worker çalıştığında yeterli görünse de, üretim ortamlarında genellikle aynı consumer servisinden birden fazla instance çalışır. Bu durumda birden fazla worker aynı anda inbox tablosundaki PENDING kayıtları almaya çalışabilir.</p><p>Bu nedenle worker’ların aynı event’i eş zamanlı olarak işlememesi için kayıtların güvenli şekilde claim edilmesi gerekir. Aksi halde iki farklı worker aynı event’i işlenmemiş olarak görüp aynı işi başlatabilir.</p><p>Bu problemi önlemek için veritabanı seviyesinde satır kilitleme veya atomic claim mekanizmaları kullanılabilir. Örneğin SQL tarafında FOR UPDATE SKIP LOCKED yaklaşımı tercih edilebilir:</p><pre>SELECT *<br>FROM consumer_inbox<br>WHERE status = &#39;PENDING&#39;<br>ORDER BY created_at<br>LIMIT 100<br>FOR UPDATE SKIP LOCKED;</pre><pre>BEGIN;<br><br>SELECT ...<br>FOR UPDATE SKIP LOCKED;<br><br>UPDATE consumer_inbox<br>SET status = &#39;PROCESSING&#39;<br>...<br><br>COMMIT;</pre><p>Yalnızca SELECT FOR UPDATE SKIP LOCKED yapmak kalıcı claim anlamına gelmez; transaction bittiğinde lock kalkar.</p><p>Bu nedenle birçok sistemde worker event’i aldıktan sonra kaydın durumunu PENDING’den PROCESSING’e günceller. Böylece transaction sonlansa bile event’in bir worker tarafından sahiplenildiği görülebilir.</p><p>Böylelikle bir worker tarafından alınan kayıtlar diğer worker’lar tarafından görülmez ve aynı event’in eş zamanlı olarak işlenmesi engellenir.</p><p>Inbox Pattern kullanıldığında güvenilirlik yalnızca event’i saklamakla sınırlı değildir; aynı zamanda event’in yalnızca bir worker tarafından işlenmesini sağlayacak concurrency kontrolünün de doğru tasarlanması gerekir. Offset commit ile dış sistemlere yapılan işlemleri tek bir transaction içinde garanti etmek çoğu zaman mümkün değildir.</p><h3>Geçici Hatalar ve Retry Mekanizması</h3><p>Duplicate event problemini idempotency ile kontrol altına almaya çalışsak da çözmemiz gereken tek problem bu değildir.</p><p>Dağıtık sistemlerde servislerin her zaman erişilebilir olduğunu varsayamayız. Örneğin AnswerApproved event&#39;i işlendiğinde mail servisine istek gönderdiğimizi düşünelim.</p><p>Bu sırada şu hatalar oluşabilir:</p><ul><li>SMTP servisi geçici olarak erişilemez olabilir.</li><li>Ağ bağlantısında kısa süreli kesinti yaşanabilir.</li><li>E-posta sağlayıcısı timeout dönebilir.</li><li>Rate limit nedeniyle istek reddedilebilir.</li></ul><p>Bu tip hatalarda event’i ilk denemede başarısız kabul edip tamamen bırakmak veri kaybına neden olabilir. Çünkü birkaç saniye sonra sistem normale dönebilir.</p><p>Bu nedenle geçici hatalarda retry mekanizması kullanılır.</p><p>Örnek akış:</p><pre>1. deneme - başarısız -&gt; 5 saniye bekle<br>2. deneme - başarısız -&gt; 10 saniye bekle<br>3. deneme - başarılı</pre><p>Bu senaryoda event kaybedilmemiş olur ve kullanıcı bilgilendirme e-postasını almaya devam eder.</p><h3>Exponential Backoff ve Jitter</h3><p>Retry uygulanırken dikkat edilmesi gereken noktalardan biri denemeler arasındaki bekleme süresidir.</p><p>Başarısız olan bir isteği saniyede yüzlerce kez tekrar göndermek hem consumer tarafını hem de karşı servisi gereksiz yere zorlar. Bu nedenle genellikle exponential backoff yaklaşımı kullanılır.</p><p>Örnek:</p><pre>1. deneme → hemen<br>2. deneme → 5 saniye sonra<br>3. deneme → 10 saniye sonra<br>4. deneme → 20 saniye sonra<br>5. deneme → 40 saniye sonra</pre><p>Gerçek production ortamlarında buna çoğu zaman jitter da eklenir. Jitter, bekleme süresine küçük bir rastgelelik ekleyerek tüm consumer instance’larının aynı anda tekrar deneme yapmasını engeller.</p><p>Bu özellikle çok sayıda consumer’ın aynı bağımlı servise istek gönderdiği durumlarda önemlidir.</p><h3>Her Hata Retry Edilmeli midir?</h3><p>Hayır.</p><p>Retry mekanizmasının en kritik noktalarından biri, hangi hataların tekrar denenebilir olduğunu ayırt etmektir.</p><p>Örneğin aşağıdaki event’i düşünelim:</p><pre>{<br>  &quot;questionId&quot;: null,<br>  &quot;answerId&quot;: null<br>}</pre><p>Bu event mail servisi geçici olarak kapalı olduğu için başarısız olmuyor. Event’in kendisi hatalı. Bu event’i yüz kez retry etsek de sonuç değişmeyecektir.</p><p>Retry edilebilecek hata örnekleri:</p><ul><li>Network timeout</li><li>Rate limit</li><li>Geçici servis kesintisi</li><li>5xx servis hataları</li></ul><p>Retry edilmemesi gereken hata örnekleri:</p><ul><li>Zorunlu alanların eksik olması</li><li>Geçersiz veri formatı</li><li>Bozuk payload</li><li>İş kuralına aykırı veri</li><li>Kullanıcının bulunamaması gibi kalıcı domain hataları</li></ul><p>Bu ayrım yapılmadığında sistem bozuk event’leri sürekli tekrar işlemeye çalışır ve ana akışı yavaşlatır.</p><h3>Dead Letter Queue (DLQ)</h3><p>Bazı event’ler retry denemelerinin tamamına rağmen başarılı şekilde işlenemeyebilir. Bu durumda event’i sonsuza kadar yeniden işlemeye çalışmak doğru değildir.</p><p>Bu noktada Dead Letter Queue devreye girer.</p><p>Akış şu şekilde düşünülebilir:</p><pre>Kafka Topic<br>↓<br>Consumer<br>↓<br>Retry<br>↓<br>Retry<br>↓<br>Retry<br>↓<br>Dead Letter Queue</pre><p>Bir event belirlenen retry sayısını aştığında özel bir kuyruğa taşınır. Böylece:</p><ul><li>Ana consumer akışı bloke olmaz.</li><li>Diğer event’ler işlenmeye devam eder.</li><li>Problemli event daha sonra incelenebilir.</li><li>Gerekirse düzeltilip tekrar işlenebilir.</li></ul><p>Örneğin AnswerApproved event&#39;i beklenmeyen bir veri nedeniyle sürekli hata üretiyorsa, bu event DLQ&#39; ya gönderilebilir. Daha sonra bu event&#39;i inceleyip neden başarısız olduğunu analiz edebilir.</p><p>DLQ kullanırken event ile birlikte hata bilgisini de saklamak faydalıdır:</p><pre>{<br>  &quot;eventId&quot;: &quot;8f4b3c12&quot;,<br>  &quot;eventType&quot;: &quot;AnswerApproved&quot;,<br>  &quot;payload&quot;: {},<br>  &quot;error&quot;: &quot;missing userId&quot;,<br>  &quot;failedAt&quot;: &quot;2026-06-23T10:15:00Z&quot;,<br>  &quot;attemptCount&quot;: 5<br>}</pre><p><em>Bu sayede DLQ yalnızca bir çöp kutusu değil, incelenebilir ve gerektiğinde replay edilebilir bir hata izolasyon mekanizması haline gelir.</em></p><h3>Inbox Pattern ile Consumer Tarafında Güvenilirlik</h3><p>Kafka consumer geliştirirken yapılan yaygın hatalardan biri, consumer’ın görevinin mail göndermek, Elasticsearch güncellemek veya cache temizlemek olduğunu düşünmektir. Oysa consumer’ın asıl görevi event’i güvenli şekilde teslim almak ve kaybetmeyecek bir ortama taşımaktır.</p><p>Inbox Pattern kullandığımız yapıda bu ortam veritabanındaki inbox tablosudur. Event inbox’a başarıyla yazıldıktan sonra Kafka açısından görev tamamlanmış kabul edilir. Mail gönderimi, indeks güncellemesi veya diğer yan etkiler daha sonra worker’lar tarafından yönetilebilir.</p><p>Idempotency, retry ve DLQ birçok problemi çözer. Ancak hâlâ kritik bir soru vardır:</p><p>Bir event’in hangi aşamada olduğunu nasıl takip edeceğiz?</p><p>Örneğin consumer event’i aldı, mail göndermeye başladı ve tam o sırada servis kapandı. Event’in işlenip işlenmediğini, hangi adımda kaldığını ve tekrar ne yapılması gerektiğini bilmek zorlaşır.</p><p>Inbox Pattern burada devreye girer.</p><p>Inbox Pattern’ in temel amacı, tüketilen event’ leri consumer tarafında güvenli şekilde saklamaktır. Consumer event’i aldığında doğrudan iş mantığını çalıştırmak yerine önce kendi veritabanındaki inbox tablosuna yazar.</p><p>Örnek tablo:</p><pre>CREATE TABLE consumer_inbox (<br>    event_id VARCHAR PRIMARY KEY,<br>    event_type VARCHAR NOT NULL,<br>    payload JSONB NOT NULL,<br>    status VARCHAR NOT NULL,<br>    retry_count INT NOT NULL DEFAULT 0,<br>    last_error TEXT,<br>    created_at TIMESTAMP NOT NULL,<br>    processed_at TIMESTAMP<br>);</pre><p>Event ilk geldiğinde PENDING olarak kaydedilir:</p><pre>event_id  = 8f4b3c12asdf<br>status    = PENDING</pre><p>Daha sonra ayrı bir worker veya aynı consumer içindeki işlemci PENDING kayıtları işler. İşlem başarılı olursa kayıt PROCESSED yapılır. Başarısız olursa retry_count artırılır ve hata bilgisi last_error alanına yazılır.</p><p>Basitleştirilmiş akış:</p><pre>Kafka&#39;dan event alınır<br>↓<br>Event inbox tablosuna atomic şekilde yazılır<br>↓<br>Offset commit edilir<br>↓<br>Inbox worker PENDING event&#39;leri işler<br>↓<br>Başarılı olursa status = PROCESSED<br>↓<br>Başarısız olursa retry_count artırılır<br>↓<br>Retry limiti aşılırsa DLQ&#39;ya taşınır</pre><p>Bu yaklaşımın önemli avantajı şudur:</p><p>Consumer event’i Kafka’dan aldıktan sonra kendi dayanıklı kayıt alanına taşımış olur. Servis yeniden başlasa bile PENDING kayıtlar üzerinden işleme devam edebilir.</p><h3>Idempotency ve Inbox Pattern Birlikte Kullanıldığında</h3><p>Inbox Pattern ve idempotency birbirini tamamlar.</p><p>Inbox Pattern:</p><ul><li>Event’in consumer tarafında güvenli şekilde saklanmasını sağlar.</li><li>Event’in hangi aşamada olduğunu takip etmeyi kolaylaştırır.</li><li>Retry ve DLQ süreçlerini daha kontrollü hale getirir.</li></ul><p>Idempotency:</p><ul><li>Aynı event’in tekrar işlenmesini engeller.</li><li>Duplicate delivery durumunda yan etkilerin tekrar oluşmasını önler.</li><li>Eş zamanlı consumer instance’larında atomic claim ile güvenliği artırır.</li></ul><p>Örneğin aynı AnswerApproved event&#39;i ikinci kez gelirse consumer inbox tablosuna tekrar yazmaya çalışır. event_id primary key olduğu için ikinci kayıt oluşmaz. Böylece sistem event&#39;in daha önce alındığını anlayabilir.</p><p>Ancak burada önemli bir nokta daha vardır:</p><p>Mail gönderimi gibi dış sistem çağrıları tam anlamıyla transaction içine alınamaz. Bu nedenle mümkünse mail provider tarafında da idempotency key kullanılmalıdır. Örneğin event_id, mail gönderim isteğinde idempotency key olarak taşınabilir.</p><p>Provider bu desteği vermiyorsa duplicate mail ihtimali tamamen yok edilemeyebilir; ancak inbox, idempotency store ve doğru offset stratejisi ile bu ihtimal ciddi şekilde azaltılır.</p><h3>Idempotent Bir Consumer Nasıl Görünebilir?</h3><p>Teorik kısmı bir kenara bırakıp basitleştirilmiş bir Go örneği üzerinden düşünelim.</p><p>Admin tarafından onaylanan bir cevap için aşağıdaki event’in üretildiğini varsayalım:</p><pre>type AnswerApprovedEvent struct {<br>	EventID    string    `json:&quot;eventId&quot;`<br>	QuestionID string    `json:&quot;questionId&quot;`<br>	AnswerID   string    `json:&quot;answerId&quot;`<br>	UserID     string    `json:&quot;userId&quot;`<br>	ProductID  string    `json:&quot;productId&quot;`<br>	ApprovedAt time.Time `json:&quot;approvedAt&quot;`<br>}</pre><p>İlk bakışta mail consumer şu şekilde yazılabilir:</p><pre>func (c *MailConsumer) Handle(<br>	ctx context.Context,<br>	event AnswerApprovedEvent,<br>) error {<br>	return c.mailService.SendAnswerApprovedMail(<br>		ctx,<br>		event.UserID,<br>		event.QuestionID,<br>	)<br>}</pre><p>Ancak bu implementasyon duplicate event’lere karşı koruma sağlamaz.</p><p>Daha güvenli bir yaklaşımda consumer önce event’i atomic şekilde claim etmeye çalışır:</p><pre>func (c *MailConsumer) Handle(<br>	ctx context.Context,<br>	event AnswerApprovedEvent,<br>) error {<br>	key := &quot;mail:answer-approved:&quot; + event.EventID</pre><pre>	claimed, err := c.idempotencyStore.Claim(ctx, key)<br>	if err != nil {<br>		return err<br>	}</pre><pre>	if !claimed {<br>		return nil<br>	}</pre><pre>	if err := c.mailService.SendAnswerApprovedMail(<br>		ctx,<br>		event.UserID,<br>		event.QuestionID,<br>	); err != nil {<br>		return err<br>	}</pre><pre>	return c.idempotencyStore.MarkProcessed(ctx, key)<br>}</pre><p>Inbox Pattern kullanan sistemlerde idempotency çoğu zaman inbox tablosundaki event_id üzerinden de sağlanabilir. Event ikinci kez geldiğinde aynı event_id ile tekrar kayıt oluşturulamaz ve sistem event’in daha önce alındığını anlayabilir.</p><p>Bazı durumlarda ise inbox kaydına ek olarak Redis veya ayrı bir idempotency store kullanılarak dış sistem çağrıları için ek koruma katmanı oluşturulabilir.</p><p>Buradaki Claim operasyonu atomic olmalıdır. Redis kullanılıyorsa SET NX, veritabanı kullanılıyorsa INSERT ... ON CONFLICT DO NOTHING benzeri bir yapı tercih edilebilir.</p><p>Bu örnek sadeleştirilmiştir. Gerçek üretim ortamında CLAIMED, PROCESSED, FAILED gibi state&#39;ler tutulabilir. Ayrıca claim alındıktan sonra servis çökerse event&#39;in tekrar işlenebilmesi için lock süresi, retry count veya inbox worker gibi ek mekanizmalar gerekir.</p><h3>Retry Mekanizmasını Go ile Basitleştirilmiş Şekilde Yazmak</h3><p>Geçici hataları yönetmek için consumer içerisinde retry mekanizması kullanılabilir.</p><p>Basitleştirilmiş bir retry fonksiyonu şöyle olabilir:</p><pre>func Retry(<br>	ctx context.Context,<br>	maxAttempts int,<br>	operation func() error,<br>) error {<br>	var err error</pre><pre>	for attempt := 1; attempt &lt;= maxAttempts; attempt++ {<br>		err = operation()<br>		if err == nil {<br>			return nil<br>		}</pre><pre>		sleep := time.Duration(attempt*attempt) * time.Second</pre><pre>		select {<br>		case &lt;-time.After(sleep):<br>		case &lt;-ctx.Done():<br>			return ctx.Err()<br>		}<br>	}</pre><pre>	return err<br>}</pre><p>Consumer içerisinde kullanımı:</p><pre>func (c *MailConsumer) Handle(<br>	ctx context.Context,<br>	event AnswerApprovedEvent,<br>) error {<br>	return Retry(ctx, 3, func() error {<br>		return c.mailService.SendAnswerApprovedMail(<br>			ctx,<br>			event.UserID,<br>			event.QuestionID,<br>		)<br>	})<br>}</pre><p>Bu örnekte mail gönderimi en fazla üç kez denenir. Tüm denemeler başarısız olursa hata yukarıya döner ve event retry topic’e ya da DLQ’ya yönlendirilebilir.</p><p>Gerçek üretim ortamında bu fonksiyonun hata tipine göre karar vermesi gerekir. Örneğin validation hatası retry edilmemeli, timeout veya rate limit gibi geçici hatalar retry edilmelidir. Ayrıca exponential backoff’a jitter eklemek, retry yoğunluğunu azaltmak için faydalıdır.</p><h3>Cache ve Elasticsearch Güncelliği</h3><p>Ürün detay sayfalarında kullanıcıların büyük bölümü yalnızca ilk birkaç soru-cevap kaydını inceliyordu. Bu nedenle ürün detay ekranında gösterilen ilk kayıtları Redis üzerinde tutmak mantıklıydı.</p><p>Fakat kullanıcı “Daha Fazla Göster” dediğinde daha büyük veri seti, sayfalama ve arama ihtiyacı ortaya çıkıyordu. Bu noktada Elasticsearch kullanmak daha uygun hale geliyordu.</p><p>Basitleştirilmiş okuma stratejisi:</p><pre>Ürün Detay Sayfası<br>↓<br>İlk kayıtlar<br>↓<br>Redis</pre><pre>Kullanıcı &quot;Daha Fazla Göster&quot;<br>↓<br>Elasticsearch</pre><p>Bu yaklaşım performans açısından faydalı olsa da veri güncelliği problemini de beraberinde getirir.</p><p>Admin yeni bir soru veya cevabı onayladığında:</p><ul><li>Redis cache’i temizlenmeli veya yeniden oluşturulmalıdır.</li><li>Elasticsearch indeksi güncellenmelidir.</li></ul><p>Bu işlemleri senkron yapmak yerine event-driven yapı üzerinden yürütmek daha sağlıklıydı. AnswerApproved veya QuestionApproved event&#39;lerini dinleyen cache ve search consumer&#39;ları kendi sorumluluklarını yerine getiriyordu.</p><p>Burada da aynı güvenilirlik kuralları geçerlidir:</p><ul><li>Cache invalidation tekrar çalışırsa sistem bozulmamalıdır.</li><li>Elasticsearch update işlemi idempotent tasarlanmalıdır.</li><li>Geçici hatalar retry edilmelidir.</li><li>Sürekli başarısız olan event’ler DLQ’ya taşınmalıdır.</li></ul><p>Yani güvenilir consumer tasarımı yalnızca mail gönderimi için değil, sistemdeki tüm yan etkiler için önemlidir.</p><h3>Operasyonel Olarak Neleri İzlemek Gerekir?</h3><p>Consumer güvenilirliği yalnızca kodla çözülmez. Üretim ortamında sistemin gözlemlenebilir olması da gerekir.</p><p>Bu tip bir yapıda takip edilmesi faydalı metrikler şunlardır:</p><ul><li>Consumer lag</li><li>Retry sayısı</li><li>DLQ’ya düşen event sayısı</li><li>Inbox içinde bekleyen PENDING event sayısı</li><li>Event processing duration</li><li>Mail gönderim hata oranı</li><li>Elasticsearch update hata oranı</li><li>Cache invalidation hata oranı</li></ul><p>Örneğin DLQ sayısı bir anda artıyorsa bu sadece teknik bir hata olmayabilir. Yeni deploy edilen bir consumer eski event schema’sını desteklemiyor olabilir. Ya da producer tarafında bozuk payload üretiliyor olabilir.</p><p>Bu yüzden DLQ’ya düşen event’lerin incelenebilir, alarmlanabilir ve gerektiğinde replay edilebilir olması önemlidir.</p><h3>Tüm Parçaları Birleştirmek</h3><p>Ürün soru-cevap sistemi ilk bakışta basit bir domain gibi görünüyordu:</p><p>Kullanıcı soru sorar, satıcı cevaplar, admin onaylar.</p><p>Ancak sistem büyüdükçe aşağıdaki problemlerle karşılaştık:</p><ul><li>Aynı event’in birden fazla kez işlenebilmesi</li><li>Geçici servis hataları</li><li>Başarısız entegrasyonlar</li><li>Offset commit zamanlamasından kaynaklanan riskler</li><li>Cache ve arama indekslerinin güncel tutulması</li><li>Bozuk event’lerin ana akışı bloke etmesi</li><li>Event’in hangi aşamada olduğunun izlenememesi</li></ul><p>Bu problemlere karşı şu yaklaşımları kullandık:</p><ul><li>Idempotency ile duplicate event’leri kontrol altına aldık.</li><li>Atomic claim yaklaşımıyla race condition riskini azalttık.</li><li>Retry mekanizmalarıyla geçici hatalara tolerans sağladık.</li><li>Exponential backoff ve jitter ile retry yoğunluğunu kontrol ettik.</li><li>DLQ ile kalıcı problemli event’leri ana akıştan izole ettik.</li><li>Inbox Pattern ile consumer tarafında event yaşam döngüsünü takip edilebilir hale getirdik.</li><li>Observability metrikleriyle üretim ortamındaki davranışı izlemeyi hedefledik.</li></ul><p><em>Bu süreç bana şunu tekrar gösterdi: Event-driven mimarilerde güvenilirlik tek bir teknolojiyle elde edilmiyor. Kafka kullanmak tek başına yeterli değil. Doğru iş kuralları, doğru offset stratejisi, idempotent consumer tasarımı, retry/DLQ mekanizmaları ve gözlemlenebilirlik birlikte düşünülmeli.</em></p><p><em>Sonuç olarak güvenilir bir Kafka consumer tasarlarken hedef yalnızca mesaj tüketmek değildir. Hedef; aynı event’in tekrar gelebileceğini, servislerin hata verebileceğini ve dış sistemlerin her zaman erişilebilir olmayacağını kabul ederek, hata senaryolarına rağmen tekrar çalıştırılabilir, izlenebilir ve tutarlı davranabilen bir sistem kurmaktır.</em></p><p><em>Bu projede öğrendiğim en önemli şey de tam olarak buydu: Güvenilirlik Kafka’nın tek başına sunduğu bir özellik değil, doğru tasarlanmış mimarinin bir sonucudur.</em></p><p><em>Projelerimi daha yakından incelemek ve açık kaynaklı çalışmalarıma göz atmak isterseniz </em><a href="https://github.com/Zeyneppsevgi"><strong><em>GitHub profilimi</em></strong></a><em> ziyaret edebilirsiniz. Görüş ve geri bildirimleriniz benim için çok değerli, merak ettiklerinizi sormaktan lütfen çekinmeyin.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc08a4a9f2d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mikro servislerde Veri Kaybını Önleme: Go ile Transactional Outbox, Saga ve Idempotency]]></title>
            <link>https://medium.com/@zeyneppsevgi/mikro-servislerde-veri-kayb%C4%B1n%C4%B1-%C3%B6nleme-go-ile-transactional-outbox-saga-ve-idempotency-d3da76b54ea1?source=rss-f9bd6e56f8cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3da76b54ea1</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[idempotency]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[saga-pattern]]></category>
            <category><![CDATA[transactional-outbox]]></category>
            <dc:creator><![CDATA[Zeynep Sevgi]]></dc:creator>
            <pubDate>Sat, 28 Feb 2026 10:15:31 GMT</pubDate>
            <atom:updated>2026-03-02T07:29:03.481Z</atom:updated>
            <content:encoded><![CDATA[<p>Mikro servis tabanlı sistemlerde alınan tek bir karar, sistemin tamamında beklenmedik ve sarsıcı sonuçlar doğurabilir. Özellikle yüksek trafikli e-ticaret platformlarında bir satıcının başvurusunun iptal edilmesi veya pasife alınması gibi kritik işlemler; ürün yönetiminden aramaya, sepetten ödeme sistemlerine kadar pek çok servisi doğrudan etkiler.</p><p>Bu tür mimari hatalar çoğu zaman sistem loglarında belirgin bir “Error” olarak değil, doğrudan <strong>kullanıcı davranışlarında ve iş kaybında</strong> ortaya çıkar. Örneğin, yönetim panelinde satıcı pasif görünürken, ürünleri hâlâ listelenmeye ve müşteriler tarafından satın alınmaya devam eder. Bu durum, teknik bir hatadan ziyade, “sessiz ama pahalı” bir veri tutarsızlığı problemidir.</p><blockquote><strong>Peki, bu sorunu nasıl kontrol altına alabiliriz?</strong></blockquote><p>Bu yazıda; Go ekosisteminde <strong>Hexagonal Architecture</strong> prensiplerini temel alarak, <strong>Transactional Outbox</strong> ve <strong>Saga Pattern</strong> ile dağıtık veri tutarlılığını nasıl sağladığımızı, <strong>Idempotency</strong> ile bu akışı nasıl iyi hale getirdiğimizi gerçek hayat senaryoları ve kod örnekleriyle inceleyeceğiz.</p><p><strong>Idempotency</strong><br>API tasarımlarında aynı isteğin birden fazla kez gönderilmesi durumunda sistemin tekrarlayan işlemleri engellemesi için kullanılan bir mekanizmadır. Örneğin, bir odanın ışığını kapatıyorsunuz. Işık zaten kapalıysa tekrar kapatma düğmesine basmak hiçbir şeyi değiştirmez. Işık yine kapalı. Bu idempotent bir işlemdir. Banka havalesi ise tam tersidir -&gt; her basışta para tekrar gönderilir.</p><pre>Idempotency-Key + UserID + Endpoint <br>// Tam tersi durum da aynı key farklı kullanıcıdan gelirse çakışma olabilir.</pre><p><strong><em>Problem: Neden tekrar tekrar gelir?</em></strong></p><p><em>Dağıtık sistemlerde ağ güvenilmez. Bir istek gönderdikten sonra cevap gelmeyebilir. Timeout alırsınız. Bu durumda ne yapılır? Tekrar denersiniz. Peki ya o ilk istek aslında sunucuya ulaşmış, işlem tamamlanmış ama sadece cevap size gelmemişse?</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3zFK1XZHJcYLDyYCZcdFFw.png" /></figure><p><em>Ağ sorunları dışında aynı problem message broker’larda da yaşanır. Kafka ve RabbitMQ gibi sistemler “at-last-once” delivery garantisi verir.</em> <em>(</em><strong><em>mesaj en az bir kez iletilir, ama bazen iki ya da daha fazla da iletilebilir. Consumer’ınız idempotent değilse, aynı işi birden çok kez yaparsınız</em></strong><em>.)</em></p><p><strong>Idempotency Nasıl Uygulanır?</strong></p><p>Mükerrer işlemleri önlemek adına istemci tarafından gönderilen her benzersiz anahtar, sunucu tarafında kayıt altına alınır. Aynı anahtarla gelen sonraki tüm taleplerde, sunucu işlemi tekrarlamaz; bunun yerine <strong>ilk işlemin kayıtlı sonucunu </strong>döndürerek veri bütünlüğünü garanti altına alır.</p><p><strong>1-API Seviyesi Idempotency (Go Fiber Middleware)</strong></p><pre>func IdempotencyMiddleware(store *IdempotencyStore) fiber.Handler {<br>    return func(c *fiber.Ctx) error {<br>        // Header&#39;dan anahtarı oku<br>        key := c.Get(&quot;Idempotency-Key&quot;)<br>        if key == &quot;&quot; {<br>            return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{<br>                &quot;error&quot;: &quot;Idempotency-Key başlığı zorunludur&quot;,<br>            })<br>        }<br><br>        // 2. Veri tabanı veya Redis üzerinde bu anahtarı kontrol et<br>        cachedResponse, found := store.Get(c.Context(), key)<br>        if found {<br>            // Daha önce işlenmiş: Kaydedilen yanıtı doğrudan dön<br>            c.Set(&quot;X-Idempotency-Replayed&quot;, &quot;true&quot;)<br>            return c.Status(cachedResponse.StatusCode).Send(cachedResponse.Body)<br>        }<br><br>        // 3. İlk kez işleniyor: İsteği bir sonraki handler&#39;a ilet<br>        err := c.Next()<br>        if err != nil {<br>            return err<br>        }<br><br>        // 4. İşlem başarılıysa sonucu (Status Code ve Body) kaydet<br>        if c.Response().StatusCode() &lt; 300 {<br>            store.Save(c.Context(), key, c.Response().StatusCode(), c.Response().Body())<br>        }<br><br>        return nil<br>    }<br>}</pre><p><strong><em>Idempotency key’leri sonsuza kadar mı saklayacağız?</em></strong></p><blockquote><strong>-Redis veya Couchbase gibi TTL destekleyen bir veri tabanı kullanılıyorsa set edilmeli (örn: 24 saat). Mysql veya PostgreSQL gibi RDBMS kullanılıyorsa bir worker ile belirli periyotlarda loglar temizlenmeli, aksi takdirde DB boyutu büyür ve sorgular yavaşlayacaktır.</strong></blockquote><blockquote>-DB kullanılıyorsa cron ile temizlik yapılmalı.</blockquote><blockquote>-PCI veya finansal sistemlerde retention policy net olmalı.</blockquote><blockquote><strong>Idempotency sadece POST için değildir.</strong></blockquote><blockquote>-PUT zaten semantik olarak idempotenttir.</blockquote><blockquote>-POST değildir → bu yüzden idempotency key gerekir.</blockquote><blockquote>-PATCH genelde değildir.</blockquote><p><strong>2-Consumer Seviyesi Idempotency (Database Guard)</strong></p><blockquote>Kafka veya RabbitMQ gibi kuyruk sistemlerinde, “at-least-once” teslimat nedeniyle aynı event birden fazla kez gelebilir. Burada en güvenli yöntem, veri tabanının <strong>Unique Constraint</strong> (Benzersizlik Kısıtı) özelliğini kullanarak bir “koruma kalkanı” oluşturmaktır.</blockquote><pre>type EventGuard struct {<br>    db *sql.DB <br>}<br><br>// Process, gelen event&#39;in daha önce işlenip işlenmediğini kontrol eder ve işlemi yürütür.<br>func (g *EventGuard) Process(ctx context.∏<br>    // Bu sorgu atomiktir. Eğer ID varsa hiçbir şey yapmaz, yoksa ekler.<br>    // &#39;RowsAffected&#39; değerini kontrol ederek işlemin daha önce yapılıp yapılmadığını anlarız.<br>    result, err := g.db.ExecContext(ctx, <br>        `INSERT INTO processed_events (event_id, processed_at) <br>         VALUES ($1, NOW()) <br>         ON CONFLICT (event_id) DO NOTHING`, <br>        eventID,<br>    )<br>    if err != nil {<br>        return fmt.Errorf(&quot;idempotency check failed: %w&quot;, err)<br>    }<br><br>    rows, _ := result.RowsAffected()<br>    if rows == 0 {<br>        // Bu event ID daha önce işlenmiş, işleme sokmadan başarılı dönüyoruz.<br>        log.Printf(&quot;Event %s zaten işlendi, atlanıyor...&quot;, eventID)<br>        return nil<br>    }<br><br>    // 2. Eğer ilk kez geliyorsa, asıl iş mantığını çalıştır.<br>    return task()<br>}</pre><h4>Idempotency Yeterli mi? Fiyat Güncelleme Üzerinden Versionlama (Optimistic Concurrency)</h4><p>Idempotency tekrar eden <em>aynı isteğin</em> güvenli şekilde işlenmesini sağlar. Ancak dağıtık sistemlerde daha büyük bir problem vardır:</p><p><em>Aynı kaynağa eş zamanlı gelen farklı güncellemeler.</em></p><p>Bu problemi satıcı statüsü üzerinden değil, çok daha kritik bir senaryo üzerinden düşünelim: <strong>ürün fiyatı güncelleme</strong>.</p><p>Yüksek trafikli bir e-ticaret sisteminde aynı ürünün fiyatı birden fazla kaynaktan değiştirilebilir:</p><ul><li>Kampanya servisi → Fiyatı 950 TL yapıyor</li><li>Satıcı paneli → Fiyatı 1000 TL yapıyor</li><li>Dinamik fiyatlama servisi → Fiyatı 970 TL yapıyor</li></ul><p>Bu isteklerin bazıları retry olabilir (timeout sonrası tekrar gönderim).</p><p>Bazıları ise gerçekten eş zamanlı olabilir.</p><p>Burada iki ayrı problem vardır:</p><ol><li><strong>Duplicate request → Idempotency çözer.</strong></li><li><strong>Concurrent update (Lost Update) → Optimistic locking (version kontrolü) çözer.</strong></li></ol><p>Idempotency tek başına yeterli değildir.</p><blockquote><em>“Çünkü idempotency, aynı isteğin tekrar işlenmesini engeller; fakat iki farklı isteğin aynı kaynağı aynı anda güncellemesi durumunda ortaya çıkan çakışmayı (lost update) engellemez.”</em></blockquote><h3>Lost Update Problemi</h3><p>Senaryoyu adım adım düşünelim:</p><ol><li>Client A → Ürünü çeker → price=1000, version=5</li><li>Client B → Ürünü çeker → price=1000, version=5</li><li>A → Fiyatı 950 yapar → version=6 olur</li><li>B → Fiyatı 970 yapmak ister (hala version=5 ile)</li></ol><p>Eğer version kontrolü yoksa:</p><ul><li>B’nin isteği A’nın yaptığı güncellemeyi ezer.</li><li>Kampanya fiyatı kaybolur.</li><li>Sistem sessiz veri tutarsızlığı üretir.</li></ul><p>Bu durum loglarda hata üretmez.</p><p>Ama finansal kayıp yaratabilir.</p><p><strong>Çözüm: Optimistic Locking (Version Alanı)</strong></p><p>İlk adım olarak, ilgili veri tabanı tablosuna (örneğin products) her güncellemede değişecek olan version adında bir tam sayı sütunu eklenir.</p><pre>ALTER TABLE products <br>ADD COLUMN version INT NOT NULL DEFAULT 1;</pre><p>Bir kullanıcı veriyi güncellemek istediğinde, o anki mevcut versiyon numarasını da veriyle birlikte hafızaya alır.</p><p>Güncelleme sorgusu gönderilirken, sadece az önce okunan versiyon numarası hala aynıysa işlemin gerçekleşmesine izin verilir.</p><p>Eğer numara eşleşiyorsa, işlem başarılı sayılır ve versiyon numarası otomatik olarak bir artırılır.</p><h3>Idempotency + Versiyonlama Birlikte Nasıl Çalışır?</h3><p>Bu iki mekanizma farklı problemleri çözer.</p><p><strong>Senaryo 1 — Retry</strong></p><ul><li>Client fiyatı 950 yaptı</li><li>Sunucu işledi</li><li>Response timeout oldu</li><li>Client tekrar denedi</li></ul><p>Idempotency devreye girer ve aynı sonucu döner.</p><p>Duplicate update yapılmaz.</p><p><strong>Senaryo 2 — Eş Zamanlı Güncelleme</strong></p><ul><li>Kampanya servisi fiyatı düşürdü</li><li>Aynı anda satıcı paneli fiyatı değiştirdi</li></ul><blockquote>Version mismatch oluşur.</blockquote><blockquote>Conflict döner.</blockquote><blockquote>Veri kaybı engellenir.</blockquote><blockquote>I<strong>dempotency → İşlemin tekrarını kontrol eder.</strong></blockquote><blockquote><strong>Versionlama → İşlemin geçerliliğini kontrol eder.</strong></blockquote><blockquote><strong>Idempotent ama version kontrolü olmayan bir sistem hâlâ veri kaybedebilir.</strong></blockquote><blockquote><strong>Version kontrolü olan ama idempotent olmayan bir sistem duplicate üretir.</strong></blockquote><h4>Neden Bu Yapıları Tercih Etmeliyiz?</h4><ul><li><strong>Race Condition Önleme:</strong> INSERT ON CONFLICT kullanımı, iki farklı thread aynı anda aynı ID ile geldiğinde bile veri tabanı seviyesinde birinin &quot;takılmasını&quot; ve sadece birinin başarılı olmasını garanti eder.</li><li><strong>Performans:</strong> Go Fiber’in c.Response().Body() metoduna doğrudan erişimi sayesinde, response capture işlemleri standart net/http kütüphanesine göre çok daha sade ve hızlıdır.</li><li><strong>Tutarlılık:</strong> API tarafında cached response dönmek, istemcinin (Client) kafasının karışmasını önler; istemci ağ hatası alsa bile tekrar denediğinde sanki işlem o an yapılmış gibi aynı cevabı alır.</li></ul><blockquote><em>“Idempotency ile aynı işlemin tekrar edilmesini engelledik. Ancak bu, servisler arası veri tutarlılığı problemini tamamen çözmez. Özellikle event-driven sistemlerde, verinin kaydedilip mesajın yayınlanamaması gibi farklı bir risk vardır…”</em></blockquote><p><strong>Transactional Outbox</strong></p><p>Veri tabanı yazma işlemi ile mesaj gönderme işlemini atomik hale getirir. “Ya ikisi de olsun, ya da hiçbiri” garantisi sağlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gJ2glT2ivTEM5cix60gI5w.png" /></figure><h4>Dual-Write Problemi</h4><p>İki şeyi aynı anda iki farklı sisteme yazmak istiyorsunuz: veri tabanı ve message broker. Bu ikisini kapsayan bir global transaction yoktur. Dolayısıyla birini yapıp diğerini yapamama ihtimaliniz her zaman vardır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VEq9snzESJZEG2L9Ws7NJQ.png" /></figure><p>Bir işlem sırasında:</p><ol><li>Veri tabanına yazarsınız</li><li>Ardından message broker’a event gönderirsiniz.</li></ol><p>Bu iki adım <strong>farklı sistemlerdedir</strong> ve aralarında global bir transaction yoktur.</p><p><strong>Peki şu senaryoda ne olur?</strong></p><ul><li><strong>DB’ye yazdınız .</strong></li><li><strong>Kafka’ya gönderirken network hatası aldınız .</strong></li></ul><p><strong>Sonuç: Veri kaydedildi ama event yayınlanmadı.</strong></p><p><strong>Diğer servisler bu değişiklikten asla haberdar olmaz.</strong></p><p><strong>Ya da tam tersi:</strong></p><ul><li><strong>Event gönderildi.</strong></li><li><strong>DB transaction rollback oldu.</strong></li></ul><blockquote><strong>Bu kez diğer servisler olmayan bir veriye göre hareket eder. Bu problem, production ortamında “sessiz veri kaybı” olarak ortaya çıkar. Log’larda her şey normal görünebilir ama sistem tutarsızdır.İşte Transactional Outbox bu noktada devreye girer.</strong></blockquote><h4>Üç Bileşen</h4><p><strong>Outbox tablosu:</strong> İş mantığıyla aynı veri tabanında yaşar. Event’i broker’a değil buraya yazarsınız. İş kaydıyla aynı transaction içinde — atomiklik burada sağlanır.</p><p><strong>Relay process:</strong> Arka planda sürekli çalışır. Outbox tablosunu poll eder, işlenmemiş kayıtları broker’a gönderir. SELECT FOR UPDATE SKIP LOCKED sayesinde birden fazla relay instance çakışmadan çalışabilir.</p><p><strong>Idempotent consumer:</strong> Relay tekrar çalışırsa aynı event iki kez gönderilebilir. Consumer bunu tolere etmeli. Birinci bölümdeki consumer idempotency tam burada anlam kazanır.</p><h3><strong>Saga Pattern</strong></h3><p>Mikro servis mimarisinde klasik “ya hep ya hiç” (ACID) yaklaşımını servisler arası bir işlem zincirinde uygulamak mümkün değildir. Çünkü her servis kendi veri tabanına ve kendi transaction sınırına sahiptir. Sipariş, Stok ve Ödeme servislerinin verilerini tek bir global BEGIN TRANSACTION altında kilitlemek hem teknik olarak zordur hem de sistemi ciddi şekilde yavaşlatır.</p><p>Bu noktada Saga Pattern devreye girer.</p><p>Saga, dağıtık sistemlerde tek bir global ACID transaction yerine kullanılan bir <strong>eventual consistency</strong> yaklaşımıdır. Önemli bir ayrım şudur: Saga ACID sağlamaz. Sistem anlık (strong) tutarlı değildir; eventual consistency modeline göre çalışır.</p><p>Bu şu anlama gelir: Bir işlem zinciri devam ederken sistem geçici olarak tutarsız bir durumda olabilir. Örneğin sipariş oluşturulmuş ancak ödeme henüz tamamlanmamış olabilir. Saga’nın amacı bu geçici durumu ya tüm adımları başarıyla tamamlayarak tutarlı bir sonuca ulaştırmak ya da bir hata oluştuğunda daha önce tamamlanan adımları telafi işlemleri (compensating transactions) ile geri alarak sistemi dengeli bir duruma getirmektir.</p><p>Saga, merkezi kilitleme yerine kontrollü ilerleme ve gerektiğinde telafi stratejisini benimser.</p><h4>Saga Nasıl Çalışır?</h4><p>Saga, büyük bir işlemi bir dizi yerel işleme (local transaction) böler. Her servis kendi veri tabanında kendi transaction’ını yürütür.</p><p>Örnek bir sipariş akışı:</p><ol><li><strong>Sipariş Servisi</strong> → Siparişi oluşturur (Başarılı)</li><li><strong>Ödeme Servisi</strong> → Ödemeyi alır (Başarılı)</li><li><strong>Stok Servisi</strong> → Stoğu düşmeye çalışır (HATA: Stokta ürün kalmamış)</li></ol><p>Üçüncü adımda hata oluştuğunda, daha önce başarıyla tamamlanan adımların geri alınması gerekir. İşte bu sürece <strong>Telafi İşlemi (Compensating Transaction)</strong> denir.</p><p>Rollback gibi otomatik değildir; açıkça kodlanmalıdır.</p><p>Örnek telafiler:</p><ul><li>Ödemeyi al → Telafi: Ödemeyi iade et</li><li>Stoğu düş → Telafi: Stoğu artır</li><li>Siparişi oluştur → Telafi: Siparişi iptal et</li></ul><p>Saga’nın temel mantığı şudur:</p><p>Her adımın bir ileri işlemi varsa, bir de geri alma işlemi olmalıdır.</p><h3>Saga Türleri</h3><p>Saga iki farklı şekilde uygulanabilir: <strong>Choreography</strong> ve <strong>Orchestration</strong>.</p><h4>A. Choreography (Koreografi)</h4><p>Servisler arasında merkezi bir yönetici yoktur. Her servis bir işi bitirince bir “Event” fırlatır, diğer servis o event’i dinleyip kendi işine başlar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/985/1*fZQpi5dgaRATkIOHtB3qFg.png" /><figcaption><strong>Artısı:</strong> Çok hızlıdır, merkezi bir nokta yoktur. <strong>Eksisi:</strong> Kimin ne yaptığını takip etmek (debug etmek) çok zordur; servis sayısı artınca kafa karıştırır.</figcaption></figure><h4>B. Orchestration (Orkestrasyon) — “Bir Şef (Orchestrator) Vardır”</h4><p>Merkezi bir “Saga Manager” (Orchestrator) vardır. Dağıtık bir işlem sürecinin tüm akış mantığının merkezi bir bileşen (Orchestrator/Saga Manager) tarafından yönetildiği tasarım desenidir. Bu yapıda servisler birbirleriyle doğrudan iletişim kurmak yerine, yalnızca merkezi yönetici ile haberleşirler.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1023/1*bOWEX9BIH7VpbxT5VBaoPg.png" /><figcaption>Süreç tek bir yerden izlenebilir. Karmaşık süreçler için idealdir.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1DJdgr5benTLRX7sJC9NEg.png" /></figure><blockquote>Saga Pattern, dağıtık mimarilerde uzun süren işlemleri merkezi kilitleme olmadan yönetmemizi sağlar. Sistem anlık tutarlı olmayabilir; ancak hata durumlarında telafi mekanizmaları devreye girerek veri tutarlılığı ve operasyonel süreklilik korunur.</blockquote><blockquote>Saga, ACID’in dağıtık versiyonu değildir.</blockquote><blockquote>Saga, hatayı kabullenip onu kontrollü şekilde yönetme stratejisidir.</blockquote><h3>Sonuç</h3><blockquote>Bu yazıda, Go ile mikro servis mimarisinde dağıtık veri tutarlılığını sağlamak için kullanılan üç temel yaklaşımı ele aldım: <strong>Idempotency</strong>, <strong>Transactional Outbox</strong> ve <strong>Saga Pattern</strong>. API seviyesinde tekrar eden istekleri güvenli şekilde yönetmeyi, message broker kaynaklı duplicate event problemlerini veri tabanı seviyesinde nasıl kontrol altına alabileceğimizi ve dual-write problemini Outbox pattern ile nasıl çözebileceğimizi adım adım inceledik.</blockquote><blockquote>Ardından, mikro servisler arası uzun süren ve birden fazla servisi ilgilendiren işlemlerde ACID transaction yerine neden Saga yaklaşımını kullanmamız gerektiğini, telafi işlemlerinin (compensating transactions) neden kritik olduğunu ve Choreography ile Orchestration modellerinin pratikte nasıl farklılaştığını değerlendirdik.</blockquote><blockquote>Gerçek sistemlerde karşılaşılan veri tutarsızlıkları çoğu zaman log’larda açık bir hata olarak görünmez; kullanıcı davranışlarında ve iş kaybında ortaya çıkar. İşte bu nedenle idempotent API’ler tasarlamak, event tüketicilerini güvenli hale getirmek ve dağıtık transaction problemlerini bilinçli şekilde çözmek, özellikle yüksek trafikli ve kritik iş süreçlerine sahip sistemlerde hayati önem taşır.</blockquote><blockquote>Özetle:</blockquote><blockquote><strong>Idempotency</strong>, tekrar eden istekleri güvenli hale getirir.</blockquote><blockquote><strong>Transactional Outbox</strong>, veri tabanı ve mesajlaşma sistemi arasındaki tutarlılığı garanti altına alır.</blockquote><blockquote><strong>Saga Pattern</strong>, dağıtık işlemleri merkezi kilitleme olmadan yönetmemizi sağlar.</blockquote><blockquote>Bu üç yaklaşım birlikte kullanıldığında, yüksek trafikli mikro servis mimarilerinde daha dayanıklı, daha öngörülebilir ve production-ready sistemler inşa etmek mümkün hale gelir.</blockquote><blockquote>Bu süreç benim için, dağıtık sistemlerde ‘<strong>hatasız bir tasarım</strong>’ yapmaktan ziyade, ‘<strong>hataları kontrollü yönetebilme</strong>’ becerisinin ne kadar kritik olduğunu kanıtladı. Mikro servis dünyasında asıl hedef; kusursuz bir senaryo kurgulamak değil, kaçınılmaz hataları güvenli bir şekilde karşılayıp sistemi stabil tutabilen esnek bir mimari inşa etmek olduğunu anladım.</blockquote><blockquote>Eğer siz de mikro servis mimarilerinde veri tutarlılığı (<strong>data consistency</strong>) sorun yaşıyorsanız, bu yazının sizin için faydalı bir <strong>başlangıç noktası</strong> olmasını dilerim.</blockquote><blockquote>Projelerimi daha yakından incelemek ve açık kaynaklı çalışmalarıma göz atmak isterseniz <a href="https://github.com/Zeyneppsevgi"><strong>GitHub profilimi</strong></a> ziyaret edebilirsiniz. Görüş ve geri bildirimleriniz benim için çok değerli, merak ettiklerinizi sormaktan lütfen çekinmeyin.”</blockquote><p><strong>Kaynakça :<br></strong><a href="https://www.geeksforgeeks.org/system-design/saga-design-pattern/"><strong>https://www.geeksforgeeks.org/system-design/saga-design-pattern/</strong></a></p><p><a href="https://www.baeldung.com/cs/outbox-pattern-microservices"><strong>https://www.baeldung.com/cs/outbox-pattern-microservices</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3da76b54ea1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Go ile Sitemap Oluşturma ve Cache ile Performans Artırma]]></title>
            <link>https://medium.com/@zeyneppsevgi/go-ile-sitemap-olu%C5%9Fturma-ve-cache-ile-performans-art%C4%B1rma-3aeb7c4c187e?source=rss-f9bd6e56f8cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/3aeb7c4c187e</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[couchbase]]></category>
            <category><![CDATA[sitemap]]></category>
            <category><![CDATA[seo]]></category>
            <category><![CDATA[cache]]></category>
            <dc:creator><![CDATA[Zeynep Sevgi]]></dc:creator>
            <pubDate>Mon, 15 Sep 2025 08:15:33 GMT</pubDate>
            <atom:updated>2025-09-15T08:15:33.944Z</atom:updated>
            <content:encoded><![CDATA[<p>👋 Merhaba, ben bir backend geliştiricisiyim. Çoğunlukla API’ler, veri tabanı, cache gibi işlerle uğraşıyorum. SEO ise açıkçası bugüne kadar çok da girdiğim ve bildiğim bir alan değildi. Ama çalıştığım projede ilk kez <strong>sitemap</strong> oluşturma ihtiyacıyla karşılaştım. Bu yazıda kendi deneyimim üzerinden, Go ile nasıl (dinamik) sitemap ürettiğimi, Fiber framework’ü üzerinde çalıştırdığım bu serviste Couchbase’ de cache’ leyerek nasıl hız kazandığımı ve sayfalama mantığını nasıl kurduğumu paylaşmak istiyorum. <strong>Bu arada Couchbase yerine Redis de kullanılabilinir fakat yatayda ölçeklendirme daha kolay olduğu için ben Couchbase tercih ettim.</strong></p><h3>Sitemap nedir? SEO için neden önemlidir?</h3><p><strong>Sitemap</strong>, bir web sitesinin yapısını ve içeriğini (sayfalar, resimler, videolar ve diğer dosyalar) arama motorlarına sunan özel bir dosyadır. Google gibi arama motorları bu dosyayı okuyarak sitenizi daha verimli bir şekilde tarar ve daha hızlı indeksler. Bu da hem tarama sürecini iyileştirir hem de dolaylı olarak kullanıcı deneyimini geliştirir.</p><p>Ayrıca sitemap, sitenizde <strong>önemli gördüğünüz sayfaları ve dosyaları</strong> arama motorlarına (Googlebot, Bingbot gibi) bildirmenizi sağlar. Bir sayfanın en son ne zaman güncellendiğini veya alternatif dil sürümlerini de arama motorlarına iletebilir.</p><h4>Sitemap’ teki alanlar:</h4><ul><li>&lt;loc&gt; → Sayfanın tam URL’i (örn: <a href="https://site.com/urun/123)">https://site.com/urun/123)</a></li><li>&lt;lastmod&gt; → Sayfanın en son güncellendiği tarih.</li><li>&lt;changefreq&gt; → Sayfanın tahmini güncellenme sıklığı (ör: daily, weekly, monthly).</li><li>&lt;priority&gt; → Sayfanın sitendeki önem derecesi (0.0–1.0 arası).</li><li>&lt;image:loc&gt; → Görsel URL’i</li><li>&lt;image:caption&gt; → Açıklama</li><li>&lt;image:title&gt; → Görsel başlığı</li><li>&lt;video:title&gt; → Video başlığı</li><li>&lt;video:description&gt;→ Açıklama</li><li>&lt;video:thumbnail_loc&gt;→ (Önizleme görseli)</li><li>&lt;video:content_loc&gt; veya &lt;video:player_loc&gt;→ (Video dosyası ya da oynatıcı linki)</li></ul><p>O zaman şimdi ilk olarak adım adım statik olarak yazdığım sitemap’ ten başlayalım :</p><pre>package sitemap<br><br>import (<br> &quot;encoding/xml&quot;<br>)<br><br>// URLSet sitemap&#39;in temel yapısını temsil eder<br>type URLSet struct {<br> XMLName xml.Name `xml:&quot;urlset&quot;`<br> XMLNS   string   `xml:&quot;xmlns,attr&quot;`<br> Image   string   `xml:&quot;xmlns:image,attr&quot;`<br> URLs    []URL    `xml:&quot;url&quot;`<br>}<br><br>// Image sitemap içindeki görsel bilgilerini temsil eder<br>type Image struct {<br> Loc     string `xml:&quot;image:loc&quot;`<br> Title   string `xml:&quot;image:title,omitempty&quot;`<br> Caption string `xml:&quot;image:caption,omitempty&quot;`<br>}<br><br>// URL sitemap URL&#39;sini tanımlar<br>type URL struct {<br> Loc    string  `xml:&quot;loc&quot;`<br> Images []Image `xml:&quot;image:image,omitempty&quot;`<br>}<br></pre><blockquote>URLSet sitemap’in ana yapısıdır. Her URL sayfası loc ile belirtilir, isteğe bağlı olarak resim (Image) bilgileri eklenebilir.</blockquote><pre>package sitemap<br><br>import (<br> &quot;encoding/xml&quot;<br> &quot;fmt&quot;<br> &quot;github.com/gofiber/fiber/v2&quot;<br>)<br><br>const SitemapURLLimit = 40000<br><br>func GenerateSitemap(ctx *fiber.Ctx) error {<br><br> // Önce cache&#39;den sitemap verisini almaya çalışıyoruz var ise <br> cachedXML, err := getSitemapFromCache()<br> if err == nil {<br>  ctx.Set(&quot;Content-Type&quot;, &quot;application/xml&quot;)<br>  return ctx.SendString(cachedXML)<br> }</pre><blockquote>Google önerisine göre bir sitemap en fazla 50.000 URL içerebilir. Biz burada örnek olarak 40.000 verdik.<br>Öncelikle, sitemap’i DB’den yeniden oluşturmak yerine cache’ den almaya çalışıyoruz.</blockquote><pre> baseURL := &quot;https://example.com&quot;<br><br> urlset := URLSet{<br>  XMLNS: &quot;http://www.sitemaps.org/schemas/sitemap/0.9&quot;,<br>  URLs: []URL{<br>   {Loc: fmt.Sprintf(&quot;%s/&quot;, baseURL)},<br>   {Loc: fmt.Sprintf(&quot;%s/hakkimizda&quot;, baseURL)},<br>   {Loc: fmt.Sprintf(&quot;%s/iletisim&quot;, baseURL)},<br>   {Loc: fmt.Sprintf(&quot;%s/gizlilik&quot;, baseURL)},<br>   // Daha fazla statik sayfa varsa eklenebilir<br>  },<br> }</pre><blockquote>Statik sayfaları listeledik. fmt.Sprintf ile base URL’e ekliyoruz.<br>Dinamik sayfaları DB’den çekip aynı şekilde ekleyebiliriz.</blockquote><pre> ctx.Set(&quot;Content-Type&quot;, &quot;application/xml&quot;)<br> xmlOutput, err := xml.MarshalIndent(urlset, &quot;&quot;, &quot;  &quot;)<br> if err != nil {<br>  return ctx.Status(500).SendString(&quot;XML oluşturma hatası&quot;)<br> }<br><br> xmlData := append([]byte(xml.Header), xmlOutput...)<br>// cache&#39; e kaydediyoruz<br> _ = saveSitemapToCache(xmlData)<br><br> return ctx.Send(xmlData)<br>}</pre><blockquote>Sitemap XML’e dönüştürülüyor, HTTP response olarak gönderiliyor ve cache’e kaydediliyor.<br>Cache sayesinde sonraki isteklerde DB’ den tekrar çekmek zorunda kalmıyoruz.</blockquote><pre>app.Get(&quot;/sitemap-general.xml&quot;, sitemap.GenerateSitemap)</pre><blockquote>Statik sayfalar için oluşturduğumuz sitemap’i bir <strong>HTTP endpoint</strong> olarak tanımladık. Artık /sitemap-general.xmlURL’sine istek yapıldığında GenerateSitemap fonksiyonu çalışıyor ve sitemap XML dosyasını kullanıcıya veya arama motorlarına döndürüyor. Böylece hem tarayıcılar hem de Googlebot gibi botlar sitenizin önemli sayfalarına kolayca erişebiliyor.</blockquote><p><strong>XML Çıktısı:</strong></p><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;<br>&lt;urlset xmlns=&quot;http://www.sitemaps.org/schemas/sitemap/0.9&quot;&gt;<br>  &lt;url&gt;<br>    &lt;loc&gt;https://example.com/&lt;/loc&gt;<br>  &lt;/url&gt;<br>  &lt;url&gt;<br>    &lt;loc&gt;https://example.com/hakkimizda&lt;/loc&gt;<br>  &lt;/url&gt;<br>  &lt;url&gt;<br>    &lt;loc&gt;https://example.com/iletisim&lt;/loc&gt;<br>  &lt;/url&gt;<br>  &lt;url&gt;<br>    &lt;loc&gt;https://example.com/gizlilik&lt;/loc&gt;<br>  &lt;/url&gt;<br>&lt;/urlset&gt;</pre><p><strong>Dinamik Sitemap oluşturma:</strong></p><pre>package sitemap<br><br>import (<br> &quot;encoding/xml&quot;<br> &quot;fmt&quot;<br> &quot;github.com/gofiber/fiber/v2&quot;<br> &quot;product-service/pkg/db/mysql&quot;<br> &quot;strconv&quot;<br> &quot;github.com/gosimple/slug&quot;<br>)<br><br>func ProductSitemap(ctx *fiber.Ctx) error {<br> <br> page, _ := strconv.Atoi(ctx.Params(&quot;page&quot;))<br> if page &lt; 1 {<br>  return ctx.Status(400).SendString(&quot;Geçersiz sayfa&quot;)<br> }<br><br> // Cache kontrolü<br> cachedXML, err := getProductSitemapFromCache(page)<br> if err == nil {<br>  ctx.Set(&quot;Content-Type&quot;, &quot;application/xml&quot;)<br>  return ctx.SendString(cachedXML)<br> }<br><br> // Sayfalama hesaplamaları<br> offset := (page - 1) * SitemapURLLimit<br> limit := SitemapURLLimit<br><br> fmt.Println(&quot;Product sitemap cache&#39;de bulunamadı veya hata oluştu, yeniden oluşturuluyor...&quot;)<br><br> // Temel URL&#39;ler<br> baseURL := &quot;https://example.com&quot;<br> imgBaseURL := &quot;https://img.example.com/product&quot;<br><br> // Veritabanı bağlantısı<br> conn, err := mysql.GetConn()<br> if err != nil {<br>  return ctx.Status(500).SendString(&quot;Veritabanı bağlantı hatası&quot;)<br> }<br><br> // Sitemap verilerini hazırlıyoruz<br> urlset := URLSet{<br>  XMLNS: &quot;http://www.sitemaps.org/schemas/sitemap/0.9&quot;,<br>  Image: &quot;http://www.google.com/schemas/sitemap-image/1.1&quot;,<br>  URLs:  []URL{},<br> }<br><br> // Ürünleri db&#39; den çekiyoruz<br> rows, err := conn.Query(`<br>  SELECT p.id, p.name, p.uuid, p.brand_id, IFNULL(b.name, &#39;&#39;) as brand_name<br>  FROM prod p <br>  LEFT JOIN brand b ON p.brand_id = b.id <br>  WHERE p.status = 1 <br>  ORDER BY p.id <br>  LIMIT ? OFFSET ?`, limit, offset)<br> if err != nil {<br>  return ctx.Status(500).SendString(&quot;Veritabanı sorgu hatası&quot;)<br> }<br> defer rows.Close()<br><br> // Ürünleri sitemap&#39;e ekle<br> for rows.Next() {<br>  var id int<br>  var name, uuid, brandName string<br>  var brandID int<br><br>  if err := rows.Scan(&amp;id, &amp;name, &amp;uuid, &amp;brandID, &amp;brandName); err != nil {<br>   continue<br>  }<br><br>  // URL slug oluştur<br>  slug := makeSlug(name)<br>  productURL := fmt.Sprintf(&quot;%s/%s-p-%d&quot;, baseURL, slug, id)<br><br>  // Ürün URL nesnesi<br>  productURLObj := URL{<br>   Loc:    productURL,<br>   Images: []Image{},<br>  }<br><br>  // Ürün resimlerini çek<br>  imgRows, err := conn.Query(&quot;SELECT file_name FROM prod_img WHERE product_id = ? ORDER BY sequence&quot;, id)<br>  if err == nil {<br>   defer imgRows.Close()<br>   for imgRows.Next() {<br>    var fileName string<br>    if err := imgRows.Scan(&amp;fileName); err != nil {<br>     continue<br>    }<br><br>    imageURL := fmt.Sprintf(&quot;%s/%s/%s&quot;, imgBaseURL, uuid, fileName)<br>    imageTitle := slug<br>    imageCaption := fmt.Sprintf(&quot;%s %s | example.com&quot;, slug, brandName)<br><br>    productURLObj.Images = append(productURLObj.Images, Image{<br>     Loc:     imageURL,<br>     Title:   imageTitle,<br>     Caption: imageCaption,<br>    })<br>   }<br>  }<br><br>  // URL set&#39;e ekle<br>  urlset.URLs = append(urlset.URLs, productURLObj)<br> }<br><br> // XML oluşturma<br> ctx.Set(&quot;Content-Type&quot;, &quot;application/xml&quot;)<br> xmlOutput, err := xml.MarshalIndent(urlset, &quot;&quot;, &quot;  &quot;)<br> if err != nil {<br>  return ctx.Status(500).SendString(&quot;XML oluşturma hatası&quot;)<br> }<br><br> xmlData := append([]byte(xml.Header), xmlOutput...)<br><br> // Cache&#39;e kaydet<br> _ = saveProductSitemapToCache(page, xmlData)<br><br> return ctx.Send(xmlData)<br>}</pre><ul><li>Sitemap’i <strong>sayfalara bölüyoruz (</strong><strong>page parametresi)</strong>. Bu, özellikle ürün sayısı 50.000’e yaklaşan büyük kataloglar için gerekli. Tek bir sitemap dosyasına tüm ürünleri sığdırmak hem pratik değil hem de Google’ın sınırları nedeniyle mümkün değil.</li><li>Couchbase üzerinde bir bucket, scope ve collection oluşturdum. Sitemap XML’lerini bu collection’a kaydediyorum. İstek geldiğinde önce cache kontrol ediliyor, varsa doğrudan oradan okunuyor. Bu sayede DB sorgusunu atlayarak performansı ciddi şekilde artırıyoruz.</li><li>baseURL ve imgBaseURL ile ürün ve resim URL’lerini oluşturuyoruz. MySQL bağlantısı ile ürün ve marka bilgilerini çekiyoruz.</li><li>Sitemap’in temel XML yapısı oluşturuluyor.Image namespace’i ile <strong>ürün resimlerini</strong> sitemap’e ekleyebiliyoruz.</li><li>Ürünleri veritabanından çekiyoruz.</li><li>Ürün ismini <strong>URL dostu hâle getiriyoruz</strong> (makeSlug). Ürün URL’ini ve boş resim listesi ile URL nesnesi oluşturuyoruz.</li><li>Her ürün için <strong>tüm resimleri</strong> çekiyoruz. Title ve caption ile SEO açısından değerli hale getiriyoruz.</li><li>Sitemap’i <strong>XML formatında oluşturuyoruz</strong>. Cache’e kaydederek sonraki istekleri hızlandırıyoruz. Son olarak XML yanıt olarak dönüyor.</li></ul><pre> app.Get(&quot;/prod-sitemap-:page.xml&quot;, sitemap.GenerateProductSitemap)</pre><p>XML Çıktısı:</p><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;<br>&lt;urlset xmlns=&quot;http://www.sitemaps.org/schemas/sitemap/0.9&quot; xmlns:image=&quot;http://www.google.com/schemas/sitemap-image/1.1&quot;&gt;<br>  &lt;url&gt;<br>    &lt;loc&gt;https://example.com/urun-adi-p-1&lt;/loc&gt;<br>    &lt;image:image&gt;<br>      &lt;image:loc&gt;https://img.example.com/product/uuid1/resim1.jpg&lt;/image:loc&gt;<br>      &lt;image:title&gt;urun-adi&lt;/image:title&gt;<br>      &lt;image:caption&gt;urun-adi Marka1 | example.com&lt;/image:caption&gt;<br>    &lt;/image:image&gt;<br>    &lt;image:image&gt;<br>      &lt;image:loc&gt;https://img.example.com/product/uuid1/resim2.jpg&lt;/image:loc&gt;<br>      &lt;image:title&gt;urun-adi&lt;/image:title&gt;<br>      &lt;image:caption&gt;urun-adi Marka1 | example.com&lt;/image:caption&gt;<br>    &lt;/image:image&gt;<br>  &lt;/url&gt;<br>  &lt;url&gt;<br>    &lt;loc&gt;https://example.com/urun-adi-iki-p-2&lt;/loc&gt;<br>    &lt;image:image&gt;<br>      &lt;image:loc&gt;https://img.example.com/product/uuid2/resim1.jpg&lt;/image:loc&gt;<br>      &lt;image:title&gt;urun-adi-iki&lt;/image:title&gt;<br>      &lt;image:caption&gt;urun-adi-iki Marka2 | example.com&lt;/image:caption&gt;<br>    &lt;/image:image&gt;<br>  &lt;/url&gt;<br>&lt;/urlset&gt;</pre><blockquote>&lt;urlset&gt;: Sitemap’in ana kapsayıcısı.</blockquote><blockquote>&lt;url&gt;: Her ürün için bir URL bloğu.</blockquote><blockquote>&lt;loc&gt;: Ürünün erişim URL’si.</blockquote><blockquote>&lt;image:image&gt;: Ürün görsellerini içeriyor. Her resim için loc, title ve caption bilgileri var.</blockquote><blockquote>Sayfalama yapılmış olduğundan, örneğin page=1 ile ilk 40.000 ürünün URL’leri gelir, sonraki sayfa page=2 ile devam eder.</blockquote><p><strong>Go &amp; Couchbase ile Cache’ lemek</strong></p><p>İlk adım olarak Couchbase üzerinde verilerimi tutabilmek için gerekli yapılandırmayı yaptım; yani bir <strong>bucket</strong>, bunun içinde bir <strong>scope</strong> ve ilgili <strong>collection</strong> oluşturdum. Ürün sitemap verilerimi bu collection’a kaydettim ve daha sonra ihtiyaç duyduğumda aynı collection üzerinden verileri okuyarak sitemap’i cache’den almayı sağladım. Bu sayede veritabanına her sorguda gitmek yerine, sık kullanılan sitemap verilerini hızlı bir şekilde çekebiliyorum ve uygulamanın performansını artırmış oldum.</p><pre>package sitemap<br><br>import (<br> &quot;fmt&quot;<br> &quot;time&quot;<br>)<br><br>// Product sitemap&#39;i cache&#39;den getirme<br>func getProductSitemapFromCache(page int) (string, error) {<br><br> cluster, err := connectCouchbase()<br> if err != nil {<br>  return &quot;&quot;, err<br> }<br> defer cluster.Close(nil)<br><br> bucket := cluster.Bucket(&quot;seo&quot;)<br> err = bucket.WaitUntilReady(5*time.Second, nil)<br> if err != nil {<br>  return &quot;&quot;, err<br> }<br><br> collection := bucket.Scope(&quot;sitemap&quot;).Collection(&quot;prod&quot;)<br><br> cacheKey := fmt.Sprintf(&quot;prod_sitemap_xml_%d&quot;, page)<br><br> getResult, err := collection.Get(cacheKey, nil)<br> if err != nil {<br>  fmt.Printf(&quot;Product sitemap (page=%d)cache okuma hatası: %v\n&quot;, page, err)<br>  return &quot;&quot;, err<br> }<br><br> var sitemapCache SitemapCache<br> err = getResult.Content(&amp;sitemapCache)<br> if err != nil {<br>  fmt.Printf(&quot;Product sitemap (page=%d)cache dönüştürme hatası: %v\n&quot;, page, err)<br>  return &quot;&quot;, err<br> }<br><br> fmt.Println(&quot;Product sitemap başarıyla cache&#39;den okundu&quot;)<br> return sitemapCache.XMLData, nil<br>}<br><br>// Ürün sitemap&#39;i cache&#39;e kaydet<br>func saveProductSitemapToCache(page int, xmlData []byte) error {<br> fmt.Printf(&quot;Product sitemap (page=%d) cache&#39;e kaydediliyor...\n&quot;, page)<br> cluster, err := connectCouchbase()<br> if err != nil {<br>  fmt.Printf(&quot;Cache bağlantı hatası: %v\n&quot;, err)<br>  return err<br> }<br> defer cluster.Close(nil)<br><br> bucket := cluster.Bucket(&quot;seo&quot;)<br> err = bucket.WaitUntilReady(5*time.Second, nil)<br> if err != nil {<br>  fmt.Printf(&quot;Bucket bağlantı hatası: %v\n&quot;, err)<br>  return err<br> }<br><br> collection := bucket.Scope(&quot;sitemap&quot;).Collection(&quot;prod&quot;)<br> cacheKey := fmt.Sprintf(&quot;prod_sitemap_xml_%d&quot;, page)<br><br> cache := SitemapCache{<br>  XMLData:     string(xmlData),<br>  LastUpdated: time.Now(),<br> }<br><br> _, err = collection.Upsert(cacheKey, cache, nil)<br> if err != nil {<br>  fmt.Printf(&quot;Product sitemap cache kaydetme hatası (page=%d): %v\n&quot;, page, err)<br>  return err<br> }<br><br> return nil<br>}</pre><blockquote><strong>getProductSitemapFromCache</strong> fonksiyonu, belirtilen sayfaya ait ürün sitemap XML’ini Couchbase collection’ dan alır ve eğer veri varsa doğrudan döndürür.</blockquote><blockquote><strong>saveProductSitemapToCache</strong> fonksiyonu ise oluşturulan veya güncellenen sitemap XML’ini aynı collection’a kaydeder, böylece sonraki isteklerde hızlıca erişilebilir hale getirir.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HRCaNiI14ToVxjYHcTXGEw.png" /><figcaption><strong>Cache’ lemeden önceki cevap verme süresi (optimize edilmemiş mysql sorgusu, gerçek projeden alınan sonuç)</strong></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XT8JvH2mTvQOZpacFQIYIQ.png" /><figcaption><strong>Cache’ledikten sonraki cevap verme süresi</strong></figcaption></figure><pre>package sitemap<br><br>import (<br> &quot;database/sql&quot;<br> &quot;encoding/xml&quot;<br> &quot;fmt&quot;<br> &quot;github.com/gofiber/fiber/v2&quot;<br> &quot;product-service/pkg/db/mysql&quot;<br>)<br><br>// SitemapIndex tüm alt sitemap dosyalarını listeleyen temel yapı<br>type SitemapIndex struct {<br> XMLName  xml.Name       `xml:&quot;sitemapindex&quot;`<br> XMLNS    string         `xml:&quot;xmlns,attr&quot;`<br> Sitemaps []SitemapEntry `xml:&quot;sitemap&quot;`<br>}<br><br>// SitemapEntry her bir alt sitemap dosyasını temsil eder<br>type SitemapEntry struct {<br> Loc string `xml:&quot;loc&quot;`<br>}<br><br>func GenerateMainSitemapIndex(ctx *fiber.Ctx) error {<br> // Önce cache&#39;den kontrol ediyoruz, varsa direkt döndürüyoruz<br> cachedXML, err := getMainSitemapFromCache()<br> if err == nil {<br>  ctx.Set(&quot;Content-Type&quot;, &quot;application/xml&quot;)<br>  return ctx.SendString(cachedXML)<br> }<br><br> baseURL := &quot;https://example.com&quot;<br> var sitemaps []SitemapEntry<br><br> // Statik sitemap&#39;i ekliyoruz<br> sitemaps = append(sitemaps, SitemapEntry{<br>  Loc: fmt.Sprintf(&quot;%s/sitemap-general.xml&quot;, baseURL),<br> })<br><br> // Veritabanına bağlanıyoruz<br> conn, err := mysql.GetConn()<br> if err != nil {<br>  return ctx.Status(500).SendString(&quot;Veritabanı bağlantı hatası&quot;)<br> }<br><br> // Ürünler için sitemap sayfalarını ekle<br> var productCount int<br> err = conn.QueryRow(&quot;SELECT COUNT(*) FROM prod WHERE status = 1&quot;).Scan(&amp;productCount)<br> if err != nil &amp;&amp; err != sql.ErrNoRows {<br>  return ctx.Status(500).SendString(&quot;Ürün sayısı alınamadı&quot;)<br> }<br> productPages := (productCount + SitemapURLLimit - 1) / SitemapURLLimit<br> for i := 1; i &lt;= productPages; i++ {<br>  sitemaps = append(sitemaps, SitemapEntry{<br>   Loc: fmt.Sprintf(&quot;%s/product-sitemap-%d.xml&quot;, baseURL, i),<br>  })<br> }<br><br> // Burada benzer mantıkla kategori, marka veya satıcı sitemaplerini de ekleyebilirsin<br><br> index := SitemapIndex{<br>  XMLNS:    &quot;http://www.sitemaps.org/schemas/sitemap/0.9&quot;,<br>  Sitemaps: sitemaps,<br> }<br><br> ctx.Set(&quot;Content-Type&quot;, &quot;application/xml&quot;)<br><br> output, err := xml.MarshalIndent(index, &quot;&quot;, &quot;  &quot;)<br> if err != nil {<br>  return ctx.Status(500).SendString(&quot;XML oluşturma hatası&quot;)<br> }<br><br> xmlData := append([]byte(xml.Header), output...)<br><br> // Oluşan ana sitemap index&#39;i cache&#39;e kaydediyoruz<br> _ = saveMainSitemapToCache(xmlData)<br> return ctx.Send(xmlData)<br>}</pre><blockquote>Bu fonksiyon, tüm alt sitemap dosyalarını bir <strong>ana sitemap index</strong> altında topluyor.</blockquote><blockquote>İlk olarak statik sayfaları (sitemap-general.xml) ekliyor, sonra ürünleri sayfalamaya göre bölerek (prod-sitemap-1.xml, prod-sitemap-2.xml...) listeye ekliyor.</blockquote><blockquote>Veritabanındaki kayıt sayısına göre sayfalama yapıyoruz, böylece milyonlarca ürün tek bir dosyaya sığmıyor ve Google botları için daha yönetilebilir hale geliyor.</blockquote><blockquote>Oluşturulan index XML’i Couchbase cache’ine kaydediyoruz, böylece sonraki isteklerde çok hızlı dönebilir.</blockquote><pre> app.Get(&quot;/sitemap.xml&quot;, sitemap.GenerateMainSitemapIndex) // genel ana sitemap</pre><p>XML Çıktısı:</p><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;<br>&lt;sitemapindex xmlns=&quot;http://www.sitemaps.org/schemas/sitemap/0.9&quot;&gt;<br>  &lt;sitemap&gt;<br>    &lt;loc&gt;https://example.com/sitemap-general.xml&lt;/loc&gt;<br>  &lt;/sitemap&gt;<br>  &lt;sitemap&gt;<br>    &lt;loc&gt;https://example.com/prod-sitemap-1.xml&lt;/loc&gt;<br>  &lt;/sitemap&gt;<br>  &lt;sitemap&gt;<br>    &lt;loc&gt;https://example.com/prod-sitemap-2.xml&lt;/loc&gt; <br>  &lt;/sitemap&gt;<br>&lt;/sitemapindex&gt;</pre><h4>Go ile Slug Üretimi (gosimple/slug)</h4><pre><br>package sitemap<br><br>import &quot;github.com/gosimple/slug&quot;<br><br>// slug.Make otomatik olarak boşlukları tire yapar,<br> // Türkçe karakterleri dönüştürür ve URL dostu hale getirir<br>func makeSlug(text string) string {<br> return slug.Make(text)<br>}</pre><blockquote>Ben URL’leri daha güvenli ve okunabilir hâle getirmek için gosimple/slug kütüphanesini kullandım. Bu kütüphane başlıklardaki boşlukları tireye çeviriyor, Türkçe karakterleri dönüştürüyor ve URL’de güvenle kullanabileceğimiz bir string üretiyor.<br>(şu komut ile indirebilirsiniz: <strong>go get </strong><a href="https://github.com/gosimple/slug"><strong>github.com/gosimple/slug</strong></a>)</blockquote><h3><strong>Sonuç</strong></h3><blockquote>Bu yazıda, <strong>Go ile dinamik sitemap oluşturma sürecini</strong>, <strong>Fiber framework üzerinde servis etme</strong>, <strong>Couchbase ile cache kullanarak performansı artırma</strong> ve <strong>sayfalama sayesinde büyük veri setlerini yönetilebilir hâle getirme</strong> adımlarını ele aldım. Ayrıca URL’lerin SEO dostu olabilmesi için <strong>gosimple/slug</strong> kütüphanesinden yararlanarak başlıkları güvenli ve okunabilir hâle getirdim.</blockquote><blockquote>Gerçek bir projede karşılaştığım ihtiyaçtan yola çıkarak hazırladığım bu çözüm, özellikle <strong>büyük ürün kataloglarına sahip e-ticaret siteleri</strong> için oldukça kritik. Çünkü arama motorlarının sayfaları hızlı ve verimli bir şekilde taraması, sitenin görünürlüğünü doğrudan etkiliyor. Cache kullanımıyla sorgu yükünü azaltıp performansı artırmak, slug üretimiyle daha temiz URL’ler elde etmek ve sayfalama sayesinde Google’ın limitlerine takılmadan sitemap yönetmek mümkün hale geliyor.</blockquote><blockquote>Özetle, backend tarafında SEO odaklı bir geliştirme yapmam gerekince, doğru teknolojileri (Go, Fiber, Couchbase, gosimple/slug) bir araya getirerek <strong>hem ölçeklenebilir hem de SEO dostu</strong> bir çözüm üretebildim.</blockquote><blockquote>Benim için güzel bir öğrenme süreci oldu. Hem backend bilgimi SEO tarafına nasıl entegre edebileceğimi deneyimledim hem de arama motorlarının nasıl çalıştığına dair daha fazla fikir edindim. Bu yazı, benim gibi backend odaklı çalışıp SEO tarafıyla ilk kez karşılaşan geliştiricilere yol gösterici olabilir diye düşünüyorum.</blockquote><p>Kaynakça<strong> -&gt; “</strong><a href="https://developers.google.com/search/docs?hl=tr"><strong>https://developers.google.com/search/docs/crawling-indexing/sitemaps/build-sitemap?hl=tr</strong></a><strong>”</strong></p><blockquote>Projelerim hakkında daha fazla bilgi edinmek ve geliştirdiğim uygulamalara göz atmak için <a href="https://github.com/Zeyneppsevgi"><strong>Github</strong></a> profilimi ziyaret edebilirsiniz.</blockquote><p><em>Umarım yazı hoşunuza gitmiştir. Geri dönüşlerinizi bekliyorum.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3aeb7c4c187e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SwiftData ile Veri Yönetimi: Projelerim ve Öğrendiklerim]]></title>
            <link>https://medium.com/@zeyneppsevgi/swiftdata-ile-veri-y%C3%B6netimi-projelerim-ve-%C3%B6%C4%9Frendiklerim-d4ff99042c56?source=rss-f9bd6e56f8cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4ff99042c56</guid>
            <category><![CDATA[swiftdata]]></category>
            <category><![CDATA[core-data]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[Zeynep Sevgi]]></dc:creator>
            <pubDate>Mon, 30 Sep 2024 11:58:50 GMT</pubDate>
            <atom:updated>2024-09-30T12:09:33.807Z</atom:updated>
            <content:encoded><![CDATA[<h3>SwiftData</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*qj-3M8lymXb9trCp9aDLIg.jpeg" /><figcaption><a href="https://www.google.com/url?sa=i&amp;url=https%3A%2F%2Fdeveloper.apple.com%2Fvideos%2Fplay%2Fwwdc2023%2F10187%2F&amp;psig=AOvVaw38lf7D8aFKnDAB_xmewrqt&amp;ust=1727783228395000&amp;source=images&amp;cd=vfe&amp;opi=89978449&amp;ved=0CBcQjhxqFwoTCLC4kt_M6ogDFQAAAAAdAAAAABAE">Meet SwiftData — WWDC23 — Videos — Apple Developer</a></figcaption></figure><p><em>Herkese merhaba! Bu yazımda SwiftData framework’ünden bahsetmek istiyorum.</em></p><p><strong>SwiftData Nedir? </strong><br>SwiftData , Apple tarafından 2023 yılında WWDC 2023 etkinliğinde duyurulan, veri yönetimi için kullanılan yeni bir framework’tür.</p><p>SwiftData, uygulamanızın verilerini Swift kodu ile modelleyip kalıcı hale getirmenizi sağlayan, yalın ve güçlü bir API sunuyor. Yeni API’ler sayesinde, özel veri depoları oluşturabilir, işlem geçmişiyle çalışabilir böylelikle veri depolama ve yönetimini daha modern ve kolay hale getirmeyi amaçlar.</p><p><strong>SwiftData vs Core Data?</strong><br>Aslında ikisi de data persistence ( veri kalıcığı) frameworkleridir. Ancak iki framework arasında bazı temel farklılılar vardır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*El2SzuloiKkb9QXvZBwCxQ.png" /><figcaption>SwiftData vs Core Data</figcaption></figure><p><strong>SwiftData’ da Veri Akış Şeması</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f_tnhfUrV_9Nkq_4OET0-A.png" /></figure><p><strong>1.View (Görünüm):</strong> Uygulamanın kullanıcı arayüzünü temsil eder. Kullanıcı, bu arayüzle etkileşime girer ve ekranda gördüğü içeriklere tepki verir. Örneğin, bir butona bastığında ya da bir form doldurduğunda, View bu işlemleri algılar ve gerekli veriyi toplar. Bu veriyi işlemek ya da güncellemek için <strong>ModelContext</strong>’e iletir. Yani, kullanıcıyla veri arasında köprü görevi görür.</p><p><strong>2.ModelContext (Model Bağlamı):</strong> Verilerle etkileşime geçen ve onları yöneten bir yapıdır. View’dan gelen verileri alır ve bu veriler üzerinde işlem yapar. <strong>ModelContext</strong>, verileri anlamlı bir şekilde yönetmek için <strong>ModelContainer</strong> ile birlikte çalışır. Örneğin, CRUD (veri ekleme, silme ya da güncelleme) işlemleri burada gerçekleştirilir. ModelContext, aynı zamanda bu işlemleri kalıcı hale getirmek için <strong>Store</strong> ile iletişim kurar.</p><p><strong>3</strong>.<strong>ModelContainer (Model Yöneticisi):</strong> Verilerin yönetilmesini ve farklı <strong>ModelContext</strong>’ler arasında uyumlu bir şekilde işlenmesini sağlayan bir mekanizmadır. Birden fazla ModelContext ile çalışabilir, böylece uygulamanın farklı kısımlarındaki veri yönetimi işlemlerini koordine eder. Ayrıca, verilerin kalıcı hale getirilmesini sağlamak için <strong>Store</strong> ile etkileşime girer. Yani, verilerin geçici değil, kalıcı olarak saklanmasını mümkün kılar.</p><p><strong>4.Store (Depo):</strong> Verilerin depolandığı yerdir. Bu, verilerin kalıcı hale getirildiği yani diske kaydedildiği kısımdır. <strong>ModelContext</strong>, verileri işledikten sonra bu işlemleri kalıcı hale getirmek için <strong>Store</strong> ile iletişime geçer. Örneğin, bir kullanıcı uygulamada yeni bir kayıt oluşturduğunda ya da mevcut bir kaydı güncellediğinde, bu bilgiler Store’a yazılarak uzun süre saklanır. Store, verilerin güvenli ve erişilebilir bir şekilde tutulmasını sağlar.</p><blockquote>Şimdi bir kod yazalım</blockquote><pre>import Foundation<br>import SwiftData<br>// Veri modeli oluşturuldu<br>@Model<br>final class ToDoItem {<br>    var name: String<br>    var timestamp: Date<br>    var isCritical : Bool<br>    var isCompleted: Bool<br>    <br>    // ToDoItem sınıfından yeni bir nesne oluşturduğumuz<br>    // zaman hangi başlangıç değerlerini verebileceğiimizi belirler.<br>    init(name: String = &quot;&quot;, timestamp: Date = .now, isCritical: Bool = false, isCompleted: Bool = false) {<br>        self.name = name<br>        self.timestamp = timestamp<br>        self.isCritical = isCritical<br>        self.isCompleted = isCompleted<br>    }<br>}</pre><p><strong>SwiftData</strong> kullanılarak bir <strong>ToDoItem </strong>modeli tanımlanıyoruz. <strong>@Model</strong> attribute’u ile işaretlenen bu sınıf, verileri kalıcı olarak depolamak için tasarlanmıştır.</p><pre>import SwiftUI<br>struct CreateToDoView: View {<br>    <br>    @Environment(\.dismiss) var dismiss<br>    @Environment(\.modelContext) var context<br>    <br>    @State private var item = ToDoItem()<br>    var body: some View {<br>        List {<br>            TextField(&quot;Name&quot;, text: $item.name)<br>            DatePicker(&quot;Choose a date&quot;, selection: $item.timestamp)<br>            Toggle(&quot;Know?&quot;, isOn: $item.isCritical)<br>            Button(&quot;Create?&quot;) {<br>                withAnimation{<br>                    context.insert(item)<br>                }<br>                dismiss()<br>            }<br>        }<br>        .navigationTitle(&quot;Create To Do List&quot;)<br>    }<br>}</pre><p>Kullanıcıların yeni bir ToDoItem oluşturmasına olanak tanıyan bir kullanıcı arayüzü sağlar. Kullanıcı, yapılacak öğenin adını, tarihini ve kritik olup olmadığını belirtir. &quot;Create? &quot; butonuna tıklandığında, yeni öge veritabanına eklenir ve ardından kullanıcı, mevcut görünüme geri döner.</p><pre>@Environment(\.modelContext) var context</pre><p>@Environment: SwiftUI&#39;da, bir görünümün çevresel (environment) özelliklerini almak için kullanılır. Burada, modelContext, SwiftData framework’ü ile veritabanı işlemlerini gerçekleştirmek için gerekli olan model bağlamını (context) sağlar. Bu bağlam, verilerin kaydedilmesi ve güncellenmesi gibi işlemler için kullanılır.</p><pre>import SwiftUI<br>import SwiftData</pre><pre>struct ToDoListView: View {<br>    <br>    @Environment(\.modelContext) var context<br>    <br>    @State private var showCreate = false<br>    @State private var toDoToEdit: ToDoItem?<br>    @Query(filter: #Predicate&lt;ToDoItem&gt; { $0.isCompleted == false }, sort: \.timestamp, order: .reverse)<br>    private var items: [ToDoItem]<br>    var body: some View {<br>        NavigationView {<br>            List {<br>                ForEach(items) { item in<br>                    HStack {<br>                        VStack(alignment: .leading) {<br>                            if item.isCritical {<br>                                Image(systemName: &quot;exclamationmark.3&quot;)<br>                                    .symbolVariant(.fill)<br>                                    .foregroundColor(.red)<br>                                    .font(.largeTitle)<br>                                    .bold()<br>                            }<br>                            Text(item.name)<br>                                .font(.title)<br>                                .bold()<br>                            Text(&quot;\(item.timestamp, format: Date.FormatStyle(date: .numeric, time: .shortened))&quot;)<br>                                .font(.callout)<br>                        }<br>                        Spacer()<br>                        Button {<br>                            withAnimation {<br>                                item.isCompleted.toggle()<br>                            }<br>                        } label: {<br>                            Image(systemName: &quot;checkmark&quot;)<br>                                .symbolVariant(.circle.fill)<br>                                .foregroundStyle(item.isCompleted ? .green : .gray)<br>                                .font(.largeTitle)<br>                        }<br>                        .buttonStyle(.plain)<br>                    }<br>                    .swipeActions {<br>                        Button(role: .destructive) {<br>                            withAnimation {<br>                                context.delete(item)<br>                            }<br>                        } label: {<br>                            Label(&quot;Delete&quot;, systemImage: &quot;trash&quot;)<br>                                .symbolVariant(.fill)<br>                        }<br>                        <br>                        Button {<br>                            toDoToEdit = item<br>                        } label: {<br>                            Label(&quot;Edit&quot;, systemImage: &quot;pencil&quot;)<br>                        }<br>                        .tint(.orange)<br>                    }<br>                }<br>            }<br>            .navigationTitle(&quot;List&quot;)<br>            .toolbar {<br>                ToolbarItem {<br>                    Button(action: {<br>                        showCreate.toggle()<br>                    }, label: {<br>                        Label(&quot;Öge Ekle&quot;, systemImage: &quot;plus&quot;)<br>                    })<br>                }<br>            }<br>            .sheet(isPresented: $showCreate, content: {<br>                NavigationView {<br>                    CreateToDoView()<br>                }<br>                .presentationDetents([.medium])<br>            })<br>            .sheet(item: $toDoToEdit) { item in<br>                UpdateToView(item: item)<br>            }<br>        }<br>    }<br>}<br>#Preview {<br>    ToDoListView()<br>}</pre><p>Bu ToDoListView , kullanıcıların yapılacaklar listesini etkili bir şekilde yönetmelerini sağlayan kullanıcı dostu bir arayüz sunar. Kullanıcılar, listede mevcut olan yapılacak öğeleri görüntüleyebilir, her bir öğenin detaylarını inceleyebilir ve tamamlanmış veya önemli öğeleri kolayca işaretleyebilirler. Ayrıca, kullanıcıların yeni öğeler eklemelerini sağlayan &quot;Öğe Ekle&quot; butonu sayesinde, kullanıcılar listeye hızla yeni notlar ekleyebilirler. Liste üzerinde bulunan kaydırma eylemleri, kullanıcıların öğeleri silmelerine veya düzenlemelerine imkan tanır, böylece uygulama akışında esneklik ve kullanıcı kontrolü sağlar.</p><p><strong>SONUÇ</strong><br>Sonuç olarak, SwiftData framework’ü, Apple’ın veri yönetimi alanında sağladığı modern ve güçlü bir çözüm sunarak geliştiricilerin uygulama verilerini daha etkili bir şekilde modellemelerine ve kalıcı hale getirmelerine olanak tanır. Bu framework, kullanıcı arayüzleri ile veri yönetimini bir araya getirerek, kullanıcı deneyimini geliştiren sezgisel uygulamalar oluşturmayı mümkün kılar. ToDoList örneği, SwiftData kullanarak nasıl kullanıcı dostu bir yapılacaklar listesi oluşturulabileceğini göstermektedir. Kullanıcıların yeni öğeler ekleyebileceği, mevcut öğeleri düzenleyebileceği ve tamamlanan öğeleri işaretleyebileceği, silebileceği bir uygulamadır. SwiftData’nın sağladığı yapılar, geliştiricilerin veri akışını kolayca yönetmelerini sağlar, bu da uygulama performansını ve kullanıcı memnuniyetini artırır.</p><p>Kaynakça -&gt; “<a href="https://developer.apple.com/xcode/swiftdata/">https://developer.apple.com/xcode/swiftdata</a>”</p><p>Projelerim hakkında daha fazla bilgi edinmek ve geliştirdiğim uygulamalara göz atmak için <a href="https://github.com/Zeyneppsevgi"><strong>Github</strong></a> profilimi ziyaret edebilirsiniz Github adresime bakıp geliştirdiğim projelerden faydalanabilirisin.</p><blockquote>Umarım yazı hoşunuza gitmiştir. Geri dönüşlerinizi bekliyorum.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4ff99042c56" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[iOS Swift-MVVM Mimarisi]]></title>
            <link>https://medium.com/@zeyneppsevgi/ios-swift-mvvm-mimarisi-1d70934a1487?source=rss-f9bd6e56f8cf------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d70934a1487</guid>
            <category><![CDATA[mvvm]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[weather-app-for-iphone]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Zeynep Sevgi]]></dc:creator>
            <pubDate>Wed, 01 Nov 2023 19:55:35 GMT</pubDate>
            <atom:updated>2023-11-02T19:43:09.405Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Herkese merhaba! Bu yazımda MVVM mimarisinden bahsetmek istiyorum.MVVM (Model-View-ViewModel), Yazılım ve uygulama geliştirmenin önemli bir parçasıdır. MVVM mimarisi, kod kalitesini ve sürdürebilirliği artırabilir.</blockquote><h4>MVVM Mimarisinin Ortaya Çıkışı</h4><p>MVVM mimarisinin tarihsel gelişimi, yazılım geliştirme süreçlerinin sonucunda bir ihtiyaç olarak ortaya çıkmıştır. MVVM’nin oluşumunda, kullanıcı arayüzü ve arka plandaki kodlar arasındaki ayrımın gerekliliği için bu mimari önemli bir yere sahiptir. İlk olarak, Model-View-Controller (MVC) tasarım deseni yazılım geliştirmenin temelini atmıştır. Ancak, bu desenin kullanımı büyük ve karmaşık uygulamalarda veri bağlamını yönetmekte zorluklar yaşanmasına neden olmuştur. Bu sorunları çözmek için Model-View-ViewModel (MVVM) tasarım deseni geliştirilmiştir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*R5XfdSmq_qpOQlZ1OMaFWw.jpeg" /><figcaption>MVVM image</figcaption></figure><h3>MVVM Mimarisi Nedir?</h3><p>Bir yazılım projesi geliştirirken, projenin büyüklüğü ve karmaşıklığı, yazılım mimarisinin ne kadar önemli olduğunu gösterir. Büyük projelerde, karmaşık etkileşimler, büyük veri hacimleri ve birden fazla ekibin çalışması gibi zorluklarla karşılaşabilirsiniz. Ayrıca, projenin bir noktadan sonra başkası tarafından devralınması gerekebilir. Bu gibi durumlarda sağlam bir yazılım mimarisi, proje yönetimini ve sürdürülebilirliği büyük ölçüde kolaylaştırır. Kodun daha kolay test edilebilir, yeniden kullanılabilir ve bakımı daha kolay hale getirmesine yardımcı olabilir.</p><blockquote>Gelin bunu günlük hayattan bir örnek ile açıklayalım.</blockquote><p>Ev alımı sürecinde, evlerin fiziksel özellikleri, fiyatları, yerleşim bölgeleri, vb. gibi veriler <strong>Model</strong>’i temsil eder. Bu veriler, almayı düşündüğünüz evlerin karakteristiklerini içerir.</p><p>Görüntü, bu senaryoda almayı düşündüğünüz evleri gördüğünüz ve incelediğiniz yerdir.<strong><em> </em></strong>Evleri ziyaret etmek, fotoğraflarını görmek veya ilanları incelemek, <strong>View</strong>’i temsil eder.</p><p><strong>ViewModel</strong>, ev alımında, birçok faktörü değerlendirmeniz gerekebilir: Evin büyüklüğü, konumu, fiyatı, sahibi, cephesi ,vb. ViewModel, bu faktörleri bir araya getirir, evlerin avantajlarını ve dezavantajlarını anlatır ve nihai kararı vermenize yardımcı olur. ViewModel, kullanıcıya her evin avantajlarını ve dezavantajlarını gösterir, böylece kullanıcı doğru evi seçebilir.</p><p>Kullanıcı, View üzerinden evleri inceler, beğenir veya beğenmez ve ViewModel üzerinden geri bildirim sağlar. ViewModel, kullanıcının tercihlerini alır ve kullanıcıya uygun model verileriyle eşleştirir.</p><blockquote><strong>Özetle:</strong><br><strong>MVVM mimarisi, kullanıcıların ev alımı gibi karmaşık kararlar alırken karşılaştıkları veri ve bilgileri organize etmelerine ve bu verileri kullanarak bilinçli kararlar vermelerine yardımcı olur. Kullanıcı, Model (evlerin özellikleri), ViewModel (evlerin avantajları ve dezavantajları) ve View (evlerin görsel temsili) arasında akıcı bir etkileşimle en iyi evi seçebilir. Bu, MVVM’nin günlük hayatta nasıl kullanılabileceğini anlamak için iyi bir örnektir.</strong></blockquote><p><strong>Şimdi bir Weather Application uygulaması yapalım.</strong></p><h3>Model</h3><p>İlk olarak modelimi oluşturuyorum. Hava durumunda enlem, boylam, günlük, haftalık nesnelerini oluşturuyorum.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wZC33Hm2Vbc680cKA7tkEA.png" /></figure><h3>ViewModel</h3><p>ViewModel kullanıcı etkileşimini View’dan alır, Model’ den veri alır, daha sonra hazır olan verileri ekranda gösterir.<br>ViewModel, hava durumu verilerimizin olduğu kısımdır.<br>Örneğin, “fetchWeather”fonksiyonu, belirtilen enlem ve boylam koordinatlarına sahip hava durumu verilerini alır ve bu verileri “Daily”veri modeli ile ilişkilendirir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R3-JktqDfrExdyZEBSIDrg.png" /></figure><h3>View</h3><p>MVVM mimarisininde ViewController’ı View olarak kullanıyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ec53zkwVV32yc91WWk5nmw.png" /></figure><h3>Dosyalama Şekli</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*RCm92oPq0Ko5T1OoE_fjew.png" /></figure><h3>Simülatörde görünümü;</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/738/1*n0KbYbNePiYja1qL1bx_Rg.png" /></figure><h3>Sonuç</h3><p><em>Sonuç olarak, MVVM (Model-View-ViewModel) mimarisi, yazılım geliştirme süreçlerinde veri yönetimi ve kullanıcı arayüzü tasarımını daha düzenli ve yönetilebilir hale getiren bir mimaridir. MVVM mimarisi uygulamaların geliştirilmesini kolaylaştırırken kodun daha düzenli ve test edilebilir olmasını sağlar. MVVM, modern uygulama geliştirme projelerindeki karmaşıklığı azaltmak ve daha kaliteli yazılım elde etmek isteyen geliştiriciler için önemli bir mimari tercihidir.</em></p><p><a href="https://github.com/Zeyneppsevgi/CaseStudy">Projenin tamamı</a> merak edip bakmak isteyenler için buraya bırakıyorum.<br>Umarım yazı hoşunuza gitmiştir. Geri dönüşlerinizi bekliyorum.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d70934a1487" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>