
Apache Kafka Sıralı Günlük Mimarisi ve Sıfır Kopyalama Tüketimi
Kafka mesaj kuyruğu yerine sıralı commit log kullanarak disk G/Ç maliyetini düşürürken page cache ve sendfile ile sıfır kopyalama verimi sağlar.
Dağıtık mimarilerde asenkron veri aktarımı tasarlandığında ilk akla gelen bileşen geleneksel mesaj kuyruklarıdır. RabbitMQ veya ActiveMQ gibi geleneksel yapılar mesajları bellekte tutar, tüketicilere dağıtır ve her tüketim onayında (ack) ilgili mesajı veri yapısından siler. Tüketici sayısı arttıkça veya kuyrukta yüz binlerce mesaj biriktiğinde bellek yönetimi çöker, B-Tree indeks güncellemeleri diski rastgele erişimlerle (random I/O) kilitler.
Apache Kafka bu problemin köküne farklı bir bakış açısıyla yaklaşır. Kafka klasik bir mesaj kuyruğu değildir. Kafka disk üzerinde yalnızca sona ekleme yapılan (append-only) dağıtılmış ve sıralı bir kayıt kütüğüdür (commit log). Mesajlar tüketildiğinde silinmez. Tüketiciler yalnızca kütük üzerindeki bir işaretçiyi (offset) ileri taşır.
Bu mimari tercih iki devasa işletim sistemi avantajını beraberinde getirir. Linux çekirdeğinin sayfa önbelleği (page cache) ve ağ soketine doğrudan veri aktaran sıfır kopyalama (zero-copy) mekanizması.
1. Rastgele Erişim Çıkmazı ve Sıralı Günlük Tasarımı
Geleneksel ilişkisel veritabanları ve B-Tree tabanlı kuyruk motorları her mesaj ekleme veya silme işleminde disk bloklarında rastgele arama ve güncelleme yapar. Modern NVMe SSD disklerde dahi rastgele yazma işlemleri flash hücrelerinin silinip yeniden yazılması (write amplification) sebebiyle sıralı yazmaya kıyasla belirgin şekilde yavaştır. Mekanik sabit disklerde (HDD) ise okuma kafasının fiziksel hareketi sebebiyle bu fark yüzlerce kata çıkar.
Kafka veriyi bellekte karmaşık indeks ağaçlarında tutmak yerine doğrudan dosya sisteminde sıralı parçalar (segment files) halinde depolar. Yeni gelen her kayıt aktif segment dosyasının sonuna ardışık baytlar olarak eklenir.
+-------------------------------------------------------------------------+
| KAFKA PARTITION (BÖLÜM) DİZİNİ |
| |
| 00000000000000000000.log (Eski segment, salt okunur) |
| 00000000000000000000.index |
| 00000000000000000000.timeindex |
| |
| 00000000001054320000.log (Aktif segment, append-only yazma) |
| [Offset: 1054320001] -> [Offset: 1054320002] -> [YENİ KAYITLAR...] |
+-------------------------------------------------------------------------+
Segment dosyaları varsayılan olarak 1 GB boyutuna ulaştığında kapatılır ve yeni bir aktif segment açılır. Eski segment dosyaları artık değiştirilemez (immutable) kütüklere dönüşür. Bu yapı LSM-Tree ve B-Tree Depolama Motorları mimarisindeki append-only felsefesiyle birebir örtüşür.
Kayıt kütüğündeki arama maliyetini düşürmek için Kafka seyrek indeks (sparse index) kullanır. Her mesaj için değil, belirli bayt aralıklarında (varsayılan olarak 4 KB) bir indeks kaydı tutulur. Tüketici belirli bir offset değerini talep ettiğinde Kafka önce seyrek indekste ikili arama (binary search) yapar, ardından doğrudan segment dosyasındaki ilgili bayt konumuna atlar.
2. JVM Heap Tuzağı ve Linux Page Cache
Kafka Java ve Scala dillerinde yazılmış bir sistemdir. Ancak Kafka broker süreçleri devasa JVM yığın (heap) bellekleri tahsis etmekten kaçınır. 64 GB belleğe sahip bir sunucuda Kafka broker için genellikle 6 GB veya 8 GB heap ayrılır. Geriye kalan tüm bellek Linux çekirdeğinin sayfa önbelleğine (page cache) bırakılır.
Bu tercihin arkasında üç kritik mühendislik gerekçesi bulunur:
- Çöp Toplayıcı (Garbage Collector) Duraklamaları: JVM içinde yüz milyonlarca küçük nesne tutulduğunda çöp toplayıcı duraklamaları (Stop-the-World pauses) saniyeler sürebilir. Bu durum kümede sahte düğüm kopmalarına (node failure) ve lider yeniden seçim fırtınalarına yol açar.
- Nesne Bellek Şişmesi: JVM içinde 24 baytlık ham bir mesaj nesne başlıkları ve referans işaretçileri nedeniyle 80 bayta kadar büyüyebilir. Ham bayt dizilerini çekirdek belleğinde tutmak bellek verimini katlar.
- Süreç Çöküşünde Bellek Dayanıklılığı: Kafka broker süreci çökerse veya yeniden başlatılırsa JVM heap belleği tamamen sıfırlanır. Ancak Linux page cache işletim sistemi çekirdeğine aittir. Broker yeniden başladığında tüm sıcak veriler bellekte hazır bekler.
Kafka bir segment dosyasına yazma yaptığında aslında doğrudan diske yazmaz. Çekirdeğin sayfa önbelleğindeki ilgili 4 KB sayfalara yazar. Çekirdek bu sayfaları kirli (dirty) olarak işaretler ve arka plan flush iş parçacıkları (flusher threads) bu verileri asenkron olarak diske senkronize eder.
3. Sıfır Kopyalama Tüketim Yolu: sendfile()
Kafka üzerinden veri tüketen bir istemci veri okuduğunda geleneksel dosya aktarım mekanizması devasa bir CPU yükü üretir.
Geleneksel bir web veya mesaj sunucusunda diski okuyup ağa göndermek şu dört adımı gerektirir:
GELENEKSEL VERİ AKTARIMI (4 Bağlam Geçişi, 4 Kopyalama):
[Disk] --DMA--> [Kernel Page Cache] --CPU Copy--> [User Space Buffer]
|
CPU Copy
v
[Ağ Kartı] <--DMA-- [Socket Buffer (Kernel)] <-----------+
- Çekirdek
read()çağrısı ile veriyi diskten page cache alanına DMA (Direct Memory Access) ile okur. - Çekirdek veriyi kullanıcı alanındaki (user space) uygulama tamponuna CPU ile kopyalar.
- Uygulama veriyi ağa göndermek için
write()veyasend()sistem çağrısını tetikler. - Çekirdek veriyi kullanıcı alanından soket tamponuna (socket buffer) ikinci kez CPU ile kopyalar.
- Ağ kartı soket tamponundaki veriyi DMA ile fiziksel hatta basar.
Bu döngüde dört kez kullanıcı-çekirdek bağlam geçişi (context switch) gerçekleşir ve veri bellekte iki kez gereksiz yere CPU ile taşınır.
Kafka Java NIO kütüphanesinin FileChannel.transferTo() metodunu kullanır. Linux çekirdeğinde bu metod doğrudan sendfile() sistem çağrısına eşlenir.
SIFIR KOPYALAMA VERİ AKTARIMI (2 Bağlam Geçişi, Sıfır CPU Kopyalama):
[Disk] --DMA--> [Kernel Page Cache]
|
DMA Gather / SG-DMA
v
[Ağ Kartı] <-----------+
sendfile() çağrıldığında:
- Veri diskten page cache alanına DMA ile okunur.
- Veri kullanıcı alanına (JVM) ASLA kopyalanmaz.
- Ağ kartı scatter-gather DMA (SG-DMA) destekliyorsa veri page cache alanından doğrudan ağ kartının FIFO tamponuna kopyalanır. Yalnızca veri uzunluğu ve bellek işaretçisi içeren minik bir tanımlayıcı soket tamponuna yazılır.
Sonuç olarak CPU bellekteki veriyi taşımak için tek bir döngü dahi harcamaz. Tüketici sayısı 1 yerine 100 olduğunda dahi veriler page cache üzerinden aynı bellek işaretçileriyle yüzlerce istemciye neredeyse saf ağ kartı hat hızında dağıtılır. Bu mimari Linux io_uring ve epoll Mimarisi incelememizde ele aldığımız asenkron çekirdek tasarımıyla aynı prensibi paylaşır.
4. Tüketici İşaretçi Yönetimi: __consumer_offsets
Klasik mesaj kuyruklarında her mesajın teslim edilip edilmediği broker tarafından tekil olarak takip edilir. Milyonlarca mesajın her biri için ack beklemek kuyruk düğümünde kilit çekişmesini (lock contention) tavan yaptırır.
Kafka bu maliyeti tüketiciye devreder. Broker mesaj durumunu tutmaz. Broker yalnızca her tüketici grubunun (consumer group) o bölümde hangi ofsette olduğunu saklar. Bu bilgi de yine Kafka içinde özel bir konu olan __consumer_offsets başlığına append-only olarak yazılır.
Tüketici bir mesajı işlediğinde broker üzerindeki veri durumu değişmez. Tüketici yalnızca kendi offset değerini ilerletir:
[Bölüm 0 Kütüğü]: [Msg 0] [Msg 1] [Msg 2] [Msg 3] [Msg 4] [Msg 5]
^ ^
| |
Tüketici A (Offset: 2) Tüketici B (Offset: 4)
Bu model sayesinde:
- Bir tüketici geriye dönük olarak mesajları tekrar okuyabilir (replay).
- Hata durumunda offset geriye çekilebilir.
- Tüketici hızları birbirinden bağımsızdır, yavaş bir tüketici hızlı tüketicinin veri akışını engellemez.
5. Üretim Ortamı Çekirdek ve Broker Ayarları
Kafka üretim kümesinde çalıştırılırken Linux çekirdeğinin bellek sayfalarını diske yazma davranışı optimize edilmelidir. Yanlış ayarlanmış bir Linux sunucusunda çekirdek aniden tüm G/Ç operasyonlarını durdurarak kirli sayfaları tek seferde diske yazmaya çalışabilir.
Önerilen Linux /etc/sysctl.conf yapılandırması:
# Arka plan kirli sayfa temizliğinin başlayacağı bellek eşiği
vm.dirty_background_ratio = 5
# Tüm G/C işlemlerinin durdurulup yazmanın zorlandığı tavan eşik
vm.dirty_ratio = 10
# Sayfaların bellekte ne kadar süre kalabileceği (yüzde bir saniye cinsinden)
vm.dirty_expire_centisecs = 3000
# Swappiness değerini düşürerek diske takas alanı kullanımını engelle
vm.swappiness = 1
Broker tarafında ise server.properties dosyasında şu parametrelerin izlenmesi gerekir:
# İşletim sisteminin page cache mekanizmasına güven, Kafka seviyesinde zorunlu fsync kapat
# Sürekli fsync çağırmak sıralı G/C avantajını yok eder
log.flush.interval.messages=9223372036854775807
log.flush.interval.ms=9223372036854775807
# Sıfır kopyalama çağrılarının aktif olduğundan emin ol
# Varsayılan değer true gelir, kapatılmamalıdır
log.cleaner.enable=true
Sistem mühendisliğinde Kafka kullanırken unutulmaması gereken temel gerçek şudur. Kafka diski yavaş bir depolama birimi olarak değil, sıralı erişildiğinde neredeyse bellek hızına yaklaşan devasa bir dairesel tampon kütüğü olarak kullanır. Donanımı zorlamak yerine Linux çekirdeğinin sunduğu hazır yeteneklerle uyum içinde çalışmak bu mimarinin asıl başarısını oluşturur.
Yazıyı Değerlendir
0 tepkiFikirlerinizi tek tıkla paylaşarak geri bildirim bırakın.
Ali Purtaş
@alipurtas • Hey, This is Ali!
Kendi halinde yazılım geliştiren bir öğrenci. Sistemler kuruyor, deniyor, bozuyor ve öğrendiği gerçek çözümleri burada belgeliyor.
Konu Kümesi & Önerilen Yazılar
Redis Pub/Sub ile L1/L2 Çok Katmanlı Önbellek Geçersizleştirme Ağı
Süreç içi yerel RAM (L1) ile merkezi Redis (L2) katmanlarını senkron tutan Pub/Sub tabanlı geçersizleştirme ve istemci önbellekleme mimarisi.
Önbellek İzdihamı ve XFetch Probabilistik Erken Yenileme Algoritması
Önbellek izdihamı (cache stampede) krizlerini önleyen XFetch olasılıksal erken yenileme algoritması ve tekil uçuş (singleflight) desen analizi.
Write-Behind Önbellekleme ve Veritabanı Toplu Yazma Yükü Mimarisi
Write-behind önbellekleme ile yazma gecikmesini düşürme, toplu veritabanı yazımları, veri kaybı riskleri ve çöküş kurtarma mimari rehberi.
Tartışma & Yorumlar
0Tartışmaya katılmak ve soru sormak için oturum açmalısınız.
Giriş Yap