Kafka vs SQS vs EventBridge: Hangisini Seçmeli?

Olay güdümlü sistemlerde doğru aracı seçmek hype’tan çok trade-off’ları anlamakla ilgili. Bu yazıda mesaj kalıplarından başlayıp AWS, Azure ve GCP eşleniklerine, DLQ stratejilerine ve edge deployment’a geçiyoruz.

Mesaj Kalıpları: Temel

Her pattern farklı araçlar ve trade-off’lar getirir:

1’e 1 (Kuyruk Kalıbı)

• Mesaj tek consumer tarafından tüketilir (FIFO ile tam olarak bir kez)
• Kullanım: Task işleme, iş dağıtımı, async job’lar
• Araçlar: SQS, Azure Service Bus Queues, Cloud Tasks

1’e Çok (Topic/Fan-out Kalıbı)

• Mesaj birden fazla subscriber’a iletilir; her biri kendi kopyasını alır
• Kullanım: Event yayınlama, bildirimler, audit log
• Araçlar: SNS, Azure Service Bus Topics, Cloud Pub/Sub

Çok’a Çok (Event Mesh)

• Birden fazla producer/consumer arası karmaşık routing, filtreleme
• Kullanım: Microservices iletişimi, domain event’leri
• Araçlar: EventBridge, Azure Event Grid, Eventarc

Tam Araç Manzarası

Basit Kuyruk Servisleri

AWS SQS (Simple Queue Service)

Neyde öne çıkıyor: Çok basit kuyruk operasyonları, serverless entegrasyon, otomatik ölçekleme

Çalışan gerçek production config:

// Uygun error handling ve DLQ ile SQS
const params = {
  QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123/my-queue',
  ReceiveMessageWaitTimeSeconds: 20,  // Long polling
  MaxNumberOfMessages: 10,
  VisibilityTimeout: 30,  // İşleme penceresi
  MessageAttributeNames: ['All']
};

// DLQ konfigürasyonu
const dlqParams = {
  QueueName: 'my-queue-dlq',
  Attributes: {
    MessageRetentionPeriod: '1209600',  // 14 gün
    RedrivePolicy: JSON.stringify({
      deadLetterTargetArn: dlqArn,
      maxReceiveCount: 3  // DLQ'ya gitmeden önce 3 kez dene
    })
  }
};

Teslimat garantileri:

• Standard Queue: En az bir kez (olası duplikasyonlar)
• FIFO Queue: Tam olarak bir kez işleme
• Mesaj sıralaması: Sadece FIFO
• Max mesaj boyutu: 1MB (Ağustos 2025’te 256KB’den yükseltildi)

Not: Mesaj boyutu limitindeki bu 4x artış, daha büyük veri alışverişi gerektiren AI, IoT ve karmaşık uygulama entegrasyon workload’ları için faydalıdır. AWS Lambda’nın event source mapping’i de yeni 1MB payload’ları destekleyecek şekilde güncellendi.

SQS ne zaman parlıyor:

• Microservices’i decouple etme
• Batch job işleme
• Serverless mimariler (Lambda trigger’ları)
• Basit task kuyrukları

Azure Service Bus Queues

Enterprise özellikleriyle SQS’in Azure eşleniği:

// Session'lar ve DLQ handling ile Service Bus
var client = new ServiceBusClient(connectionString);
var processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions
{
    MaxConcurrentCalls = 10,
    AutoCompleteMessages = false,
    MaxAutoLockRenewalDuration = TimeSpan.FromMinutes(5),
    SubQueue = SubQueue.DeadLetter  // DLQ'ya erişim
});

// Duplikasyon algılamalı mesaj
var message = new ServiceBusMessage(body)
{
    MessageId = Guid.NewGuid().ToString(),  // Deduplication için
    SessionId = sessionId,  // Sıralı işleme için
    TimeToLive = TimeSpan.FromMinutes(5)
};

SQS’ten temel farklar:

• Sıralı işleme için built-in session’lar
• Duplikasyon algılama (yapılandırılabilir pencere)
• Zamanlanmış mesajlar
• Mesaj boyutu: 256KB (standard), 100MB (premium)

Google Cloud Tasks

HTTP target entegrasyonlu GCP task kuyruğu:

import { CloudTasksClient } from '@google-cloud/tasks';

const client = new CloudTasksClient();
const parent = client.queuePath(project, location, queue);

const task = {
    httpRequest: {
        httpMethod: 'POST',
        url: 'https://example.com/process',
        headers: { 'Content-Type': 'application/json' },
        body: Buffer.from(JSON.stringify(payload))
    },
    scheduleTime: { seconds: Math.floor(timestamp / 1000) }
};

const response = await client.createTask({ parent, task });

Pub/Sub Sistemleri

AWS SNS (Simple Notification Service)

1’e çok mesaj dağıtımı:

// Akıllı routing için filter policy'li SNS
const publishParams = {
  TopicArn: 'arn:aws:sns:us-east-1:123:my-topic',
  Message: JSON.stringify(event),
  MessageAttributes: {
    eventType: { DataType: 'String', StringValue: 'ORDER_CREATED' },
    priority: { DataType: 'Number', StringValue: '1' }
  }
};

// Filter'lı subscription
const subscriptionPolicy = {
  eventType: ['ORDER_CREATED', 'ORDER_UPDATED'],
  priority: [{ numeric: ['>', 0] }]
};

SNS + SQS Pattern (Fanout):

Teslimat garantileri:

• En az bir kez teslimat
• Mesaj sıralaması yok
• Exponential backoff ile retry
• Başarısız teslimatlar için DLQ desteği

Azure Service Bus Topics

SNS’ten daha sofistike:

// Birden fazla subscription ve filter'lı topic
var adminClient = new ServiceBusAdministrationClient(connectionString);

await adminClient.CreateSubscriptionAsync(
    new CreateSubscriptionOptions(topicName, subscriptionName),
    new CreateRuleOptions("OrderFilter",
        new SqlRuleFilter("EventType = 'OrderCreated' AND Priority > 5"))
);

Gelişmiş özellikler:

• SQL benzeri filtre kuralları
• Sıralama için mesaj session’ları
• Duplikasyon algılama
• Sebep takipli dead-lettering

Google Cloud Pub/Sub

Global mesaj dağıtımı:

import { PubSub } from '@google-cloud/pubsub';

const pubsub = new PubSub();
const topic = pubsub.topic(topicId);

// Ordering key ile yayınlama
const messageId = await topic.publishMessage({
    data: Buffer.from(data),
    orderingKey: 'user-123',
    attributes: {
        event_type: 'user_updated',
        version: '2'
    }
});

Event Routing Servisleri

AWS EventBridge

Kural tabanlı event routing:

// İçerik tabanlı routing ile EventBridge
const rule = {
  Name: 'OrderProcessingRule',
  EventPattern: JSON.stringify({
    source: ['order.service'],
    'detail-type': ['Order Created'],
    detail: {
      amount: [{ numeric: ['>', 100] }],
      country: ['US', 'UK', 'DE']
    }
  }),
  Targets: [
    {
      Arn: lambdaArn,
      RetryPolicy: {
        MaximumRetryAttempts: 2,
        MaximumEventAge: 3600
      },
      DeadLetterConfig: {
        Arn: dlqArn
      }
    }
  ]
};

Hesaplar arası event paylaşımı:

// EventBridge event bus paylaşımı
const eventBusPolicy = {
  StatementId: 'AllowAccountAccess',
  Action: 'events:PutEvents',
  Principal: '987654321098',  // Hedef hesap
  Condition: {
    StringEquals: {
      'events:detail-type': 'Order Created'
    }
  }
};

Azure Event Grid

Güçlü filtreleme ile Azure eşleniği:

