Kafka İzleme Neden Kritiktir?

Apache Kafka dayanıklı olacak şekilde tasarlanmıştır ancak esneklik otomatik değildir: aktif gözlemlenebilirlik gerektirir. Aşırı yüklenmiş bir aracı, üretime ayak uyduramayan bir tüketici grubu veya çoğaltma kalitesi düşük bir bölüm erken tespit edilmediği takdirde veri kaybına veya kesintiye neden olabilirler.

Kafka'da izlenmesi gereken üç temel boyut şunlardır:

  • Küme sağlığı: etkin aracılar, etkin denetleyici, az çoğaltılmış bölümler, çevrimdışı bölümler
  • Üretici performansı: istek oranı, kayıt hatası oranı, istek gecikmesi, toplu iş boyutu
  • Tüketici performansı: grup ve bölüm başına tüketici gecikmesi, taahhüt oranı, yeniden dengeleme sıklığı

En Kritik 5 Kafka Metriği

  • kafka.tüketici.lag: LEO ve taahhütlü dengeleme arasındaki fark — sistem sağlığı için 1 numaralı ölçüm
  • kafka.server.UnderReplicatedPartitions: eksik ISR'ye sahip bölümler — bozulmuş aracı sinyali
  • kafka.server.OfflinePartitionsCount: lidersiz bölümler — kritik hata, verilere erişilemiyor
  • kafka.network.RequestMetrics.TotalTimeMs: isteklerin toplam gecikmesi
  • kafka.server.BrokerTopicMetrics.MessagesInPerSec: alım verimi

Kafka Metrikleri Nasıl Ortaya Çıkarır: JMX

Kafka tüm iç ölçümlerini şu şekilde ortaya koyuyor: JMX (Java Yönetim Uzantıları)için standart çerçeve JVM uygulamalarının izlenmesi. Her metrik bir ile tanımlanır MBean adı formatta dominio:tipo=Tipo,nome=Metrica.

JMX metriklerini bulut tabanlı ortamda en çok kullanılan izleme sistemi olan Prometheus için erişilebilir kılmak, sen kullan JMX Dışa Aktarıcı: JMX ölçümlerini HTTP uç noktası olarak ortaya çıkaran bir Java aracısı Prometheus formatında (metin tabanlı, çekme modeli).

JMX Exporter'ı Java Aracısı olarak yapılandırma

JMX Exporter, JVM aracısı olarak başlatılır: parametreyi eklemeniz yeterlidir -javaagent Kafka komisyoncusu JVM'ye. JAR'ı resmi Prometheus deposundan indirir ve belirten bir YAML yapılandırma dosyası oluşturursunuz. Hangi MBean'lerin toplanacağı ve bunların Prometheus metriklerine göre nasıl yeniden adlandırılacağı. 

# Scaricare JMX Exporter (ultima versione stabile)
wget https://repo1.maven.org/maven2/io/prometheus/jmx/jmx_prometheus_javaagent/1.0.1/jmx_prometheus_javaagent-1.0.1.jar \
  -O /opt/kafka/libs/jmx_prometheus_javaagent.jar

# File di configurazione: /opt/kafka/config/kafka-jmx-exporter.yml
# Questo file dice a JMX Exporter quali MBean raccogliere
# kafka-jmx-exporter.yml
# Configurazione completa per Kafka broker + consumer group lag
---
startDelaySeconds: 0
ssl: false
lowercaseOutputName: true
lowercaseOutputLabelNames: true

