BlogKafka

Ereignisgesteuerte Architektur mit Kafka: Patterns, Design und Fehlerbilder

Scott Sternloff

Von Scott Sternloff, Senior Enterprise Architect

LinkedIn · Aktualisiert am · 7 Min. Lesezeit

Ereignisgesteuerte Architektur mit Kafka: Patterns, Design und Fehlerbilder
Auf dieser Seite

Eine ereignisgesteuerte Architektur mit Kafka nutzt Kafka-Topics als dauerhaftes Log zwischen Services: Producer veröffentlichen Fakten wie OrderPlaced, und beliebig viele Consumer Groups reagieren unabhängig voneinander in ihrem eigenen Tempo und können die Historie per Replay erneut verarbeiten. Kafka liefert Reihenfolge pro Partition, Retention und Replay. Was ein Event enthält, wie sich Schemas weiterentwickeln, wie sich Dual Writes vermeiden lassen und was mit einer dauerhaft fehlschlagenden Nachricht passiert, entscheidet Kafka nicht. Genau diese Entscheidungen behandelt dieser Leitfaden.

Zu den Broker-Interna darunter siehe Kafka-Architektur.

Drei Patterns, die alle „ereignisgesteuert“ heißen

Martin Fowlers Artikel von 2017 unterscheidet Patterns, die oft in einen Topf geworfen werden – und welches Sie umsetzen, bestimmt Topic-Design und Retention.

PatternInhalt des EventsBedeutung in Kafka
Event NotificationEin kleiner Fakt und eine ID: Bestellung 123 wurde aufgegebenConsumer rufen Details beim Quell-Service ab, dessen API-Last also mit jedem neuen Consumer steigt. Normale zeitbasierte Retention genügt.
Event-Carried State TransferDer Zustand, den Consumer benötigenConsumer halten eine lokale Kopie und rufen die Quelle nicht mehr auf. Ein Topic mit Compaction (cleanup.policy=compact) behält den jeweils neuesten Wert pro Key, sodass ein neuer Consumer diese Kopie neu aufbauen kann.
Event SourcingJede Zustandsänderung, als System of RecordEvents dürfen nie gelöscht werden: retention.ms=-1 auf einem Topic mit Delete-Policy, nicht Compaction, die ältere Events pro Key verwirft.

Die Standard-Retention von Kafka beträgt sieben Tage (log.retention.hours=168). Jedes Topic, aus dem Zustand neu aufgebaut wird, braucht daher eine explizite Retention-Entscheidung. Die meisten Systeme kombinieren die ersten beiden Patterns; Event Sourcing bedeutet, jedes Event durch Code zu schicken, der auch das älteste Schema noch versteht.

Topic-Design und Keys

Granularität. Ein Topic pro Event-Typ (orders.order-placed) lässt sich leicht absichern und weiterentwickeln. Ein Topic pro Entitäts-Stream (orders.events mit placed, paid und shipped) hält jede Änderung an einer Bestellung in einer Sequenz. Kafka ordnet Records nur innerhalb einer Partition. Braucht ein Consumer für dieselbe Bestellung placed vor paid, müssen beide Typen ein gemeinsames Topic nutzen.

Keys. Verwenden Sie die Entitäts- oder Aggregat-ID als Record-Key, damit der Standard-Partitioner alle Events einer Bestellung an dieselbe Partition sendet. Ein Key mit wenigen sehr heißen Werten, etwa einem großen Mandanten, überlastet eine Partition und einen Consumer. Spätere zusätzliche Partitionen ändern das Hashing der Keys und brechen die Reihenfolge pro Key über die Änderung hinweg – planen Sie Wachstum also von Anfang an ein; siehe unseren Leitfaden zur Kafka-Partitionsstrategie. Legen Sie Replikation und Retention pro Topic fest, statt sich auf Broker-Defaults zu verlassen.

Schemas und Kompatibilität