{
  "filter": {
    "includedEventTypes": ["Microsoft.Storage.BlobCreated"],
    "subjectBeginsWith": "/blobServices/default/containers/images/",
    "advancedFilters": [
      {
        "operatorType": "NumberGreaterThan",
        "key": "data.contentLength",
        "value": 1048576
      }
    ]
  }
}

Google Cloud Eventarc

GCP’nin birleşik eventing’i:

# Eventarc trigger konfigürasyonu
apiVersion: eventarc.cnrm.cloud.google.com/v1beta1
kind: EventarcTrigger
metadata:
  name: storage-trigger
spec:
  location: us-central1
  matchingCriteria:
  - attribute: type
    value: google.cloud.storage.object.v1.finalized
  - attribute: bucket
    value: my-bucket
  destination:
    cloudRunService:
      name: process-image
      region: us-central1

Stream Processing Platformları

Apache Kafka

Event streaming’in ağır siklet şampiyonu:

// Gerçek zamanlı işleme için Kafka Streams
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "order-processor");
props.put(StreamsConfig.PROCESSING_GUARANTEE_CONFIG, "exactly_once_v2");
props.put(StreamsConfig.REPLICATION_FACTOR_CONFIG, 3);

KStream<String, Order> orders = builder.stream("orders");
KTable<String, Long> orderCounts = orders
    .filter((k, v) -> v.getAmount() > 100)
    .groupByKey()
    .count(Materialized.as("order-counts-store"));

// Kafka Streams ile DLQ handling
orders.foreach((key, value) -> {
    try {
        processOrder(value);
    } catch (Exception e) {
        producer.send(new ProducerRecord<>("orders-dlq", key, value));
    }
});

Kafka teslimat semantiği:

• En fazla bir kez: Gönder ve unut (acks=0)
• En az bir kez: Varsayılan (acks=1 veya all)
• Tam olarak bir kez: Transaction’larla (enable.idempotence=true)

Cloud Streaming Eşlenikleri

AWS Kinesis Data Streams

// İşleme için KCL ile Kinesis
const kinesisClient = new AWS.Kinesis();

// Düşük latency için enhanced fan-out
const consumer = await kinesisClient.registerStreamConsumer({
  StreamARN: streamArn,
  ConsumerName: 'low-latency-consumer'
}).promise();

// SQL işleme için Kinesis Data Analytics
const sqlQuery = `
CREATE STREAM orders_above_100 AS
SELECT * FROM SOURCE_SQL_STREAM_001
WHERE orderAmount > 100;
`;

Azure Event Hubs

// Kafka protokolü ile Event Hubs
var config = new ConsumerConfig
{
    BootstrapServers = "namespace.servicebus.windows.net:9093",
    SecurityProtocol = SecurityProtocol.SaslSsl,
    SaslMechanism = SaslMechanism.Plain,
    GroupId = "consumer-group"
};

// Uzun süreli depolama için Data Lake'e capture
var captureDescription = new CaptureDescription
{
    Enabled = true,
    IntervalInSeconds = 300,
    SizeLimitInBytes = 314572800,
    Destination = new Destination
    {
        StorageAccountResourceId = "/subscriptions/.../storageAccounts/...",
        BlobContainer = "capture"
    }
};

Google Cloud Dataflow

// Stream işleme için Dataflow
import { Pipeline } from '@google-cloud/dataflow';

const pipeline = new Pipeline(options);

pipeline
    .readFromPubSub({ topic })
    .window({ type: 'fixed', duration: 60 })
    .map((data: string) => JSON.parse(data))
    .filter((item: any) => item.amount > 100)
    .writeToBigQuery({ tableSpec });

Dead Letter Queue (DLQ) Esasları

DLQ’lar production dayanıklılığı için kritiktir. Retry’lardan sonra başarıyla işlenemeyen mesajları ele alır.

Temel DLQ kavramları:

• Başarısız mesajlar için güvenlik ağı
• Poison pill senaryolarını önler
• Hata analizi ve kurtarmayı mümkün kılar
• Kuyruk derinliğinin ötesinde temel monitoring

