İçeriğe atla

Queue, Stream ve Pub/Sub: Bir Mesajın Davranışını Belirleyen Üç Soru

Queue, pub/sub ve stream bir mesaj hakkında üç ayrı soruya yanıt verir: okununca silinir mi, kopyayı kim alır, ilerlemeyi kim tutar. Çalıştırılabilir demo ile.

Ayhan Sipahi Ayhan Sipahi

Queue (kuyruk), pub/sub ve stream çoğu zaman aynı şeyin üç sürümü gibi karşılaştırılır. Bu karşılaştırma seçimi zorlaştırır, çünkü üç kelime bir mesaj hakkında farklı sorulara yanıt verir. Queue ile stream, okumanın mesajı silip silmediği ve ilerlemeyi kimin hatırladığı konusunda ayrışır. Pub/sub ise yalnızca kopyayı kimin aldığını söyler. Kalıcı biçimleri kuyrukların ya da bir log’un üzerine kurulur; düz bir push aboneliği ise mesajı yalnızca teslimat denemeleri sürdükçe tutar.

İlk sistem için tek bir eşleştirme ihtiyaçların çoğunu karşılar. Bir havuzdaki tek bir worker’ın yapması gereken iş kuyruğa gider. Birden fazla servisin tepki verdiği olgular pub/sub’a gider ve her abonenin kendi kalıcı kuyruğu olur. İkisi de bir mesajı birden fazla kez teslim edebilir; bu yüzden handler’lar tekrarı kaldırabilmelidir. Bir consumer geçmişi okumak zorundaysa ya da sıralı trafik sıralı bir kuyruğun taşıyabileceğini aşıyorsa, sıradaki adım log’dur.

Aynı üç yanıt, tanımadığınız bir broker’ın bildiğinizden neden farklı davrandığını da açıklar. Üç soru, Event Odaklı Düşünmek yazısının bıraktığı yerden devam eder: o yazı komut ile event’i ayırır ve teslimat ayrıntılarını açık bırakır.

İsimlerin Arkasındaki Üç Soru#

Her kanal bir mesaj hakkında üç soruya yanıt vermek zorundadır ve her yanıt ötekilerden bağımsız seçilebilir.

  1. Okuma mesajı siler mi? Kuyruk yıkıcı okur: teslim edilen mesaj tek bir consumer için tutulur ve o consumer onayladığında (ack) silinir. Log yıkıcı olmayan biçimde okur: kayıt, saklama süresi dolana kadar yerinde durur ve yeniden okunabilir.
  2. Kopyayı kim alır? Mesajı ya bir havuzdaki consumer’lardan yalnızca biri alır ya da her abone kendi kopyasını alır.
  3. İlerlemeyi kim hatırlar? Ya broker her mesajın durumunu takip eder ya da her consumer sıralı bir log içinde tek bir konumu takip eder.

Queue bu yanıtların sabit bir kümesidir: okuma yıkıcıdır, mesajı tek bir consumer alır ve takibi broker yapar. Stream başka bir kümedir: kayıtlar yerinde kalır ve her okuyucu kendi konumunu tutar. Pub/sub yalnızca ikinci soruyu yanıtlar. Silme ya da ilerleme hakkında bir şey söylemez; bu iki yanıt her aboneliğin arkasında ne olduğuna bağlıdır.

Tablo her biçim için yanıtları gösterir. Son sütundaki iki terim ileride açıklanıyor. Partition bir log’un sıralı tek bir dilimidir, consumer group ise partition’ları aralarında bölüşen ve ilerlemesini paylaşan okuyucular kümesidir.

SoruQueuePub/subStream (log)
Mesaj okunduktan sonra duruyor mu?Hayır, onaylanınca silinirHer aboneliğin arkasında ne olduğuna bağlıEvet, saklama süresi dolana kadar
Belirli bir mesajı kim alır?Havuzdan tek bir consumerHer abonelik bir kopya alır; aynı abonelikteki consumer’lar paylaşırHer consumer group, başlangıç offset’inden itibaren her kaydı alır; grup içinde partition başına tek üye
İlerlemeyi kim takip eder?Broker, mesaj başınaHer aboneliğin arkasında ne olduğuna bağlıHer consumer group, partition başına tek offset
Geç katılan geçmişi okuyabilir mi?HayırHayır; abonelik önceden varsa ya da saklama ve seek ayarlıysa evetEvet, saklanan herhangi bir offset’ten başlayarak ya da oraya seek ederek
SıralamaConsumer’lar yarışınca kaybolur; FIFO türleri sırayı mesaj grubu başına korurVarsayılan olarak garanti yok; ordering key ile anahtar başına eklenebilirYalnızca partition başına
Consumer’lar nasıl ölçeklenir?Serbestçe consumer eklenirAbonelik içine consumer eklenirKlasik consumer group başına partition sayısına kadar

Diyagram, pub/sub’ın kalıcı iki kurulum biçimini gösterir. İlk zincirde topic her mesajı abone başına bir kuyruğa kopyalar. İkinci zincirde iki servis aynı log’u okur ve her biri kendi offset’ini tutar.

kopya

kopya

offset 4

offset 1

Yayıncı

Topic

billing kuyruğu

email kuyruğu

billing worker'ları

email worker'ları

Yayıncı

Log: o1, o2, o3, o4

billing okuyucuları