Events sind ein Vertrag zwischen Teams, die vielleicht nie miteinander sprechen. Hinterlegen Sie für jedes Topic ein Schema (Avro, Protobuf oder JSON Schema) und lassen Sie eine Registry inkompatible Änderungen bereits bei der Registrierung ablehnen – nicht erst im Stack Trace eines Consumers. Confluent Schema Registry (Confluent Community License) verwendet standardmäßig BACKWARD: Consumer mit dem neuen Schema können alte Daten lesen. Sie dürfen also Felder löschen und optionale hinzufügen und aktualisieren zuerst die Consumer. Apicurio Registry ist eine Alternative unter Apache 2.0.

  • Nutzen Sie BACKWARD_TRANSITIVE oder FULL_TRANSITIVE für Topics mit Replay: Transitive Modi prüfen jede frühere Version, und ein Replay liest sie alle.
  • Setzen Sie ein gemeinsam genutztes Topic nie auf NONE, um eine Breaking Change zu erzwingen; veröffentlichen Sie stattdessen eine neue Topic-Version.
  • Für mehrere Event-Typen in einem Topic wechseln Sie von der Standard-TopicNameStrategy zu RecordNameStrategy oder TopicRecordNameStrategy.

Geben Sie jedem Event einen Envelope: eine eindeutige Event-ID, den Typ, den Zeitpunkt des Ereignisses und eine Correlation-ID.

Reihenfolge und Idempotenz

Auf Producer-Seite verwenden aktuelle Kafka-Clients standardmäßig acks=all und enable.idempotence=true. Laut Producer-Dokumentation bleibt die Reihenfolge bei aktivierter Idempotenz erhalten, solange max.in.flight.requests.per.connection bei höchstens 5 liegt. Prüfen Sie, dass ältere Services diese Werte nicht überschrieben haben:

acks=all
enable.idempotence=true
max.in.flight.requests.per.connection=5

Der idempotente Producer entfernt nur Duplikate aus seinen eigenen Retries. Ein Consumer, der einen Batch verarbeitet und vor dem Commit der Offsets abstürzt, verarbeitet ihn nach dem Rebalance erneut. Machen Sie jeden Handler idempotent: Speichern Sie verarbeitete Event-IDs in derselben Transaktion wie den Seiteneffekt, oder nutzen Sie Upserts mit Entität und Version als Key.

Das Outbox-Pattern mit Debezium

Der häufigste Datenverlust-Bug in ereignisgesteuerten Services ist der Dual Write: erst Commit in die Datenbank, dann Publish nach Kafka. Stirbt der Prozess dazwischen, widersprechen sich Datenbank und Event-Stream.

Das transaktionale Outbox-Pattern beseitigt den zweiten Schreibvorgang. Der Service fügt das Event in derselben Transaktion wie die fachliche Änderung in eine outbox-Tabelle ein; Debezium liest das Change Log der Datenbank, und sein Outbox Event Router macht aus jeder Zeile ein Domain-Event:

transforms=outbox
transforms.outbox.type=io.debezium.transforms.outbox.EventRouter
# outbox columns: id, aggregatetype, aggregateid, type, payload
# default topic: outbox.event.${routedByValue} (the aggregatetype)
# default record key: aggregateid

Mit aggregateid als Key bleiben die Events jedes Aggregats in Reihenfolge. Löschen Sie alte Outbox-Zeilen regelmäßig und deduplizieren Sie anhand der Outbox-id, denn ein Connector-Neustart kann eine Zeile doppelt veröffentlichen. Unsere Engineers im Debezium-Support betreiben dieses Pattern auf PostgreSQL, SQL Server und Oracle. Outbox- und CDC-Optionen werden in Debezium-Alternativen verglichen.

Consumer Groups, Retries und Dead-Letter-Topics

Jede Consumer Group erhält jedes Event; innerhalb einer Group geht jede Partition an genau ein Mitglied, die Partitionsanzahl begrenzt also die Parallelität. Kafka 4.0 hat das neue Consumer-Group-Protokoll (KIP-848) für schnellere Rebalances allgemein verfügbar gemacht, Clients verwenden aber standardmäßig group.protocol=classic und müssen es mit group.protocol=consumer explizit aktivieren; siehe unseren Leitfaden zum Kafka-Rebalance.