Basit DLQ pattern’i:

// Basit DLQ implementasyonu
const dlqParams = {
  QueueName: 'my-queue-dlq',
  Attributes: {
    MessageRetentionPeriod: '1209600',  // 14 gün
    RedrivePolicy: JSON.stringify({
      deadLetterTargetArn: dlqArn,
      maxReceiveCount: 3  // DLQ'ya gitmeden önce 3 kez dene
    })
  }
};

Derinlemesine İnceleme: Kapsamlı DLQ stratejileri, monitoring pattern’leri, circuit breaker’lar, ML tabanlı kurtarma ve production dersleri için detaylı rehberimize bakın: Dead Letter Queue Production Stratejileri

Edge ve Hybrid Deployment’lar

Edge Computing Değerlendirmeleri

Edge event sistemleri benzersiz kısıtlamalara sahip:

// Edge-optimize edilmiş event işleme
class EdgeEventProcessor {
  private localQueue: Queue[] = [];
  private cloudBuffer: Message[] = [];

  async processEvent(event: Event) {
    // Önce lokal işle
    const processed = await this.localProcess(event);

    // Cloud sync için batch'le
    if (this.shouldSyncToCloud(processed)) {
      this.cloudBuffer.push(processed);

      if (this.cloudBuffer.length >= 100 ||
          Date.now() - this.lastSync > 60000) {
        await this.syncToCloud();
      }
    }
  }

  private async syncToCloud() {
    try {
      // Sıkıştır ve batch gönder
      const compressed = this.compress(this.cloudBuffer);
      await this.cloudClient.sendBatch(compressed);
      this.cloudBuffer = [];
    } catch (error) {
      // Cloud ulaşılamazsa lokal sakla
      await this.localStorage.store(this.cloudBuffer);
    }
  }
}

Cloudflare Workers ile Kuyruklar

// Cloudflare Workers Queue Handler
export default {
  async queue(batch: MessageBatch, env: Env): Promise<void> {
    for (const message of batch.messages) {
      try {
        // Edge'de işle
        const result = await processMessage(message.body);

        // Durable Objects veya KV'de sakla
        await env.KV.put(
          `processed:${message.id}`,
          JSON.stringify(result),
          { expirationTtl: 3600 }
        );

        message.ack();
      } catch (error) {
        // Backoff ile retry
        message.retry({ delaySeconds: 30 });
      }
    }
  }
};

AWS IoT Core ile Edge Event’leri

// Greengrass ile AWS IoT Core
import { GreengrassCoreIPCClient } from 'aws-iot-device-sdk-v2';
import { PublishToTopicRequest, PublishMessage, BinaryMessage } from 'aws-iot-device-sdk-v2';

class EdgeIoTProcessor {
    private ipcClient: GreengrassCoreIPCClient;

    constructor() {
        this.ipcClient = new GreengrassCoreIPCClient();
    }

    async publishEdgeEvent(event: any): Promise<void> {
        // Lokal işleme
        const processed = this.processLocally(event);

        // IoT Core'a publish et
        const request: PublishToTopicRequest = {
            topic: `edge/${this.deviceId}/events`,
            publishMessage: {
                binaryMessage: {
                    message: Buffer.from(JSON.stringify(processed))
                }
            }
        };

        await this.ipcClient.publishToTopic(request);
    }
}

Cross-Cloud Eşlenikler

Servis Eşleme Tablosu

AWS	Azure	GCP	Kullanım Alanı
SQS	Service Bus Queues	Cloud Tasks	Basit kuyruk
SNS	Service Bus Topics	Cloud Pub/Sub	Pub/Sub mesajlaşma
EventBridge	Event Grid	Eventarc	Event routing
Kinesis	Event Hubs	Pub/Sub + Dataflow	Stream processing
Lambda + SQS	Functions + Service Bus	Cloud Run + Pub/Sub	Serverless event’ler
DynamoDB Streams	Cosmos DB Change Feed	Firestore Triggers	Database event’leri
Step Functions	Logic Apps	Workflows	Event orchestration
MSK (Kafka)	Event Hubs (Kafka mode)	Confluent Cloud	Kafka-uyumlu