email okuyucuları

Her Biçim için Çalıştırılabilir Bir Demo#

Üç biçim, hiçbir altyapı gerektirmeden tek bir dosyaya sığar. WorkQueue her mesajın durumunu tutar ve ack gelince mesajı siler. Topic abone başına bir WorkQueue tutar ve yayınlanan her mesajı hepsine kopyalar. Log her kaydı saklar ve okuyucu başına commit edilmiş tek bir offset tutar.

type Msg = { id: string; body: string };

// Queue: the broker tracks every message. ack deletes it, nack puts it back at the end.
class WorkQueue {
  private ready: Msg[] = [];
  private inFlight = new Map<string, Msg>();

  send(m: Msg): void {
    this.ready.push(m);
  }
  receive(): Msg | undefined {
    const m = this.ready.shift();
    if (m) this.inFlight.set(m.id, m);
    return m;
  }
  ack(id: string): void {
    this.inFlight.delete(id);
  }
  nack(id: string): void {
    const m = this.inFlight.get(id);
    if (!m) return;
    this.inFlight.delete(id);
    this.ready.push(m);
  }
  get size(): number {
    return this.ready.length + this.inFlight.size;
  }
}

// Pub/sub: one input, one queue per subscriber. A late subscriber starts empty.
class Topic {
  private subs = new Map<string, WorkQueue>();

  subscribe(name: string): WorkQueue {
    const q = new WorkQueue();
    this.subs.set(name, q);
    return q;
  }
  publish(m: Msg): void {
    for (const q of this.subs.values()) q.send({ ...m });
  }
}

// Log: records stay. The log stores one committed offset per reader. seek is replay.
class Log {
  private records: Msg[] = [];
  private committed = new Map<string, number>();

  append(m: Msg): void {
    this.records.push(m);
  }
  // Reading moves nothing. It returns records from the reader's committed offset.
  read(reader: string, max: number): Msg[] {
    const from = this.committed.get(reader) ?? 0;
    return this.records.slice(from, from + max);
  }
  // Progress moves only when the reader commits what it has processed.
  commit(reader: string, count: number): void {
    this.committed.set(reader, (this.committed.get(reader) ?? 0) + count);
  }
  seek(reader: string, offset: number): void {
    this.committed.set(reader, offset);
  }
  get size(): number {
    return this.records.length;
  }
}

Dosyanın ikinci yarısı aynı dört siparişi her yapıdan geçirir.

const orders: Msg[] = ['o1', 'o2', 'o3', 'o4'].map((id) => ({ id, body: `order ${id}` }));
const ids = (batch: Msg[]): string => batch.map((m) => m.id).join(', ') || '(nothing)';

function drain(q: WorkQueue): Msg[] {
  const seen: Msg[] = [];
  for (let m = q.receive(); m; m = q.receive()) {
    seen.push(m);
    q.ack(m.id);
  }
  return seen;
}

console.log('== Queue: two workers compete ==');
const queue = new WorkQueue();
for (const o of orders) queue.send(o);

const workers = ['worker-A', 'worker-B'];
let turn = 0;
let failedOnce = false;
for (let m = queue.receive(); m; m = queue.receive()) {
  const worker = workers[turn++ % workers.length];
  if (m.id === 'o2' && !failedOnce) {
    failedOnce = true;
    queue.nack(m.id);
    console.log(`${worker} received ${m.id} -> nack (handler failed)`);
  } else {
    queue.ack(m.id);
    console.log(`${worker} received ${m.id} -> ack`);
  }
}
console.log(`messages left in the queue: ${queue.size}`);

console.log('\n== Pub/sub: every subscriber gets a copy ==');
const topic = new Topic();
const billing = topic.subscribe('billing');
const email = topic.subscribe('email');
for (const o of orders.slice(0, 3)) topic.publish(o);

const analytics = topic.subscribe('analytics');
topic.publish(orders[3]);

console.log(`billing received: ${ids(drain(billing))}`);
console.log(`email received: ${ids(drain(email))}`);
console.log(`analytics (subscribed after o3) received: ${ids(drain(analytics))}`);

console.log('\n== Log: each reader commits its own offset ==');
const log = new Log();
for (const o of orders) log.append(o);

function consume(reader: string, max: number): string {
  const batch = log.read(reader, max);
  log.commit(reader, batch.length);
  return ids(batch);
}

console.log(`fast reader: ${consume('fast', 4)}`);
console.log(`slow reader: ${consume('slow', 1)}`);
console.log(`slow reader reads ${ids(log.read('slow', 1))} and stops before commit`);
console.log(`slow reader after restart: ${consume('slow', 1)}`);
console.log(`audit (joined late): ${consume('audit', 4)}`);
console.log(`fast reader again: ${consume('fast', 4)}`);
log.seek('fast', 1);
console.log(`fast reader after seek(1): ${consume('fast', 4)}`);
console.log(`records still in the log: ${log.size}`);

İki parçayı bu sırayla channels.ts adıyla kaydedin. Type stripping’in varsayılan olarak açık olduğu Node sürümleri dosyayı doğrudan çalıştırır: 22 serisinde 22.18 ve sonrası, ayrıca Node 24 dahil 23.6’dan itibaren her sürüm.

node channels.ts

Node 22 üzerindeki bir çalıştırmanın çıktısı şöyledir:

== Queue: two workers compete ==
worker-A received o1 -> ack
worker-B received o2 -> nack (handler failed)
worker-A received o3 -> ack
worker-B received o4 -> ack
worker-A received o2 -> ack
messages left in the queue: 0

== Pub/sub: every subscriber gets a copy ==
billing received: o1, o2, o3, o4
email received: o1, o2, o3, o4
analytics (subscribed after o3) received: o4

== Log: each reader commits its own offset ==
fast reader: o1, o2, o3, o4
slow reader: o1
slow reader reads o2 and stops before commit
slow reader after restart: o2
audit (joined late): o1, o2, o3, o4
fast reader again: (nothing)
fast reader after seek(1): o2, o3, o4
records still in the log: 4

Queue bölümünde her teslimat tek bir worker’a gider. worker-B, o2’yi işlerken hata alır ve mesajı nack ile geri verir. o2 ancak o4’ten sonra geri gelir ve ikinci seferde onu worker-A işler. Gönderim sırası o1’den o4’e doğruydu, tamamlanma sırası ise o1, o3, o4, o2 oldu. Bütün mesajlar onaylandığında kuyrukta hiçbir şey kalmaz.

Pub/sub bölümü billing ve email abonelerinin her birine dört siparişin hepsini verir, çünkü topic her mesajı iki kuyruğa da kopyalar. analytics, o3 yayınlandıktan sonra abone olur ve yalnızca o4’ü alır. Önceki üç sipariş onun kuyruğuna hiç kopyalanmadı; bu yüzden hiçbir yeniden deneme onları geri getiremez.

Okumanın veriyi yerinde bıraktığı tek bölüm log bölümüdür. Hızlı okuyucu dört kaydın hepsini, yavaş okuyucu ise tek bir kaydı alır ve iki okuma birbirini etkilemez. Okumak tek başına hiçbir şeyi ilerletmez. Yavaş okuyucu o2’yi okur, commit etmeden durur ve yeniden başladığında o2’yi tekrar alır. audit en son katılır ve yine de o1’den başlar. Hızlı okuyucunun ikinci okuması boş döner, çünkü commit edilmiş offset’i zaten sondadır. seek(1) sonrasında o2, o3 ve o4’ü yeniden okur ve log’da hâlâ dört kayıt durur.

İlerleme sorusunun yanıtı sınıfların alanlarında görülür. WorkQueue her mesajı takip ettiği için inFlight map’ine ihtiyaç duyar. Log ise okuyucu başına yalnızca tek bir sayı saklar.

Demo semantiği modeller ve bir broker’ın yaptığı diğer her şeyi dışarıda bırakır. Ağ, visibility timeout, partition ya da consumer group yoktur. Nack edilen mesajı kuyruğun sonuna koymak da bir sadeleştirmedir, çünkü yeniden teslim edilen mesajın nereye düşeceği broker’a göre değişir. Her yeni okuyucuyu ilk kayıttan başlatmak da bir sadeleştirmedir; bir broker’ın varsayılan olarak ne yaptığını stream bölümü anlatır. Aynı bölüm, bir Kafka consumer’ının commit edilmiş offset’in önünde tuttuğu bellek içi konumu da anlatır; demo bunu dışarıda bırakır. Sonraki bölümler bu ayrıntıları broker’ların kendi dokümantasyonundan ekler.

Queue ve Competing Consumers#

Kuyruk, bir restoran mutfağındaki sipariş fişi rayına benzer: fişi bir aşçı alır ve o siparişi başka hiçbir aşçı hazırlamaz. Enterprise Integration Patterns bunu Point-to-Point Channel (yeni sekmede açılır) olarak adlandırır. Bu kanal, belirli bir mesajı yalnızca tek bir alıcının almasını garanti eder: “ensures that only one receiver will receive a particular message”. Alıcı eklemek bu garantiyi değiştirmez. Competing Consumers (yeni sekmede açılır) deseni ölçeklenmek için bundan yararlanır ve aynı kanala birden fazla consumer koymayı önerir: “Create multiple Competing Consumers on a single channel so that the consumers can process multiple messages concurrently.”

Broker bunu her mesajı takip ederek sağlar. Amazon SQS açık bir örnektir. Visibility timeout dokümantasyonuna (yeni sekmede açılır) göre alınan mesaj kuyrukta kalır ama diğer consumer’lara geçici olarak görünmez olur: “remains in the queue but becomes temporarily invisible to other consumers”. Consumer mesajı işledikten sonra silmek zorundadır. Süre dolmadan silmezse mesaj yeniden görünür olur ve başka bir consumer onu alabilir: “the message becomes visible again in the queue and can be retrieved by another consumer.” Varsayılan süre 30 saniyedir. Demoda bu takibi inFlight map’i yapar; timeout ise yoktur.

Bu mekanizmanın üç sonucu vardır. Birincisi, bir mesaj birden fazla kez teslim edilebilir; bu yüzden handler’lar iki kez çalışsa bile güvenli olmalıdır. Bunun nasıl yapılacağını idempotency rehberi anlatır. İkincisi, her seferinde hata veren bir mesaj, bir şey onu kaldırana kadar geri gelmeye devam eder. Bu iş dead-letter queue ile çözülür.