Für gewöhnliche Consumer hat Kafka keine Dead-Letter-Queue (DLQ) – die Fehlerbehandlung ist Ihr Design:

  1. Retry an Ort und Stelle bei transienten Fehlern, mit Backoff und Obergrenze. Die Reihenfolge bleibt erhalten, aber die Partition stockt, und jede Poll-Schleife muss innerhalb von max.poll.interval.ms (standardmäßig fünf Minuten) abgeschlossen sein, sonst verlässt der Consumer die Group.
  2. Retry-Topics wie orders.retry.5m für Fehler, die sich später erledigen könnten. Die Partition läuft weiter, aber das erneut verarbeitete Event ist für seinen Key nun außer Reihenfolge.
  3. Ein Dead-Letter-Topic für Events, die nie erfolgreich sein werden – mit Headern zu Fehler, Quell-Topic, Partition und Offset, einem Alert und einem Replay-Pfad.

Spring for Apache Kafka und ähnliche Frameworks implementieren Retry- und Dead-Letter-Topics. Sink-Connectors von Kafka Connect nutzen errors.tolerance=all mit errors.deadletterqueue.topic.name. Für Queue-artige Verarbeitung ohne Reihenfolge pro Key hat Kafka 4.2 Share Groups produktionsreif gemacht, mit Acknowledgement (Ack) pro Record.

Exactly-once, wo es darauf ankommt

Kafka-Transaktionen bieten Exactly-once-Verarbeitung für Consume-Transform-Produce-Pipelines, die innerhalb von Kafka bleiben: eine Kafka-Streams-Anwendung mit processing.guarantee=exactly_once_v2 oder ein transaktionaler Producer, der konsumierte Offsets und Output-Records atomar committet und downstream mit isolation.level=read_committed gelesen wird (Consumer-Default ist read_uncommitted). Seiteneffekte außerhalb von Kafka, etwa ein Datenbank-Schreibvorgang oder ein Zahlungsaufruf, deckt das nicht ab – diese brauchen weiterhin idempotente Handler. Wie das funktioniert, erklärt unser Leitfaden zur Exactly-once-Semantik in Kafka.

Observability

  • Consumer Lag pro Partition, nicht nur pro Group: Eine hängende Partition versteckt sich in einer gesunden Gesamtsumme. Siehe Kafka Consumer Lag.
  • End-to-End-Latenz: Event-Zeitstempel versus Verarbeitungszeit, pro Consumer Group.
  • Dead-Letter-Topics: Alert bei jedem neuen Record.
  • Rebalance-Häufigkeit, Producer-Fehler und unterreplizierte Partitionen.
  • Tracing: eine Correlation-ID in den Record-Headern, damit sich eine Transaktion über Services hinweg verfolgen lässt.

Typische Fehlerbilder

  • Poison Message. Ein fehlerhaftes Event scheitert bei jedem Retry und blockiert seine Partition. Lösung: begrenzte Retries, danach ein Dead-Letter-Topic.
  • Rebalance-Schleifen. Ein langsamer Handler überschreitet max.poll.interval.ms, seine Partitionen wandern, und der Zyklus wiederholt sich. Lösung: max.poll.records senken oder schnellere Handler.
  • Stiller Verlust durch Retention. Ein Consumer, der länger offline ist als die Retention des Topics, trifft auf gelöschte Events und springt mit auto.offset.reset auf dem Default latest ohne Fehlermeldung nach vorn. Siehe Kafka-Retention-Policy.
  • Heiße Partitionen durch ungleich verteilte Keys, durchgedrückte Breaking Changes am Schema und Dual Writes ohne Outbox-Pattern.

Wenn manche Flows eigentlich Task-Queues mit Routing und Prioritäten sind, siehe RabbitMQ vs. Kafka.