rules:
  # Metriche Broker: throughput messaggi
  - pattern: 'kafka.server<type=BrokerTopicMetrics, name=MessagesInPerSec><>OneMinuteRate'
    name: kafka_server_brokertopicmetrics_messagesinpersec
    labels:
      topic: "$1"

  # Under-replicated partitions: CRITICO
  - pattern: 'kafka.server<type=ReplicaManager, name=UnderReplicatedPartitions><>Value'
    name: kafka_server_replicamanager_underreplicatedpartitions

  # Offline partitions: CRITICO
  - pattern: 'kafka.controller<type=KafkaController, name=OfflinePartitionsCount><>Value'
    name: kafka_controller_kafkacontroller_offlinepartitionscount

  # Active controller count (deve essere sempre 1)
  - pattern: 'kafka.controller<type=KafkaController, name=ActiveControllerCount><>Value'
    name: kafka_controller_kafkacontroller_activecontrollercount

  # Request latency per tipo di request
  - pattern: 'kafka.network<type=RequestMetrics, name=TotalTimeMs, request=(\w+)><>(Mean|99thPercentile)'
    name: kafka_network_requestmetrics_totaltimems
    labels:
      request: "$1"
      quantile: "$2"

  # Producer request rate
  - pattern: 'kafka.server<type=BrokerTopicMetrics, name=BytesInPerSec><>OneMinuteRate'
    name: kafka_server_brokertopicmetrics_bytesinpersec

  # Log size per topic-partizione
  - pattern: 'kafka.log<type=Log, name=Size, topic=(.+), partition=(\d+)><>Value'
    name: kafka_log_log_size
    labels:
      topic: "$1"
      partition: "$2"

  # JVM heap usage
  - pattern: 'java.lang<type=Memory><>HeapMemoryUsage'
    name: jvm_heap_memory_usage
    type: GAUGE

Aracıda JMX Aktarıcıyı Etkinleştir

# Modificare kafka-server-start.sh oppure impostare la variabile d'ambiente
# Aggiungere al file bin/kafka-server-start.sh o configurare systemd

# Opzione 1: variabile d'ambiente KAFKA_OPTS
export KAFKA_OPTS="-javaagent:/opt/kafka/libs/jmx_prometheus_javaagent.jar=9404:/opt/kafka/config/kafka-jmx-exporter.yml"

# Opzione 2: in systemd service file
# [Service]
# Environment="KAFKA_OPTS=-javaagent:/opt/kafka/libs/jmx_prometheus_javaagent.jar=9404:/opt/kafka/config/kafka-jmx-exporter.yml"

# Verificare che l'endpoint funzioni dopo il riavvio
curl http://localhost:9404/metrics | grep kafka_server_replicamanager

Tüketici Gecikmesi: En Önemli Ölçüt

Il tüketici gecikmesi Tüketicinin hâlâ kaç kayıt işlemesi gerektiğini ölçer: arasındaki farktır. the Günlük Sonu Uzaklığı (konuya yazılan son kayıt) ve Taahhüt Edilen Ofset (tüketici grubu tarafından işlenen son kayıt). Artan bir gecikme, tüketicilerin üretim hızına ayak uyduramadıklarını gösteriyor.

Gecikme tek başına komisyoncuların JMX ölçümlerini açığa çıkarmaz: tüketici grubu koordinatörü sorgulanarak toplanmalıdır. Bunun için standart araç Kafka Gecikme Aktarıcı (Lightbend/açık kaynak projesi) veya eklenti kafka_consumer_group Prometheus'un kendisi. 

# Docker Compose per Kafka Lag Exporter (alternativa moderna)
# https://github.com/seglo/kafka-lag-exporter

services:
  kafka-lag-exporter:
    image: seglo/kafka-lag-exporter:0.8.0
    ports:
      - "8000:8000"
    volumes:
      - ./lag-exporter.conf:/opt/docker/conf/application.conf
    environment:
      JAVA_OPTS: "-Xmx256m"
# lag-exporter.conf (formato HOCON)
kafka-lag-exporter {
  port = 8000

  clusters = [
    {
      name = "production-cluster"
      bootstrap-brokers = "kafka1:9092,kafka2:9092,kafka3:9092"

      # Polling interval
      poll-interval = 30 seconds

      # Consumer groups da monitorare (regex, vuoto = tutti)
      consumer-group-whitelist = [".*"]
    }
  ]

  # Metriche Prometheus esposte:
  # kafka_consumer_group_latest_offset
  # kafka_consumer_group_partition_lag
  # kafka_consumer_group_sum_lag  <-- lag totale per group
  # kafka_consumer_group_max_lag  <-- lag massimo tra le partizioni
}

PromQL ile Gecikmeyi Hesaplayın

# Query PromQL per Grafana / Prometheus

# Lag totale per consumer group
sum(kafka_consumer_group_partition_lag) by (group)