Üçüncüsü, mesajların sırası korunmaz. Microsoft’un Competing Consumers deseni (yeni sekmede açılır), consumer’ların mesajları alma sırası için “isn’t guaranteed” der; yani bu sıra garanti edilmez. Yeniden teslimat da mesajların yerini değiştirir. SQS metrik sayfası (yeni sekmede açılır) standard kuyruklar için bir durumu tarif eder. Üç ya da daha fazla kez alınıp silinmeyen mesaj kuyruğun sonuna taşınır. Sıralı kuyruk türleri sırayı anahtar başına geri getirir. Bir SQS FIFO kuyruğunda aynı mesaj grubundaki (yeni sekmede açılır) mesajlar her zaman tek tek ve kesin sırayla işlenir: “are always processed one at a time, in strict order”. Farklı gruplardaki mesajlar ise aynı anda işlenebilir. Bu mekanizmanın throughput sınırlarını Kafka geçiş yazısı ele alır.

Pub/Sub ve Aboneliğin Kalıcılığı#

Pub/sub, kopyayı kimin aldığı sorusunu yanıtlar. Publish-Subscribe Channel (yeni sekmede açılır) bir event’in kopyasını her alıcıya teslim eder: “delivers a copy of a particular event to each receiver”. Aynı sayfa yapıyı da tarif eder; tek bir giriş kanalı, abone başına bir çıkış kanalına ayrılır: “It has one input channel that splits into multiple output channels, one for each subscriber.” Bir e-posta listesi de böyle çalışır: her üye her mesajı alır, yeni katılan üye ise önceki mesajları almaz.

Microsoft’un Competing Consumers deseni (yeni sekmede açılır) kuyrukla arasındaki farkı iki cümleyle verir: “In the Competing Consumers pattern, one consumer receives each message for processing. In the Publisher-Subscriber pattern, all consumers receive every message.” İlkinde her mesajı tek bir consumer alır, ikincisinde bütün consumer’lar her mesajı alır.

Bu desen, düz kuyruklarla yapılan fan-out işi gönderene yüklediği için vardır. Microsoft’un Publisher-Subscriber deseni (yeni sekmede açılır) o durumu şöyle tarif eder: “To support multiple consumers, the sender must create a separate queue for each consumer”. Gönderen her consumer için ayrı bir kuyruk oluşturmak zorunda kalır. Pub/sub bu kopyalamayı broker’a taşır. Gönderen bir kez yayınlar ve kimin abone olduğunu bilmez.

Bir abone çevrimdışıyken ne olduğu ayrı bir konudur ve kaynaklar bunu farklı anlatır. Aynı Microsoft sayfası, alıcılar çevrimdışıyken broker’ın mesajları saklamasını bir fayda olarak sayar: “the broker retains messages even if one or more receivers are offline.” Enterprise Integration Patterns ise bu davranışı ayrı bir desen olarak ele alır. Durable Subscriber (yeni sekmede açılır) deseninin çözümü, abone bağlı değilken yayınlanan mesajları mesajlaşma sistemine saklatmaktır: “make the messaging system save messages published while the subscriber is disconnected.” Amazon SNS, abone için kalıcı bir depo olmadığında ne olduğunu gösterir. Teslimat yeniden deneme dokümantasyonuna (yeni sekmede açılır) göre SNS, yeniden deneme politikası tükendiğinde denemeyi bırakır ve mesajı atar: “stops retrying the delivery and discards the message”. Bunun istisnası, dead-letter queue bağlanmış bir aboneliktir.

Kalıcılık her aboneliğin bir özelliği olarak görüldüğünde iki anlatım birbiriyle uyuşur. Arkasında kuyruk olan bir abonelik, çevrimdışı consumer için mesajları tutar; düz bir push aboneliği ise yalnızca sınırlı bir süre yeniden dener. AWS’deki yaygın fan-out kurulumunun her SNS aboneliğinin arkasına bir SQS kuyruğu koymasının nedeni budur. SNS fan-out dokümantasyonuna (yeni sekmede açılır) göre mesajlar o zaman kuyrukta kalır ve sonradan işlenebilir: “persist in an Amazon SQS queue for other applications to process later.” Bu kurulumu hesaplar arası SNS-SQS fan-out yazısı ayrıntılı ele alır. İzole consumer hesaplarına fan-out yazısı da her consumer’a kendi kuyruğunu verir; orada fan-out’u EventBridge yapar.

Kalıcılık yeni bir aboneye geçmişi vermez. Google Pub/Sub’ın abonelik dokümantasyonu (yeni sekmede açılır) bunu şöyle ifade eder: “Only messages published to the topic after the subscription is created are available to subscriber clients.” Aboneye yalnızca abonelik oluşturulduktan sonra yayınlanan mesajlar ulaşır. Demo çıktısındaki analytics satırı budur. Aynı sayfa, mesajların varsayılan olarak sıralama garantisi taşımadığını da belirtir. Abonelikte message ordering açıldığında ise aynı ordering key’i taşıyan mesajlar Pub/Sub’ın aldığı sırayla teslim edilir.

Pub/sub, competing consumers ile de birleşir. Google Pub/Sub dokümantasyonu (yeni sekmede açılır) iki seviyeyi birlikte anlatır. Abonelikler arasında her abonelik bir kopya alır: “Each subscription receives a copy”. Birden fazla uygulamanın bağlandığı tek bir abonelikte ise her uygulama mesajların bir alt kümesini alır: “Each of the subscriber applications gets a subset of the published messages”. Demodaki Topic aynı yapıdadır, çünkü her abonenin çıktısı birkaç worker’ın paylaşabileceği bir WorkQueue’dur.