Multi-Cloud Event Bridge Pattern

// Soyut multi-cloud event interface'i
interface CloudEventAdapter {
  publish(event: CloudEvent): Promise<void>;
  subscribe(handler: EventHandler): Promise<void>;
}

class MultiCloudEventBridge {
  private adapters: Map<string, CloudEventAdapter> = new Map();

  constructor() {
    this.adapters.set('aws', new AWSEventBridgeAdapter());
    this.adapters.set('azure', new AzureEventGridAdapter());
    this.adapters.set('gcp', new GCPEventarcAdapter());
  }

  async publishToAll(event: CloudEvent) {
    const promises = Array.from(this.adapters.values())
      .map(adapter => adapter.publish(event));

    const results = await Promise.allSettled(promises);

    // Kısmi başarısızlıkları ele al
    const failures = results.filter(r => r.status === 'rejected');
    if (failures.length > 0) {
      await this.handleFailures(failures, event);
    }
  }
}

Performance Karşılaştırma Matrisi

Araç	Throughput	Latency	Mesaj Boyutu	Sıralama	Teslimat Garantisi	DLQ Desteği
SQS Standard	3K/sec batch	10-100ms	1MB	Hayır	En az bir kez	Evet
SQS FIFO	300/sec	10-100ms	1MB	Evet	Tam olarak bir kez	Evet
SNS	100K/sec	100-500ms	256KB	Hayır	En az bir kez	Evet
Kafka	1M+/sec	<10ms	1MB default	Partition başına	Yapılandırılabilir	Manuel
RabbitMQ	50K/sec	1-5ms	128MB	Opsiyonel	En az bir kez	Evet
EventBridge	10K/sec	500ms-2s	256KB	Hayır	En az bir kez	Evet
Kinesis	1MB/sec/shard	200ms	1MB	Shard başına	En az bir kez	Manuel
Azure Service Bus	2K/sec	10-50ms	256KB/100MB	Evet	En az bir kez	Evet
Cloud Pub/Sub	100MB/sec	100ms	10MB	Key başına	En az bir kez	Evet

Karar Çerçevesi

Hızlı Karar Ağacı

Kullanım Senaryoları

• Basit Kuyruklar (SQS/Service Bus): Servisleri decouple etme, iş dağıtımı, serverless işleme
• Pub/Sub (SNS/Topics): Event yayınlama, fan-out, birden fazla consumer, bildirimler
• Event Router’lar (EventBridge/EventGrid): Karmaşık routing, multi-service orchestration, SaaS entegrasyonları
• Streaming (Kafka/Kinesis): Real-time analitik, event sourcing, yüksek throughput, event replay

Yaygın Tuzaklar ve Çözümler

Tuzak 1: Mesaj Boyut Limitleri

// Çözüm: Claim check pattern
class LargeMessageHandler {
  async send(largePayload: any) {
    if (JSON.stringify(largePayload).length > 256000) {
      // S3'e sakla
      const s3Key = await this.uploadToS3(largePayload);

      // Referans gönder
      return this.queue.send({
        type: 'large_message',
        s3Key,
        size: largePayload.length
      });
    }

    return this.queue.send(largePayload);
  }
}

Tuzak 2: Zehirli Mesajlar

// Çözüm: Zehirli mesaj algılama
class PoisonMessageDetector {
  private messageAttempts = new Map<string, number>();

  async process(message: Message) {
    const attempts = this.messageAttempts.get(message.id) || 0;

    if (attempts >= 3) {
      // Zehirli mesaj olarak tanımlandı
      await this.quarantine(message);
      return;
    }

    try {
      await this.processMessage(message);
      this.messageAttempts.delete(message.id);
    } catch (error) {
      this.messageAttempts.set(message.id, attempts + 1);

      if (this.isPoisonPattern(error)) {
        await this.quarantine(message);
      } else {
        throw error; // Retry
      }
    }
  }
}

