Auf dieser Seite
# Kafka Exactly-Once-Semantik: Funktionsweise und wo sie endet
Die Exactly-Once-Semantik (EOS) von Kafka ist ein Satz von Garantien, der dafür sorgt, dass jeder Record genau einmal im Log landet und die Consumer-Position genau einmal weiterrückt – auch wenn Producer Retries ausführen, Broker ausfallen oder eine Anwendung neu startet. Apache Kafka setzt das mit zwei Mechanismen um: einem idempotenten Producer, der doppelte Schreibvorgänge anhand einer eindeutigen Producer-ID und einer Sequenznummer pro Partition verwirft, und Transaktionen, die Schreibvorgänge in mehrere Topics plus den Offset-Commit zu einer atomaren Einheit zusammenfassen. Es ist die stärkste Zustellgarantie der Plattform, und sie ist echt – aber sie gilt innerhalb von Kafka, nicht für eine externe Datenbank, einen Object Store oder einen Drittanbieterdienst, in den Sie schreiben. Genau dort verbrennen sich die meisten Teams die Finger.
Ist Exactly-Once-Semantik in Kafka überhaupt möglich?
Ja. Version 0.11 führte 2017 die Exactly-Once-Semantik ein, und Confluent argumentierte damals, dass diese Nachrichtensemantik in einem realen Messaging-System möglich ist, nicht nur in der Theorie. Der Vorbehalt ist eine Frage der Definition: Kein verteiltes System kann versprechen, dass eine einzelne Netzwerkzustellung genau einmal erfolgt, denn ein Sender kann eine verlorene Anfrage nicht von einem verlorenen Acknowledgement unterscheiden. Kafka bietet Exactly-once-Verarbeitung: Fehler führen weiterhin zu wiederholten Versuchen, doch das Log verwirft die Wiederholungen und committet ihre Effekte atomar. Das Ergebnis entspricht also einer Welt, in der jede Nachricht genau einmal angekommen ist.
Die drei Zustellgarantien – und welche der Standard ist
Jedes Messaging-System bietet drei Zustellsemantiken für Nachrichten.
- At-most-once-Zustellung. Keine Producer-Retries; der Consumer committet vor der Verarbeitung. Schnell, nie dupliziert – und jeder Fehler bedeutet Datenverlust.
- At-least-once-Semantik. Der Producer sendet erneut; der Consumer committet nach der Verarbeitung. Nichts geht verloren, aber Duplikate sind möglich – der Standard in der Praxis.
- Exactly-once. Wiederholungen werden verworfen, und der Commit erfolgt atomar mit der Ausgabe.
Seit Kafka 3.0 wird der Java-Producer mit enable.idempotence=true und acks=all ausgeliefert, ein Standard-Producer unterdrückt also bereits Retry-Duplikate. End-to-End ist das dennoch At-least-once: Ohne Transaktionen und einen read_committed-Consumer führt ein Absturz zwischen Verarbeitung und Commit zum Replay von Records.
Warum Exactly-once ein schwieriges Problem ist
Vier Fehlerszenarien müssen gleichzeitig gelöst werden, jedes ein Klassiker verteilter Systeme. Ein Producer, der nach einem verlorenen Acknowledgement erneut sendet, hängt denselben Record zweimal an. Ein Consumer, der nach der Verarbeitung, aber vor dem Commit ausfällt, verarbeitet nach der Wiederherstellung erneut. Ein Task, der Ergebnisse schreibt und seine Position committet, verändert zwei unabhängige Zustände, die gemeinsam oder gar nicht ankommen müssen. Und eine Zombie-Instanz, abgeschnitten, aber noch aktiv, schreibt weiter in einen Stream, den ihre Ersatzinstanz bereits übernommen hat.
Die Bausteine, die Kafka nutzt
Die Garantien von Kafka beruhen auf fünf Komponenten: der Idempotenzschicht im Producer, einer stabilen transactional.id, einem brokerseitigen Transaction Coordinator, dem internen Topic __transaction_state samt Commit- und Abort-Markern in jeder Datenpartition sowie dem consumerseitigen Schalter isolation.level=read_committed.
Wie entfernen idempotente Producer Duplikate?
Setzen Sie enable.idempotence=true, weist der Broker diesem Producer eine eindeutige Producer-ID zu. Jeder Batch trägt die ID und einen Zähler, der innerhalb eines Topics monoton steigt. Der Broker merkt sich den höchsten akzeptierten Wert. Ein erneut gesendeter Batch, der nach einem verlorenen Ack eintrifft, wird daher als Wiederholung erkannt, verworfen und als Erfolg bestätigt – ein Schreibvorgang, ein Record im Log.
Das deckt Producer-Retries nur innerhalb einer einzelnen Session ab. Startet der Prozess neu, erhält er eine neue Producer-ID, und Schreibvorgänge vor dem Absturz lassen sich nicht mehr zuordnen – genau das behebt transactional.id.
Wie transaktionale Producer und Consumer zusammenarbeiten
Ein transaktionaler Producer setzt eine stabile, eindeutige transactional.id und folgt dann einer festen Aufrufreihenfolge: initTransactions() beim Start, danach beginTransaction(), send()-Aufrufe und commitTransaction() oder abortTransaction().
initTransactions() registriert sich beim Transaction Coordinator, erhöht die Producer-Epoche, um ältere Instanzen mit derselben Identität auszusperren (Fencing), und schließt unvollendete Arbeit ab – das macht die Wiederherstellung sicher. Beim Commit hält der Coordinator das Ergebnis in __transaction_state fest und schreibt dann Marker in jedes beteiligte Topic. So entstehen atomare Schreibvorgänge über mehrere Partitionen hinweg.
Exactly-once ist ein Vertrag zwischen Producer und Consumer, und auf der Leseseite kommt nichts davon an, solange Sie nicht isolation.level=read_committed konfigurieren. Der Standard read_uncommitted liefert zurückgerollte Records aus und hebelt das Design aus; ein read_committed-Consumer überspringt abgebrochene Daten und liest nicht über den Last Stable Offset hinaus.
Das Consume-Transform-Produce-Muster
Die meiste Exactly-once-Verarbeitung in Produktion ist eine Consume-Transform-Produce-Schleife: ein Kafka-Eingabe-Topic lesen, transformieren, in ein Ausgabe-Topic schreiben, die Eingabeposition committen. Der Commit gehört in die Transaktion. Deaktivieren Sie enable.auto.commit und übergeben Sie die konsumierten Offsets an sendOffsetsToTransaction(), damit Ergebnisse und Positionen als eine Einheit erfolgreich sind oder scheitern.
Eine Stream-Processing-Anwendung auf Basis der Kafka Streams API bekommt das gratis: Setzen Sie processing.guarantee=exactly_once_v2, und das Framework übernimmt es – einschließlich der State Stores für Joins und Aggregationen über Datenstreams. Die v2-Implementierung nutzt einen Producer pro Instanz, abgesichert über Consumer-Group-Metadaten, statt des ursprünglichen Modells mit einem Producer pro Task. Deshalb ist Exactly-once günstig genug, um es in jeder Streams-App aktiviert zu lassen.
Wo die Garantie endet
Genau diesen Punkt verwischen andere Artikel. Eine Kafka-Transaktion umfasst das Log und die damit committeten Consumer-Offsets. Sonst nichts. Schreibt Ihr Consumer nach Postgres, S3 oder in ein Payment-Gateway, ist dieser Schreibvorgang nicht eingebunden. Ein Absturz dazwischen erzeugt nachgelagert einen doppelten Schreibvorgang, obwohl der Zustand des Brokers selbst einwandfrei ist. End-to-End-Exactly-once setzt daher voraus, dass der Sink mitspielt:
- Machen Sie den Sink idempotent. Upsert auf einen natürlichen Schlüssel oder Schreiben in einen deterministischen Objektpfad – die einfachste und robusteste Lösung.
- Speichern Sie Positionen im Sink. Committen Sie Daten und Offset in einer externen Transaktion und setzen Sie bei der Wiederherstellung per Seek an diesem Wert an.
- Nutzen Sie einen Connector, der teilnimmt. Kafka Connect unterstützt Exactly-once-Zustellung für Source-Connectors und für Sinks mit Two-Phase-Commit – prüfen Sie das für jeden Connector.
Seiteneffekte außerhalb des Commit-Bereichs – eine E-Mail versenden, eine Karte belasten – lassen sich nie abdecken; deduplizieren Sie diese an der Grenze mit einem Idempotenzschlüssel. Wenn eine Pipeline Wiederholungen ausgibt, die Sie sich nicht erklären können, setzt der 24/7-Kafka-Support von AceMQ einen Senior Engineer darauf an – mit Reaktionszeitzielen ab 15 Minuten, je nach Plan.
Auswirkungen auf die Performance und Trade-offs
Idempotenz ist nahezu kostenlos und bereits standardmäßig aktiv. Kafka-Transaktionen kosten mehr: Records werden für read_committed-Consumer erst sichtbar, wenn die Marker geschrieben sind, sodass die Latenz grob durch Ihr Commit-Intervall begrenzt ist – Kafka Streams verkürzt commit.interval.ms unter EOS aus diesem Grund auf 100ms. Der Overhead bleibt moderat, wenn ein Commit einen ordentlichen Batch transaktionaler Nachrichten umfasst, und wird erheblich, wenn er nur sehr wenige umfasst.
Das größere Risiko ist eine hängende Transaktion: Sie blockiert den Last Stable Offset und bringt jeden read_committed-Consumer auf dieser Partition zum Stillstand, bis transaction.timeout.ms abläuft. Teams, die Kafka für Ledger oder Abrechnung nutzen, halten das für lohnend; für Analytics ist At-least-once plus ein Sink mit Upserts einfacher und günstiger.
Wie Sie prüfen, ob Exactly-once tatsächlich funktioniert
Eine Konfiguration, die in einer Properties-Datei korrekt aussieht, ist kein Beweis. Vier Prüfungen decken das meiste ab, was schiefgeht.
isolation.levelauf jedem Consumer des Ausgabe-Topics. Der Standard istread_uncommitted, sodass ein einziger nicht umgestellter nachgelagerter Service unbemerkt zurückgerollte Records liest – mit großem Abstand die häufigste Fehlkonfiguration.- Eine stabile
transactional.id, die Neustarts übersteht. Eine aus dem Container-Hostnamen abgeleitete Identität ändert sich bei jedem Deployment und kann ihren eigenen Zombie nicht aussperren. - Lag auf read_committed-Consumern. Eine Partition, deren Lag nicht mehr sinkt, während das Log weiter wächst, bedeutet meist, dass eine Transaktion nie committet oder abgebrochen wurde.
- Ein Producer, der in einer Testumgebung mitten in einer Transaktion beendet wird. Bestätigen Sie, dass nichts aus dem abgebrochenen Versuch das Ausgabe-Topic erreicht; die Produktion ist ein schlechter Ort, um diesen Pfad zum ersten Mal zu durchlaufen.
Die Entscheidung für Exactly-once ist eine Designfrage; Exactly-Once-Semantik über Upgrades, Rebalances und Coordinator-Failover hinweg aufrechtzuerhalten, ist eine Betriebsaufgabe. Die 11+ Senior SMEs von AceMQ betreuen 160+ Enterprise-Kunden in 26+ Ländern. Entdecken Sie die Enterprise-Kafka-Services von AceMQ, damit diese Grenze gezogen ist, bevor sie Sie einen Abgleich kostet.
Wenn hinter diesem Artikel eher eine Architekturfrage als ein akuter Incident steht – Partitionierungsstrategie, Sizing, Security-Design, eine Migration –, setzt die Kafka-Beratung von AceMQ einen namentlich zugeordneten Senior Engineer darauf an. Für einen Cluster, den Ihr Team selbst betreibt und der abgesichert sein soll, wenn etwas bricht, ist 24/7-Kafka-Support der passende Vertrag.
Dies ist Schritt fünf von zehn in unserem Leitfaden zum Kafka-Betrieb, der die betrieblichen Entscheidungen in der Reihenfolge behandelt, in der sie in einer Produktionsumgebung anfallen.
Häufig gestellte Fragen
Ist Exactly-Once-Semantik in Kafka überhaupt möglich?
Ja, Apache Kafka unterstützt Exactly-Once-Semantik seit Version 0.11, die 2017 erschienen ist. Umgesetzt ist sie als Exactly-Once-Verarbeitung, nicht als einmalige Zustellung über das Netzwerk: Datensätze können durchaus mehrfach übertragen werden, aber der Broker verwirft die Wiederholungen und committet die Ergebnisse atomar, sodass das Ergebnis einer einmaligen Zustellung entspricht. Die Garantie gilt für Daten, die in Kafka-Topics geschrieben werden, und für die Consumer-Positionen, die in derselben Transaktion committet werden. Jedes externe System, in das Ihre Anwendung schreibt, muss sich selbst gegen Wiederholungen absichern.
Wie aktiviere ich Exactly-Once-Zustellung in Kafka?
Konfigurieren Sie drei Dinge zusammen. Setzen Sie im Producer enable.idempotence=true und eine stabile, eindeutige transactional.id und kapseln Sie die Sends in initTransactions(), beginTransaction() und commitTransaction(). Schalten Sie im Consumer Auto-Commit ab, setzen Sie isolation.level=read_committed und übergeben Sie die konsumierten Positionen an sendOffsetsToTransaction(), damit sie atomar mit Ihren Ergebnissen committet werden. Wenn Sie Kafka Streams nutzen, erledigt processing.guarantee=exactly_once_v2 all das für Sie.
Arbeitet Kafka standardmäßig mit At-least-once?
Faktisch ja. Ein aktueller Kafka-Producer verwendet standardmäßig enable.idempotence=true und acks=all und unterdrückt damit Wiederholungen durch Producer-Retries. Consumer committen ihre Position aber weiterhin getrennt von der Verarbeitung. Ein Absturz zwischen der Verarbeitung eines Datensatzes und dem Commit führt dazu, dass dieser Datensatz bei der Wiederherstellung erneut verarbeitet wird – das ist At-least-once-Zustellsemantik. Für Exactly-Once braucht es Transaktionen im Producer und read_committed-Isolation im Consumer.
Was ist das Consume-Transform-Produce-Muster in Kafka?
Consume-Transform-Produce ist die Standardschleife für Exactly-Once: Eine Anwendung liest Datensätze aus einem Input-Topic, transformiert sie, schreibt die Ergebnisse in ein Output-Topic und committet die Input-Position. Die Exactly-Once-Eigenschaft entsteht dadurch, dass diese Position per sendOffsetsToTransaction() in derselben Transaktion wie die Ergebnisse committet wird. Wird der Commit zurückgerollt, werden weder die geschriebenen Datensätze noch die vorgerückte Position sichtbar, und die Arbeit wird sauber wiederholt. Kafka Streams implementiert dieses Muster intern, wenn Exactly-Once aktiviert ist.
Was kosten Kafka-Transaktionen an Performance?
Idempotenz verursacht kaum messbaren Overhead und ist standardmäßig aktiviert. Transaktionen erhöhen die Latenz, weil Datensätze für read_committed-Consumer erst sichtbar werden, nachdem die Commit-Marker geschrieben sind. Der Durchsatz hängt daher stark davon ab, wie viel Arbeit ein Commit abdeckt. Große Batches verteilen diese Kosten gut und kosten typischerweise nur einen moderaten Prozentsatz an Durchsatz, sehr kleine können dagegen drastisch langsamer sein. Das größere betriebliche Risiko ist ein hängender Commit, der nachgelagerte Consumer blockiert, bis sein Timeout abläuft.
Leitfäden, Vergleiche und Studien
Mehr zum Thema Kafka
Leitfäden
4Vergleiche
9- NATS vs Kafka 2026: Core NATS, JetStream und Kafka im Vergleich
- Mosquitto vs. Kafka: MQTT-Broker oder Event Log?
- Kafka vs. Kinesis im Vergleich
- Die besten Managed-Kafka-Anbieter 2026 jenseits der Hyperscaler
- Kafka-BYOC-Optionen (Bring Your Own Cloud) im Vergleich
- Alternativen zu Confluent und Wettbewerber nach der IBM-Übernahme