Append-Only Log Olarak Stream#

Buradaki “stream” kelimesi bir depolama biçimini adlandırır: yalnızca sonuna ekleme yapılan bir kayıt dizisi, yani append-only log. RabbitMQ’nun streams dokümantasyonu (yeni sekmede açılır) kısa bir tanım verir. Stream’ler, süresi dolana kadar tekrar tekrar okunabilen mesajlardan oluşan bir log’u modeller: “model an append-only log of messages that can be repeatedly read until they expire”. Ortak bir kayıt defteri iyi bir benzetmedir: girişler yalnızca sona eklenir ve her okuyucu kendi ayracını tutar.

Okumak hiçbir şeyi silmez. Kafka’nın giriş sayfası (yeni sekmede açılır), bir topic’teki event’lerin gerektiği kadar okunabildiğini (“can be read as often as needed”) ve tüketildikten sonra silinmediğini (“events are not deleted after consumption”) söyler. Ne kadar kalacakları topic başına bir ayardır: “a per-topic configuration setting”. Demoda çıktının son satırı, bütün okumalardan sonra log’da hâlâ dört kayıt olduğunu gösterir.

Bir log genellikle partition’lara bölünür ve sıra yalnızca tek bir partition içinde geçerlidir. Kafka’nın giriş sayfası bunu şöyle ifade eder: “any consumer of a given topic-partition will always read that partition’s events in exactly the same order as they were written.” Bir partition’ı okuyan her consumer, event’leri yazıldıkları sırayla görür. Aynı anahtara sahip event’ler aynı partition’a gider; bu yüzden sıra anahtar başına korunur. Partition’lar arasında bir sıra yoktur.

İlerleme, okuyucunun ilerlettiği bir konumdur. Confluent’in consumer tasarım sayfası (yeni sekmede açılır) bunu şöyle anlatır: “As the consumer makes progress, it commits the offsets of messages it has successfully processed”. Consumer ilerledikçe başarıyla işlediği mesajların offset’lerini commit eder. Kafka commit edilen her offset’i grup ve partition başına broker’da saklar; ne zaman ilerleyeceğine ise consumer karar verir. Aynı sayfaya göre consumer, veriyi yeniden tüketmek için bir offset de belirtebilir: “specify an offset to reconsume data if needed.” Bu ikinci yetenek replay’dir ve demoda seek(1) bunu yapar.

Okumak ve commit etmek ayrı adımlardır. Kafka’nın consumer dokümantasyonu (yeni sekmede açılır) iki konum tanımlar. Consumer’ın kendi konumu, consumer mesaj aldıkça kendiliğinden ilerler: “automatically advances every time the consumer receives messages”. Commit edilmiş konum ise güvenle saklanmış son offset’tir: “is the last offset that has been stored securely”. Bir hatadan sonra consumer bu offset’e döner: “this is the offset that the consumer will recover to”. İşledikten sonra commit eden bir consumer, ikisinin arasında durursa commit edilmemiş kayıtları yeniden okur. Demodaki yavaş okuyucu bunu o2 ile gösterir; bu yüzden log üzerindeki handler’lar da kuyruktakiler kadar idempotent olmalıdır.

Geç katılan bir okuyucu geçmişi kendiliğinden almaz. Aynı sayfaya göre bir grup ilk kez başlatıldığında consumer’lar genellikle her partition’da en eski ya da en yeni offset’ten okumaya başlar: “typically begin reading from either the earliest or latest offset in each partition”. Kafka’da bu seçimi auto.offset.reset (yeni sekmede açılır) ayarı yapar ve varsayılanı latest, yani log’un sonudur. Geçmişi okumak için yeni bir grubun bu ayarı earliest yapması ya da geriye seek etmesi gerekir.

Commit edilmiş offset’leri paylaşan okuyucular bir consumer group oluşturur ve ölçekleme sınırı bu gruptan gelir. Aynı sayfa şunu söyler: “Each partition is consumed by exactly one consumer within each consumer group at any given time.” Her partition’ı bir grup içinde aynı anda tek bir consumer okur. Dolayısıyla altı partition’lı bir topic, bir gruba en fazla altı çalışan consumer verir ve yedincisi throughput eklemez.

RabbitMQ iki biçimi tek bir broker içinde gösterir. Aynı streams sayfasına (yeni sekmede açılır) göre stream’ler yıkıcı olmayan okuma semantiğine sahiptir (“non-destructive consumer semantics”) ve consumer’ların log’un herhangi bir noktasından bağlanmasına izin verir (“attach at any point in the log”). Kuyruk türleri ise yıkıcı okur (“have destructive consume behaviour”); bu yüzden tüketilmiş mesajlar yeniden okunamaz: “it is not possible to re-read messages that have been consumed”.

Stream çoğu zaman gerçek zamanlı işlemeyle bir tutulur ve böylece iki ayrı şey birbirine karışır. Kafka’nın giriş sayfası event streaming’i hem saklamayı hem işlemeyi kapsayacak şekilde tanımlar: “storing these event streams durably for later retrieval” ve “processing, and reacting to the event streams in real-time as well as retrospectively.” Log, saklama kısmıdır. Stream processing ise onun üzerine isteğe bağlı eklenen bir katmandır.