Tuzak 3: Sıralama Garantileri

// Çözüm: Partition key stratejisi
class OrderedEventProcessor {
  async publishOrdered(events: Event[]) {
    // Entity ID'ye göre sıralama için grupla
    const grouped = this.groupBy(events, e => e.entityId);

    for (const [entityId, entityEvents] of grouped) {
      // Timestamp'e göre sırala
      entityEvents.sort((a, b) => a.timestamp - b.timestamp);

      // Aynı partition key ile gönder
      for (const event of entityEvents) {
        await this.kafka.send({
          topic: 'events',
          key: entityId,  // Sıralamayı garanti eder
          value: event
        });
      }
    }
  }
}

Monitoring ve Gözlemlenebilirlik

Takip Edilecek Temel Metrikler

// Kapsamlı metrik toplama
class EventMetrics {
  private metrics = {
    messagesPublished: new Counter('messages_published_total'),
    messagesConsumed: new Counter('messages_consumed_total'),
    messagesFailed: new Counter('messages_failed_total'),
    processingDuration: new Histogram('message_processing_duration_seconds'),
    queueDepth: new Gauge('queue_depth'),
    consumerLag: new Gauge('consumer_lag'),
    dlqDepth: new Gauge('dlq_depth')
  };

  async recordProcessing(message: Message, processor: Function) {
    const timer = this.metrics.processingDuration.startTimer();

    try {
      const result = await processor(message);
      this.metrics.messagesConsumed.inc();
      return result;
    } catch (error) {
      this.metrics.messagesFailed.inc({
        error_type: error.constructor.name,
        queue: message.source
      });
      throw error;
    } finally {
      timer();
    }
  }
}

Sonuç

Anahtar noktalar: mesaj kalıpları araç seçimini belirler; teslimat garantileri mimariyi etkiler; DLQ stratejileri production’ı oyuncak sistemlerden ayırır; cloud eşlenikleri çoğu pattern için mevcut; edge gereksinimleri özel değerlendirme ister. Basit başla, ölç ve gerçek gereksinimlere göre evrimleş. Failure için tasarla; en iyi mimari güvenilirlik ve gözlemlenebilirliği korurken ihtiyaçlarla birlikte evrimleşebilendir.

---

İlgili Derinlemesine İncelemeler:

• Dead Letter Queue Production Stratejileri - Kapsamlı DLQ kalıpları ve monitoring

Kaynaklar

• Apache Kafka Tanıtımı - Dağıtık olay akışı, topic’ler, partition’lar ve consumer group’larına ait temel kavramları içeren resmi Apache Kafka belgesi.
• Amazon SQS, Amazon SNS veya Amazon EventBridge? Karar Rehberi - Üç mesajlaşma servisi arasında kullanım senaryosuna göre seçim yapmak için AWS’nin resmi karşılaştırma kılavuzu.
• Amazon EventBridge Nedir? - Event bus’lar, kurallar, hedefler ve entegrasyon kalıplarını ele alan resmi EventBridge belgesi.
• Amazon Kinesis Data Streams: Giriş - Gerçek zamanlı veri akışı, shard’lar ve consumer uygulamaları hakkında resmi Kinesis belgesi.
• Olay Güdümlü Mimariler: Serverless Uygulamalar Lens - Güvenilir olay güdümlü serverless sistemler tasarlamaya yönelik AWS Well-Architected rehberi.
• Apache Kafka Tasarımı - Kafka’nın günlük tabanlı mimarisini, teslimat garantilerini ve partition sıralama modelini derinlemesine açıklayan belge.
• Amazon SQS FIFO Kuyrukları - Tam olarak bir kez işleme ve katı mesaj sıralaması garantilerini ele alan resmi SQS belgesi.