Wann Sie Hilfe holen sollten

Die Engineers im Kafka-Support von AceMQ prüfen Topic-, Key-, Schema- und Retry-Design und sind zur Stelle, wenn etwas ausfällt – auf selbst betriebenem Kafka, Confluent Platform und Amazon MSK; mit Kafka Managed Services betreiben wir die Cluster für Sie.

Quellen

Häufig gestellte Fragen

Was ist eine ereignisgesteuerte Architektur mit Kafka?

Services veröffentlichen Fakten über Geschehenes in Kafka-Topics, andere Services konsumieren sie über Consumer Groups, jeweils in ihrem eigenen Tempo. Kafka hält die Events für die Dauer der Retention vor, sodass ein neuer oder wiederhergestellter Consumer sie per Replay erneut verarbeiten kann. Innerhalb jeder Partition bleibt die Reihenfolge der Events erhalten.

Eignet sich Kafka für eine ereignisgesteuerte Architektur?

Ja, wenn viele Consumer dieselben Events benötigen, Replay wichtig ist und eine Reihenfolge pro Entität ausreicht. Weniger geeignet ist Kafka für Routing pro Nachricht, Prioritäten oder Request-Reply zwischen wenigen Services – hier ist ein Broker wie RabbitMQ einfacher.

Ein Topic pro Event-Typ oder pro Entität?

Ein Topic pro Event-Typ lässt sich leichter absichern und weiterentwickeln. Ein Topic pro Entitäts-Stream mit der Entitäts-ID als Key hält alle Events einer Entität in Reihenfolge. Wenn Consumer auf die Reihenfolge verschiedener Event-Typen derselben Entität angewiesen sind, müssen diese ein gemeinsames Topic nutzen.

Wie vermeide ich Dual Writes zwischen Datenbank und Kafka?

Mit dem transaktionalen Outbox-Pattern: Schreiben Sie das Event in derselben Transaktion wie die fachliche Änderung in eine Outbox-Tabelle und lassen Sie ein Change-Data-Capture-(CDC-)Tool wie Debezium es veröffentlichen. Der Outbox Event Router verwendet die Aggregat-ID als Key, sodass die Events jedes Aggregats in Reihenfolge bleiben.

Hat Kafka eine Dead-Letter-Queue (DLQ)?

Nicht für gewöhnliche Consumer. Sink-Connectors von Kafka Connect können fehlgeschlagene Records mit errors.deadletterqueue.topic.name in ein Dead-Letter-Topic schreiben. Anwendungs-Consumer implementieren Retry- und Dead-Letter-Topics selbst oder über ein Framework wie Spring for Apache Kafka.

Brauche ich Exactly-once-Semantik in Kafka?

Nur für Pipelines, die aus Kafka lesen und wieder in Kafka schreiben und bei denen ein Duplikat das Ergebnis verändert, etwa bei Aggregationen. Exactly-once deckt weder Datenbank-Schreibvorgänge noch externe API-Aufrufe ab – Handler müssen also weiterhin idempotent sein.

Scott Sternloff

Autor

Scott SternloffSenior Enterprise Architect

Senior Enterprise Architect bei AceMQ. Verantwortet hier die technischen Beiträge: Architektur, Clustering und Migrationen von RabbitMQ, Kafka und Redis.

Mit einem Engineer sprechen

Brauchen Sie Unterstützung bei Kafka?

Senior Engineers, die es selbst in Produktion betreiben. Fordern Sie ein Angebot oder ein kostenloses Erstgespräch an – ganz ohne Verkaufsgespräch.

Kostenlose Beratung

Lassen Sie Experten auf Ihre Kafka-Cluster-Umgebung schauen

Ob Sie einen Produktionsvorfall beheben, eine Migration planen oder eine zweite Meinung zu Ihrer Architektur wünschen – unser Team steht bereit. Kein Verkaufsgespräch, nur Antworten.

E-Mail schreiben