Shard ve partition mekaniğini Kinesis yazısı ele alır.

Broker’ların Sunduğu Hibritler#

Üç yanıt birbirinden bağımsız olduğu için broker’lar onları üçten fazla şekilde birleştirir. Dört birleşim sık görülür.

BirleşimOkuma mesajı siler mi?Kopyayı kim alır?İlerlemeyi kim hatırlar?
Abone başına SQS kuyruğu olan SNS topic’iEvet, her kuyruk onaylanınca silerHer kuyruk; aynı kuyruktaki worker’lar yarışırBroker, mesaj başına
Google Pub/Sub aboneliğiVarsayılan olarak evet; saklama isteğe bağlıHer abonelik; aynı abonelikteki istemciler paylaşırBroker, her abonelikte mesaj başına
Kafka consumer groupHayırHer grup; grup içinde partition başına tek üyeHer consumer group, partition başına commit edilmiş tek offset; broker saklar
Kafka share groupHayırÜyeler partition’ları tek başına sahiplenmeden kayıtları paylaşırBroker, kayıt başına

Kafka, consumer group’ları tam da bu tür bir birleşim olarak tarif eder. 2.4 dokümantasyonundaki (yeni sekmede açılır) giriş sayfası, mesajlaşmanın geleneksel olarak iki modeli olduğunu söyler: “traditionally has two models: queuing and publish-subscribe”. Sayfa her birinin zayıf yanını da belirtir. Kuyruklar birden fazla aboneyi desteklemez (“aren’t multi-subscriber”). Pub/sub ise işlemeyi ölçekleyemez, çünkü her mesaj her aboneye gider: “has no way of scaling processing since every message goes to every subscriber”. Kafka’nın yanıtı bunun ardından gelir: “The consumer group concept in Kafka generalizes these two concepts”. Gruplar arasında Kafka pub/sub gibi davranır, grup içinde ise üyeler partition’ları aralarında bölüşür. Aynı metin sınırı da ekler: “there cannot be more consumer instances in a consumer group than partitions.”

Kafka share group’ları aynı log’un üzerine kuyruk davranışı koyar. Tasarım önerisi KIP-932 (yeni sekmede açılır), bir share group’taki consumer sayısının partition sayısını aşabileceğini söyler: “The number of consumers in a share group can exceed the number of partitions in a topic”. Kayıtlar da tek tek onaylanır: “Records are acknowledged on an individual basis”. Öneri, Kafka’ya başlı başına bir kuyruk kavramı eklemediğini de belirtir: “does not add the concept of a ‘queue’ to Kafka per se”. Bu, buradaki modelle uyumludur: kayıtlar log’da kalır; teslimat ve ilerleme takibi ise kayıt başına broker’a geçer.

Kafka 4.2 yükseltme notları (yeni sekmede açılır) özelliğin durumunu verir: “Queues for Kafka (KIP-932) is production-ready in Apache Kafka 4.2”. Bedeli sıralamadır. Confluent’in genel kullanılabilirlik duyurusu (yeni sekmede açılır) share group’ların esnek ölçekleme ve mesaj başına kontrol uğruna sıralamadan vazgeçtiğini söyler: “Share groups sacrifice ordering for elastic scaling and per-message control”. O duyurunun yayınlandığı sırada yalnızca Java istemcileri destekleniyordu ve exactly-once semantiği yol haritasındaydı. Java dışı bir istemciye ya da exactly-once semantiğine güvenmeden önce güncel durumu kontrol edin.

Google Pub/Sub, kuyruk benzeri abonelikleri olan bir pub/sub’dır ve replay isteğe bağlıdır. Replay dokümantasyonuna (yeni sekmede açılır) göre onaylanmış mesajları yeniden oynatmak için topic’te ya da abonelikte saklamanın ayarlanmış olması gerekir. Bundan sonra geçmiş bir zamana yapılan seek o mesajları yeniden teslim eder.

SQS’in önündeki SNS, çıktıları kuyruk olan bir pub/sub’dır. Her abone kalıcı bir backlog alır, ama abonenin consumer’ı sildiğinde mesaj o kuyruktan yok olur. Bunun diğer AWS servislerine göre ne zaman seçileceğini AWS mesajlaşma karşılaştırması ele alır.

Ürün kategorileri bu üç biçimle birebir örtüşmez. Microsoft’un Publisher-Subscriber sayfası Azure Event Hubs’ı pub/sub teknolojileri arasında sayar ve geleneksel pub/sub mesajlaşma yerine log tabanlı bir streaming modeli kullandığını ekler: “uses a log-based streaming model rather than traditional pub/sub messaging”. Bir ürün hakkında üç soruyu sormak, kategorisine bakmaktan daha güvenilirdir.

Yeni Bir Kanal için Biçim Seçimi#

Mesajın türü ilk yanıtı gösterir. Bir komut tek bir alıcıdan bir iş yapmasını ister; bu yüzden alıcının sahip olduğu bir kuyruğa uyar. Bir event bir şeyin olduğunu bildirir; bu yüzden yayıncının sahip olduğu pub/sub’a ya da log’a uyar. Bu ayrımı Event Odaklı Düşünmek açıklar, hangi kanalın kime ait olduğunu ise bounded context sınırındaki command ve event yazısı ele alır.