# Top 10 consumer groups per lag
topk(10, sum(kafka_consumer_group_partition_lag) by (group))

# Tasso di crescita del lag (se positivo, i consumer non stanno al passo)
rate(kafka_consumer_group_sum_lag[5m])

# Consumer lag per topic specifico
sum(kafka_consumer_group_partition_lag{topic="ordini-effettuati"}) by (group)

# Alert: lag sopra soglia critica per piu di 5 minuti
# kafka_consumer_group_sum_lag{group="servizio-inventario"} > 10000

Prometheus'u Kafka için Yapılandırma

Prometheus bir şablon kullanıyor çekmek: Uç noktalardan metrikleri toplayan Prometheus'tur yapılandırılabilir bir aralığa göre ihracatçılar tarafından maruz kalınmaktadır (scrape_interval). Yapılandırma şunları belirtir: hedefi kazımak: Sorgulanacak HTTP uç noktaları. 

# prometheus.yml - configurazione per scraping Kafka
global:
  scrape_interval: 15s
  evaluation_interval: 15s

rule_files:
  - "kafka-alerts.yml"

scrape_configs:
  # JMX Exporter su ogni broker Kafka
  - job_name: "kafka-brokers"
    static_configs:
      - targets:
          - "kafka1:9404"
          - "kafka2:9404"
          - "kafka3:9404"
    relabel_configs:
      - source_labels: [__address__]
        target_label: broker
        regex: "([^:]+):.*"
        replacement: "$1"

  # Kafka Lag Exporter per consumer group metrics
  - job_name: "kafka-lag-exporter"
    static_configs:
      - targets:
          - "kafka-lag-exporter:8000"
    scrape_interval: 30s  # lag cambia meno frequentemente

  # JVM metrics dei broker (se abilitato jvm_exporter separato)
  - job_name: "kafka-jvm"
    static_configs:
      - targets:
          - "kafka1:9404"
          - "kafka2:9404"
          - "kafka3:9404"
    metrics_path: /metrics
    params:
      module: [jvm]

Uyarı Kuralları Kafka: Temel Kurallar

Uyarı kuralları, bir bildirimi tetikleyen koşulları tanımlar. Prometheus'ta kendilerini ifade ediyorlar PromQL ile birlikte sunulur ve ayrı YAML dosyaları halinde paketlenir. İşte Kafka'nın üretimdeki temel kuralları: 