Akış şeması girişteki varsayılandan başlar ve onu geçersiz kılan durumları gösterir.

İş

Olgu

Evet

Hayır

Evet

Hacim bunu aşarsa

Hayır

Evet

Hayır

Bir mesaj için kanal gerekiyor

Tek bir worker'ın yapacağı iş mi, yoksa başkalarının tepki verdiği bir olgu mu?

Yarışan consumer'ları olan kuyruk

Varsayılan: abone başına kalıcı kuyruğu olan pub/sub

Bir consumer geçmişi okumak zorunda mı: replay, backfill ya da geç katılım?

Log: saklanan kayıtlar, consumer group başına bir offset

Anahtar başına sıra korunmalı mı?

Varsayılanın sıralı türü: FIFO kuyruklar ya da ordering key

Kaçan bir mesaj zararsız mı?

Kalıcı olmayan pub/sub push

Varsayılanın ödünleşimi ilk sisteme uygundur. Her abone kendi kuyruğuna worker ekleyerek ölçeklenir ve yavaş bir abone yalnızca kendi kuyruğunu doldurur. O abone kapalıyken mesajlar orada bekler. Karşılığında her abone için ayrı bir kuyruk ve ayrı alarmlar gerekir ve saklama ya da arşiv önceden açılmadıysa kimse geçmişi okuyamaz. AWS mesajlaşma karşılaştırması aynı eşleştirmeyi AWS terimleriyle, SQS’in önünde SNS olarak önerir.

Anahtar başına sıra tek başına log gerektirmez. FIFO kuyruk sırayı bir mesaj grubu içinde korur; ordering key de aynısını bir pub/sub aboneliği için yapar. Bedeli, sıranın başındaki mesajın arkasındakileri bekletmesidir. SQS metrik sayfasına (yeni sekmede açılır) göre hata veren bir mesaj, silinene ya da süresi dolana kadar kendi mesaj grubunu bloke eder: “A failed message blocks its message group until it’s deleted or expires.”

Log, şu ihtiyaçlardan biri ortaya çıktığında getirdiği ek işe değer:

  • Yeni bir consumer, kendisi var olmadan önceki event’leri okumak zorundadır.
  • Düzeltilen bir bug, daha önce işlenmiş kayıtlar üzerinde yeniden çalıştırılmalıdır.
  • Anahtar başına sıralı trafik, sıralı bir kuyruğun taşıyabileceğini aşar.
  • Çok sayıda consumer aynı yüksek hacimli akışı farklı hızlarda okur.

Bu sinyalleri Kafka geçiş yazısı ayrıntılı ele alır. Bunlardan biri baştan bilinen bir gereksinimse varsayılanı atlayıp log ile başlayın. Tersine, kaçan bir mesajın zararsız olduğu verilerde kalıcı olmayan push yeterlidir; canlı arayüz güncellemeleri ve cache invalidation buna örnektir.

Her Biçimin Bedeli#

Her biçimin kazandırdığı şey de karşılığında istediği şey de farklıdır.

BiçimKazandırdığıBedeliTipik hata
QueueDavranışı kolay öngörülür; consumer’lar serbestçe ölçeklenirOnaydan sonra geçmiş yoktur; yarışan consumer’larla sıra kaybolur; yinelenen teslimat mümkündürSürekli hata veren bir mesaj, DLQ yakalayana kadar dönüp durur
Abone başına kuyruğu olan pub/subProducer consumer’ları tanımaz; yavaş bir consumer yalnızca kendini geciktirirAbone başına bir kuyruk ve alarmları; saklama ya da arşiv olmadan replay yok; yeni aboneler şimdiden başlarİhtiyaç duyduğu event’lerden sonra oluşturulan abonelik
Kalıcı olmayan pub/subİşletilecek en az parçaAbone kapalıyken teslimat denemeleri tükenirse mesajlar kaybolurBir kesintiden sonra fark edilmeyen boşluklar
LogReplay, geç katılanlar, partition başına sıra, tek kopyayı okuyan çok sayıda okuyucuSaklama için depolama; partition sayısı klasik bir grubun paralelliğini sınırlar; offset’leri consumer yönetirTakılan bir kayıt, o grup için partition’ını bloke eder

Yayına Alındıktan Sonra Tutmayan Varsayımlar#

Bir broker’la yaşanan sürprizlerin çoğu, bir biçimin yanıtını başka bir biçimden beklemekten gelir. Aşağıdaki kalın satırların her biri yanlış çıkan bir varsayımdır; ardından onun yerine ne olduğu gelir.

Aynı kuyruğa bağlanan ikinci servis de her mesajı alır. İki servis yarışır ve her biri mesajların bir kısmını alır. Demonun queue bölümünde worker-A, o4’ü hiç görmez. İki servis de her mesaja ihtiyaç duyuyorsa her birine ayrı bir abonelik gerekir.

Kuyruk bir bug düzeltmesinden sonra replay yapabilir. Onaylanan mesajlar silinir, yani yeniden çalıştırılacak bir şey kalmaz. Geçmişin önemli olup olmadığına baştan karar verin. Önemliyse bir log seçin ya da bilerek bir arşiv ekleyin.