# kafka-alerts.yml - Regole di alert per Prometheus Alertmanager
groups:
  - name: kafka.critical
    rules:
      # Broker down: nessun dato dall'endpoint JMX
      - alert: KafkaBrokerDown
        expr: up{job="kafka-brokers"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Kafka broker {{ $labels.broker }} non raggiungibile"
          description: "Il broker {{ $labels.broker }} non risponde da piu di 1 minuto."

      # Partizioni offline: CRITICO, dati non accessibili
      - alert: KafkaOfflinePartitions
        expr: kafka_controller_kafkacontroller_offlinepartitionscount > 0
        for: 30s
        labels:
          severity: critical
        annotations:
          summary: "{{ $value }} partizioni offline in Kafka"
          description: "Partizioni senza leader: dati non leggibili/scrivibili."

      # Nessun active controller
      - alert: KafkaNoActiveController
        expr: sum(kafka_controller_kafkacontroller_activecontrollercount) != 1
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Kafka senza controller attivo"

  - name: kafka.warning
    rules:
      # Under-replicated partitions: replica degradata
      - alert: KafkaUnderReplicatedPartitions
        expr: kafka_server_replicamanager_underreplicatedpartitions > 0
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "{{ $value }} partizioni under-replicated su {{ $labels.broker }}"
          description: "Replica degradata: un broker potrebbe essere lento o down."

      # Consumer lag critico
      - alert: KafkaConsumerLagHigh
        expr: sum(kafka_consumer_group_partition_lag) by (group) > 50000
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Consumer lag alto per gruppo {{ $labels.group }}"
          description: "Lag: {{ $value }}. I consumer non stanno al passo con la produzione."

      # Consumer lag critico prolungato
      - alert: KafkaConsumerLagCritical
        expr: sum(kafka_consumer_group_partition_lag) by (group) > 200000
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Consumer lag CRITICO per gruppo {{ $labels.group }}"

      # JVM heap usage alta
      - alert: KafkaBrokerHeapHigh
        expr: jvm_heap_memory_usage{area="used"} / jvm_heap_memory_usage{area="max"} > 0.85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Heap JVM alta su broker Kafka {{ $labels.broker }}"

Kafka için Grafana Kontrol Paneli

Grafana, Prometheus için standart görselleştirme aracıdır. İçe aktarmaya hazır kontrol panelleri var doğrudan Grafana Kontrol Paneli Merkezinden (grafana.com/dashboards). Kafka için en çok kullanılanlar şunlardır:

  • Kontrol Paneli Kimliği 7589: Kafka'ya Genel Bakış (komisyoncu sağlığı, verim, bölümler)
  • Kontrol Paneli Kimliği 9021: Birleşik Platform Kafka Metrikleri
  • Kontrol Paneli Kimliği 13282: Kafka Tüketici Gecikmesi (ayrıntılı tüketici grubu gecikmesi)

Bir kontrol panelini Grafana'ya aktarmak için: Kontrol Panelleri → İçe aktar → kimliği girin → Prometheus veri kaynağını seçin.

Kontrol Panelinizde Bulunması Gereken Anahtar Paneller

# Pannello 1: Broker Health Overview
# Stat panel: up/down per ogni broker
up{job="kafka-brokers"}

# Pannello 2: Under-Replicated Partitions
# Stat panel con soglia colorata (verde=0, rosso>0)
sum(kafka_server_replicamanager_underreplicatedpartitions)

# Pannello 3: Consumer Lag per Group (time series)
sum(kafka_consumer_group_partition_lag) by (group)

# Pannello 4: Messages In/Out per secondo
rate(kafka_server_brokertopicmetrics_messagesinpersec[1m])

# Pannello 5: Request Latency p99 (heatmap o time series)
kafka_network_requestmetrics_totaltimems{quantile="99thPercentile"}

# Pannello 6: Disk Usage per Broker
# Utile per pianificare l'espansione storage
node_filesystem_size_bytes{mountpoint="/kafka-data"} -
node_filesystem_avail_bytes{mountpoint="/kafka-data"}

Docker Compose: Eksiksiz Yığın İzleme

Geliştirme veya hazırlama ortamları için bu Docker Compose tüm izleme yığınını başlatır: JMX Exporter (brokera entegre), Kafka Lag Exporter, Prometheus ve Grafana. 

# docker-compose.monitoring.yml
version: "3.9"

services:
  kafka:
    image: apache/kafka:4.0.0
    container_name: kafka
    ports:
      - "9092:9092"
      - "9404:9404"   # JMX Exporter
    volumes:
      - ./config/kafka-jmx-exporter.yml:/opt/kafka-jmx-exporter.yml
      - ./libs/jmx_prometheus_javaagent.jar:/opt/jmx_prometheus_javaagent.jar
    environment:
      KAFKA_NODE_ID: 1
      KAFKA_PROCESS_ROLES: "broker,controller"
      KAFKA_LISTENERS: "PLAINTEXT://kafka:9092,CONTROLLER://kafka:9093"
      KAFKA_ADVERTISED_LISTENERS: "PLAINTEXT://localhost:9092"
      KAFKA_CONTROLLER_LISTENER_NAMES: "CONTROLLER"
      KAFKA_CONTROLLER_QUORUM_VOTERS: "1@kafka:9093"
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: "CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT"
      CLUSTER_ID: "monitoring-demo-cluster"
      KAFKA_OPTS: "-javaagent:/opt/jmx_prometheus_javaagent.jar=9404:/opt/kafka-jmx-exporter.yml"

  kafka-lag-exporter:
    image: seglo/kafka-lag-exporter:0.8.0
    container_name: kafka-lag-exporter
    ports:
      - "8000:8000"
    volumes:
      - ./config/lag-exporter.conf:/opt/docker/conf/application.conf
    depends_on:
      - kafka

  prometheus:
    image: prom/prometheus:v2.50.1
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./config/prometheus.yml:/etc/prometheus/prometheus.yml
      - ./config/kafka-alerts.yml:/etc/prometheus/kafka-alerts.yml
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.retention.time=30d"

  grafana:
    image: grafana/grafana:10.3.1
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      GF_SECURITY_ADMIN_PASSWORD: "kafka-monitoring"
      GF_USERS_ALLOW_SIGN_UP: "false"
    volumes:
      - grafana-data:/var/lib/grafana
      - ./config/grafana-datasources.yml:/etc/grafana/provisioning/datasources/prometheus.yml
      - ./config/grafana-dashboards.yml:/etc/grafana/provisioning/dashboards/kafka.yml

volumes:
  grafana-data:

Java ile Tüketici Gecikmesi İzleme (Programatik)

Bazı durumlarda tüketici gecikmesini doğrudan uygulama kodunda ölçmek yararlı olabilir. örneğin bir Spring Boot uygulamasında Mikrometre/Aktüatör aracılığıyla metriği açığa çıkarmak için. Bu yaklaşım, dış izlemeyi tamamlayıcı niteliktedir ve daha kesin korelasyonlara izin verir. 

// ConsumerLagMonitor.java - Misura il lag programmaticamente con Kafka AdminClient
import org.apache.kafka.clients.admin.*;
import org.apache.kafka.clients.consumer.OffsetAndMetadata;
import org.apache.kafka.common.*;

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.*;

public class ConsumerLagMonitor {

    private final AdminClient adminClient;
    private final String groupId;

    public ConsumerLagMonitor(String bootstrapServers, String groupId) {
        Properties props = new Properties();
        props.put("bootstrap.servers", bootstrapServers);
        this.adminClient = AdminClient.create(props);
        this.groupId = groupId;
    }

    public Map<TopicPartition, Long> getLagPerPartition() throws ExecutionException, InterruptedException {
        // 1. Recupera committed offsets del consumer group
        ListConsumerGroupOffsetsResult offsetsResult =
            adminClient.listConsumerGroupOffsets(groupId);

        Map<TopicPartition, OffsetAndMetadata> committedOffsets =
            offsetsResult.partitionsToOffsetAndMetadata().get();

        // 2. Recupera l'end offset (Log End Offset) per le stesse partizioni
        Map<TopicPartition, OffsetSpec> latestOffsetRequest = committedOffsets.keySet().stream()
            .collect(Collectors.toMap(tp -> tp, tp -> OffsetSpec.latest()));

        ListOffsetsResult latestOffsets = adminClient.listOffsets(latestOffsetRequest);
        Map<TopicPartition, ListOffsetsResult.ListOffsetsResultInfo> endOffsets =
            latestOffsets.all().get();

        // 3. Calcola il lag = endOffset - committedOffset
        Map<TopicPartition, Long> lag = new HashMap<>();
        for (Map.Entry<TopicPartition, OffsetAndMetadata> entry : committedOffsets.entrySet()) {
            TopicPartition tp = entry.getKey();
            long committedOffset = entry.getValue().offset();
            long endOffset = endOffsets.get(tp).offset();
            lag.put(tp, Math.max(0, endOffset - committedOffset));
        }

        return lag;
    }

    public long getTotalLag() throws ExecutionException, InterruptedException {
        return getLagPerPartition().values().stream()
            .mapToLong(Long::longValue)
            .sum();
    }

    public void close() {
        adminClient.close();
    }
}

Kafka'yı İzlemek İçin En İyi Uygulamalar

Anti-Pattern: Her Gecikme Ani Çıkışında Uyarı

Tüketici gecikmesi doğal olarak dalgalanıyor: üretimde anlık bir zirve veya tüketici GC duraklaması hızla iyileşen geçici gecikmeye neden olurlar. Uyarıları mutlak eşik değerlerine göre yapılandırma bir zaman penceresi (for: 10m) sürekli yanlış pozitifler üretir. Uyarıyı tetiklemeden önce daima minimum bir süre (5-10 dakika) kullanın.

  • Mutlak değeri değil trendi izleyin: 100K'lık azalan gecikme daha az endişe vericidir büyüyen bir 5K gecikme. Amerika rate() Türevi görmek için PromQL'de.
  • Kontrol panellerini kişiye göre ayırın: SRE'ler için kritik uyarıları içeren operasyonel bir kontrol paneli, altyapı ekipleri için bir kapasite planlama panosu, ürün yöneticileri için bir iş KPI panosu.
  • JVM ölçümlerini dahil et: Kafka performans sorunlarının %30'u GC baskısından kaynaklanıyor komisyoncu hakkında. Her zaman izle jvm_gc_pause_seconds ve yığın kullanımı.
  • Prometheus'u en az 30 gün saklayın: trend analizi ve aylık kapasite planlaması için. Uzun süreli saklama için Thanos veya Mimir'i düşünün.
  • Uyarıları şununla test edin: amtool: Uyarı kurallarının sözdizimsel olarak doğru olduğunu doğrulayın doğru olduğunu ve üretime geçmeden önce beklenen test verileriyle tetiklendiklerini.

Bulutta Yönetilen Kafka: Confluent Cloud Metrics API

Confluent Cloud veya yönetilen bir Kafka hizmeti (AWS MSK, Aiven Kafka) kullanıyorsanız JMX ölçümleri doğrudan erişilebilir. Bu durumda şunu kullanırız: Metrik API'si bulut sağlayıcısının. Confluent Cloud, Remote_write aracılığıyla Prometheus uyumlu Metrics REST API'sini kullanıma sunar: 

# prometheus.yml per Confluent Cloud Metrics API
scrape_configs:
  - job_name: "confluent-cloud"
    honor_timestamps: true
    metrics_path: "/v2/metrics/cloud/export"
    scheme: https
    basic_auth:
      username: "<CONFLUENT_CLOUD_API_KEY>"
      password: "<CONFLUENT_CLOUD_API_SECRET>"
    static_configs:
      - targets:
          - "api.telemetry.confluent.cloud"
    params:
      resource.kafka.id:
        - "<CLUSTER_ID>"

# Per AWS MSK: usa il CloudWatch exporter
# https://github.com/prometheus/cloudwatch_exporter
scrape_configs:
  - job_name: "aws-msk"
    static_configs:
      - targets:
          - "cloudwatch-exporter:9106"

Özet: Kafka İzleme Kontrol Listesi

  • JMX Exporter tüm aracılarda yapılandırılmış, bağlantı noktası 9404
  • Kafka Lag Exporter veya tüketici grubu ölçümleri için eşdeğeri
  • Komisyoncu için 15 saniye, gecikme ihracatçısı için 30 saniye kazıma aralığına sahip Prometheus
  • Kritik uyarılar: komisyoncunun çalışmaması, çevrimdışı bölümler, etkin denetleyici yok
  • Uyarı uyarısı: az kopyalanmış bölümler, yüksek tüketici gecikmesi, yığın >%85
  • Grafana kontrol paneli içe aktarıldı (genel bakış için ID 7589, gecikme için ID 13282)
  • Saklama Prometheus minimum 30 gün
  • Yanlış pozitifleri önlemek için uyarılar minimum süreyle (5 dakika için) test edildi

Serideki Sonraki Adımlar

İzlemeyi yapılandırdınız. Bir sonraki adım, sorunlar ortaya çıktığında ne yapılacağını bilmektir:

  • Madde 10 – Teslim Edilmeyen Mektup Sırası ve Hataların Ele Alınması: mesajları yönetme kalıpları DLQ, üstel yeniden deneme ve zehirli hap tespiti de dahil olmak üzere işlenemeyenler.
  • Madde 11 – Üretimde Kafka: küme boyutlandırmaya ilişkin eksiksiz operasyonel kılavuz, saklama ve çoğaltma faktörlerinin optimum yapılandırması ve olağanüstü durum kurtarma için MirrorMaker 2.

Diğer Serilerle Bağlantı

  • Apache Kafka Temelleri (Madde 1): Tüketici gecikmesi kavramının anlaşılması gerekir LEO, HW ve taahhütlü ofset arasındaki fark serinin ilk makalesinde anlatılmıştı.
  • Olay Odaklı Mimari: Tüketici gecikmesinin izlenmesi de kritik öneme sahiptir AWS SQS ve SNS'ye sahip EDA sistemlerinde eşdeğer ölçüm kuyruk derinliğidir.