Yeni abone bütün geçmişle başlar. Abone, aboneliğinin oluştuğu andan başlar; analytics de öyle başladı. Abonelikleri producer’lar başlamadan önce oluşturun. Backfill bir gereksinimse log seçin ve yeni grubu en eski offset’ten başlatın.

Daha fazla consumer backlog’u her zaman daha hızlı eritir. Klasik bir consumer group, partition sayısına ulaştıktan sonra throughput kazanmaz. Partition sayısını beklediğiniz paralelliğe göre belirleyin ya da sıra önemli değilse share group’lara bakın.

Kuyruk mesajları sıralı tutar. Yarışan worker’lar da yeniden teslimat da sırayı değiştirir; o2 yeniden teslimat durumunu gösterdi. Yeniden sıralanmaya dayanıklı handler’lar yazın ya da varlık başına sıranın önemli olduğu yerde grup anahtarı kullanın.

Log her iş yükü için güvenli seçimdir. Bir arka plan iş kuyruğunun çoğu zaman geçmişe, sıraya ya da ikinci bir okuyucuya ihtiyacı yoktur. Log üzerinde yine de partition planlamasını, offset yönetimini ve consumer lag’i devralır. Bu iş için kuyruk daha basit araçtır.

Her Biçim için Backlog Sinyalleri#

Bir kuyruk, mesajlar fazla uzun beklediğinde geride kalır. Bu yüzden iki sinyali vardır: en eski mesajın yaşı ve bekleyen mesaj sayısı. SQS bunları ApproximateAgeOfOldestMessage ve ApproximateNumberOfMessagesVisible olarak yayınlar, işlenmekte olan mesajları ise ApproximateNumberOfMessagesNotVisible ile sayar (SQS metrikleri (yeni sekmede açılır)). Aynı sayfaya göre tekrar tekrar alınıp hiç silinmeyen mesajlar yaş metriğine dahil edilmez; bu yüzden DLQ’ya düşen mesajlar için ayrı bir alarm gerekir. Pub/sub aynı iki sinyale abonelik başına ihtiyaç duyar, çünkü tek bir abone çok gerideyken topic seviyesindeki bir sayı sağlıklı görünebilir. Abone başına kuyruk varsa kuyruk metrikleri bu görünümü zaten verir.

Klasik bir consumer group’un okuduğu log’da sayılacak mesaj başına bir durum yoktur. Sinyali consumer lag’dir: bir grubun offset’inin her partition’daki en yeni kaydın ne kadar gerisinde olduğu. Kinesis aynı fikri süre olarak, iterator age ile raporlar; Kinesis yazısı consumer’lar geride kaldığında bu değerin yükseldiğini gösterir. Biçim ne olursa olsun yeniden teslimatları, DLQ’ya düşen mesajları ve idempotency kontrolünün yakaladığı yinelenen mesajları da saymaya değer.

Varsayılanın Geçerli Olduğu Yer#

Varsayılan, iş için kuyruk ve abone başına kuyruğa fan-out’tur. Consumer’lar yalnızca bundan sonraki mesajlara ihtiyaç duyduğu sürece geçerlidir. Anahtar başına sıranın önemli olduğu yerde aynı biçimin sıralı türünü kullanın. Bir consumer geçmişi okumak ya da bir düzeltmeden sonra replay yapmak zorundaysa, ya da sıralı trafik sıralı bir kuyruğu aşıyorsa o akışı bir log’a taşıyın. Kalıcı olmayan push’u yalnızca verideki bir boşluğun zararsız olduğu yerde kullanın. Ekleyeceğiniz bir sonraki kanal için önce broker’ın üç yanıtını yazın: okuma mesajı siler mi, kopyayı kim alır, ilerlemeyi kim hatırlar.

Kaynaklar#

İlgili yazılar

Bounded Context Sınırında Command mı Event mi: Mesajın Sahibi Kim

Bounded context sınırını hangi mesajın geçeceğine karar verin: command şemasının sahibi alıcı, event şemasının sahibi yayıncıdır. Varsayılan integration event.

domain-driven-design · event-driven · messaging +4

Event Odaklı Düşünmek: Yeni Başlayanlar için Komut ve Event

Event odaklı sistemlerin arkasındaki zihinsel değişimi öğrenin: komut vermek yerine olguları duyurmak. İsimlendirme, ayrıştırma, nihai tutarlılık ve idempotency.

event-driven · messaging · idempotency +2

wasmCloud ve NATS: Event Bus'ı Taşınabilir Kılmak

Bir keşif tezi: event-driven sistemlerde vendor lock-in runtime'da değil bus topolojisinde yaşar; wasmCloud ve NATS bus'ı taşınabilir kılıyor.

webassembly · messaging · event-driven +3

Optimistic UI vs Decoupled Akış: Async Backend'ler için UX Desenleri

Async backend'le çalışan tasarımcılar için pragmatik rehber: üç etkileşim şekli, hangisi ne zaman, ve karşı durmanız gereken dört anti-pattern.

event-driven · state-management · design-patterns +2

Transactional Outbox Pattern: Dağıtık Sistemlerde Güvenilir Event Publishing

Transactional Outbox Pattern'in dağıtık sistemlerdeki dual-write problemini nasıl çözdüğünü, PostgreSQL, DynamoDB ve CDC araçlarıyla pratik implementasyonlarını öğren.

distributed-systems · microservices · event-driven +5