Auf dieser Seite
RabbitMQ routet Nachrichten auf dem Broker und schreibt Quorum Queues per fsync auf die Festplatte, bevor es bestätigt; Kafka routet im Producer und skaliert ein Topic über Partitionen. Wählen Sie RabbitMQ für Task Queues, Kontrolle pro Nachricht und mehrere Protokolle. Wählen Sie Kafka für einen einzelnen Stream mit sehr hohem Volumen, lange Retention und Stream Processing. Beide bieten heute Streams und Queue-artige Verarbeitung.
RabbitMQ vs. Kafka: Vergleichstabelle
| RabbitMQ | Apache Kafka | |
|---|---|---|
| Wo das Routing liegt | Auf dem Broker: Exchanges und Bindings, zur Laufzeit änderbar | Im Producer, der die Partition wählt; Änderungen erfordern ein Code-Release |
| Standard-Dauerhaftigkeit | Quorum Queues replizieren und schreiben per fsync auf die Festplatte, bevor sie bestätigen; Streams replizieren ohne fsync | Nur Replikation; standardmäßig kein fsync vor dem Acknowledgement |
| Kontrolle pro Nachricht | TTL, strikte Prioritäten, Dead-Letter-Routing, Verzögerungen | Keine pro Nachricht; Share Groups ermöglichen Queue-artiges Lesen, aber ohne diese Funktionen |
| Zustellmodell | Push bis zu einem Prefetch-Limit; Streams lesen ab einem Offset | Pull; der Consumer verwaltet seinen Offset selbst |
| Durchsatz pro Ziel | Rund 80.000 Nachrichten/s für eine Quorum Queue; Streams erreichen mehrere Millionen | Skaliert mit Partitionen; mehrere Millionen Nachrichten/s pro Topic auf vergleichbarer Hardware |
| Skalierungseinheit | Die Queue (ohne Sharding); Super Streams partitionieren ein Log | Die Partition |
| Retention und Replay | Streams ermöglichen Replay; Retention ist durch die lokale Festplatte begrenzt | Replay, Tiered Storage und Log Compaction |
| Protokolle | AMQP 1.0, AMQP 0-9-1, MQTT, STOMP, JMS und ein Stream-Protokoll | Nur Kafka-Protokoll |
| Stream Processing | Selbst geschriebene Consumer und Clients | Kafka Streams, Connect und ein großes Ökosystem |
| Betrieb | Management-UI und Prometheus-Endpoint integriert; elastisches Umskalieren erfordert mehr Planung | JMX-Exporter und separate UI; Broker hinzufügen und Partitionen per Rebalancing verteilen ist Routine |
Die Zahlen zu Durchsatz und Dauerhaftigkeit stammen aus dem Vergleich von RabbitMQ und Kafka des RabbitMQ Core Team; Kafka Share Groups sind ab Kafka 4.2 produktionsreif. Die folgenden Abschnitte erläutern jede Zeile. Mehr zum Log-basierten Queue-Typ von RabbitMQ lesen Sie in RabbitMQ Streams: Performance, Tuning und Vergleich mit Kafka.
Der Vergleich, mit dem die meisten Teams arbeiten, ist rund zehn Jahre alt. „Kafka für Streaming, RabbitMQ für Queuing“ beschrieb die Welt von 2015 zutreffend – die von 2026 jedoch kaum noch. RabbitMQ bietet seit 3.9 Streams. Kafka hat Share Groups eingeführt, die eine Queue-artige Verarbeitung ermöglichen. Beide Systeme decken heute beide Aufgaben ab. Die Entscheidung hängt also nicht mehr davon ab, was jedes System kann, sondern davon, was es unter Last gut kann und was es Sie im Betrieb kostet.
Das RabbitMQ Core Team hat kürzlich einen wirklich hervorragenden technischen Vergleich von RabbitMQ und Kafka veröffentlicht – die beste Referenz auf Feature-Ebene zu diesem Thema. Dieser Beitrag ersetzt ihn nicht. Er liefert die andere Hälfte: was wir sehen, wenn wir diese Systeme für Kunden in Produktion betreiben – einschließlich der Stellen, an denen RabbitMQ tatsächlich unterliegt und die die offizielle Dokumentation verständlicherweise nicht in den Vordergrund stellt.
AceMQ betreut sowohl RabbitMQ als auch Apache Kafka in Produktion für Enterprise-Kunden. Das verschafft uns eine ungewöhnliche Perspektive: Wir haben keinen Anreiz, einen der beiden Message Broker als universell richtig darzustellen, denn man ruft uns so oder so an.
Warum die alte Aufteilung „Kafka für Streaming, RabbitMQ für Queuing“ nicht mehr stimmt
Die ursprüngliche Aufteilung war real. Kafka wurde als verteiltes Commit-Log gebaut – eine Event-Streaming-Plattform für Echtzeit-Datenpipelines mit hohem Volumen, bei der der dauerhafte Datenstrom die zentrale Abstraktion ist. RabbitMQ wurde als AMQP-Message-Broker gebaut, der einzelne Arbeitseinheiten zwischen Anwendungen routet. Die Wahl zwischen beiden Messaging-Systemen war früher eine Frage der Form, die Ihr Problem hatte.
Zwei Änderungen haben diese Unterscheidung aufgelöst. Mit RabbitMQ Streams kam ein persistentes, wiederabspielbares Append-only-Log, aus dem Consumer ab einem Offset lesen – dasselbe Grundelement, auf dem Kafka aufbaut. Und mit Kafka Share Groups können mehrere Consumer aus einem Topic lesen, ohne dass ihnen Partitionen exklusiv zugewiesen werden – genau das Verhalten, das gemeint ist, wenn jemand sagt, er wolle eine Queue.
Auf dem Papier sind also beide Häkchen gesetzt. Die Falle ist die Annahme, ein gesetztes Häkchen bedeute Gleichwertigkeit. Ein RabbitMQ Stream ist kein schlechteres Kafka-Topic, und Kafka Share Groups sind keine schlechtere RabbitMQ-Queue – aber keines von beiden ist ein direkter Ersatz für das, was es nachahmt, und genau in diesen Lücken entstehen Produktions-Incidents.
Wo Kafka und RabbitMQ heute tatsächlich übereinstimmen
Auf der Streaming-Seite haben sich die beiden Architekturen bemerkenswert stark angenähert, und RabbitMQ macht kein Geheimnis daraus, bewährte Designentscheidungen übernommen zu haben. Beide Systeme nutzen Batches von Nachrichten als Arbeitseinheit. Beide verwenden vom Producer über die Disk bis zum Consumer ein einziges Binärformat, sodass unterwegs nichts neu codiert wird. Beide lesen per Zero-Copy über sendfile. Beide stützen sich auf den Page Cache des Betriebssystems, statt Nachrichten im Heap der Anwendung zu halten. Beide unterstützen Deduplizierung auf Publisher-Seite. Und beide nutzen inzwischen Raft für Cluster-Metadaten – KRaft in Kafka, Khepri in RabbitMQ.
Die praktische Folge: Der Streaming-Durchsatz ist kein relevantes Unterscheidungsmerkmal mehr. RabbitMQ Streams und Kafka-Topics erreichen auf vergleichbarer Hardware beide mehrere Millionen Nachrichten pro Sekunde. Wenn Ihnen jemand Kafka statt RabbitMQ empfiehlt, weil RabbitMQ kein Volumen bewältige, zitiert er einen Benchmark einer Version, die seit vielen Jahren ausgemustert ist.
Das ist wichtig für die Einordnung älterer Vergleiche. Ein Großteil der Inhalte zu „Kafka vs. RabbitMQ“, die noch im Umlauf sind, entstand, bevor es Streams gab. Ihre Schlussfolgerungen zur Performance waren damals richtig und sind heute falsch.
Der Unterschied bei der Dauerhaftigkeit, den die meisten Vergleiche auslassen
Das ist der folgenreichste technische Unterschied zwischen den beiden Systemen – und er wird in allgemeinen Vergleichsartikeln fast nie behandelt.
Kafka verlässt sich standardmäßig allein auf Replikation. Wenn ein Broker Ihre Nachricht bestätigt, liegt sie im Page Cache mehrerer Broker – auf die Disk geschrieben ist sie damit nicht zwingend. Replikation über mehrere Nodes ist ein starker Mechanismus zur Risikominderung und deckt den häufigen Fall ab, dass eine Maschine ausfällt. Was sie nicht abdeckt, sind korrelierte Ausfälle. Teilen sich Ihre Availability Zones eine Stromversorgung oder betreiben Sie alles On-Premises an einem einzigen Standort, kann ein Stromausfall bereits bestätigte Nachrichten mit sich reißen.
Quorum Queues in RabbitMQ replizieren und führen fsync auf die Disk aus, bevor sie dem Publisher bestätigen. Die Nachricht liegt dauerhaft auf der Disk einer Mehrheit der Nodes, bevor Ihre Anwendung erfährt, dass sie angenommen wurde. Das ist eine wesentlich stärkere Garantie, und für Zahlungen, Bestellungen und alles mit regulatorischem Prüfpfad ist sie oft das entscheidende Kriterium.
Die Nuance, die man verstehen sollte: RabbitMQ Streams gehen denselben Kompromiss ein wie Kafka. Streams verlassen sich auf Replikation und den Page Cache und führen vor der Bestätigung kein fsync aus. Die Aussage lautet also nicht „RabbitMQ ist sicherer als Kafka“, sondern: RabbitMQ lässt Ihnen die Wahl pro Ziel. Leiten Sie die Nachrichten, die Sie nicht verlieren dürfen, über eine Quorum Queue und Telemetrie mit hohem Volumen über einen Stream – im selben Cluster.
Dass RabbitMQ sich das leisten kann, liegt an der Architektur. In Kafka ist fsync teuer, weil es pro Partition stattfindet. In RabbitMQ teilen sich Quorum Queues ein Write-Ahead-Log, sodass sich die Kosten eines Flush auf viele Queues verteilen, statt von jeder einzeln getragen zu werden. Genau das macht es praktikabel, viele Queues, Replikation mit fsync und hohen Durchsatz gleichzeitig zu haben – drei Eigenschaften, von denen Sie sich bei Kafka in der Regel für zwei entscheiden müssen.
Wo RabbitMQ gewinnt: Kontrolle pro Nachricht und brokerseitiges Routing
Der grundlegendste konzeptionelle Unterschied ist, was eine Nachricht ist. In RabbitMQ ist eine Nachricht eine eigenständige Arbeitseinheit mit eigenem Lebenszyklus. In Kafka ist eine Nachricht eine feste Position in einem gemeinsamen Log, und ihr Schicksal ist an ihre Nachbarn gebunden.
Aus diesem Unterschied heraus führen Quorum Queues in RabbitMQ Raft-Konsens bis auf die einzelne Nachricht hinunter – einschließlich des Zustellstatus, also welche Nachricht welchem Consumer zugeteilt ist und wie viele Credits dieser Consumer hält. Bei einem Leader-Failover setzt der neue Leader mit genau diesem Zustand fort. Die Semantik von Kafka ist hier schwächer: Recovery bedeutet in der Regel, einen Batch erneut auszuliefern. Für eine Verarbeitung nach at-least-once ist das in Ordnung, aber es ist nicht dieselbe Garantie.
In der Praxis ergibt sich daraus ein Werkzeugkasten pro Nachricht, für den es in Kafka keine Entsprechung gibt:
- TTL pro Nachricht – einzelne Nachrichten laufen nach ihrem eigenen Zeitplan ab.
- Strikte Prioritätsstufen – dringende Arbeit überholt den Rückstau in der Queue, statt dahinter zu warten.
- Dead-Letter-Routing – fehlgeschlagene Nachrichten werden automatisch an einen sinnvollen Ort geleitet, statt zu blockieren oder zu verschwinden.
- Verzögerungen und verzögerte Retries – Backoff ohne externen Scheduler.
- Brokerseitige Message Interceptors – Logik, die auf dem Broker läuft statt in jedem Client.
Kafka Share Groups ermöglichen Queue-artigen Konsum, bringen aber weder TTL pro Nachricht noch Prioritäten oder Dead-Letter-Routing mit, und Head-of-Line-Blocking ist nicht vollständig beseitigt. Ist Ihr Workload tatsächlich eine Task Queue mit SLAs und Fehlerbehandlung, entscheidet allein diese Lücke.
Der zweite Vorteil von RabbitMQ ist brokerseitiges Routing und Filtern. Mit Exchanges, Bindings und Queues entscheidet der Broker, wohin eine Nachricht geht, und Bindings lassen sich zur Laufzeit umkonfigurieren, ohne Publisher neu auszurollen. In Kafka entscheidet der Producer, in welche Partition er schreibt – die Routing-Logik steckt also im Anwendungscode. Ein Topic-Muster wie orders.# ist in RabbitMQ ein einziges Binding; in Kafka sind es entweder mehrere physische Topics oder clientseitiges Filtern, das Daten über das Netzwerk holt, nur um sie dann zu verwerfen. Dieser Unterschied wirkt sich empfindlich aus, wenn Sie Tausende logische Subjects haben statt eines Dutzends.
Hinzu kommt die Multiprotokoll-Unterstützung – AMQP 1.0, AMQP 0-9-1, MQTT, STOMP und JMS auf einem Cluster, mit dokumentierter Header-Konvertierung zwischen ihnen. Damit deckt RabbitMQ eventgesteuerte Architekturen ab, in denen IoT-Geräte, Java-Anwendungen und Microservices denselben Message Broker brauchen. Kafka spricht das Kafka-Protokoll.
Routing: Wo die Logik liegt und wer dafür zahlt
Die tiefere Konsequenz des brokerseitigen Routings ist organisatorischer Natur. Liegt das Routing im Broker, ist eine Änderung des Nachrichtenflusses eine Konfigurationsänderung: Um einen Consumer an einen bestehenden Fluss anzuhängen, deklarieren Sie zur Laufzeit eine Queue und ein Binding – über die Management-UI, die HTTP-API oder die CLI –, ohne dass die veröffentlichenden Anwendungen beteiligt sind. Liegt das Routing im Producer, wie bei Kafka, ist eine Änderung des Nachrichtenflusses eine Codeänderung: Der Producer wählt die Partition, also bedeutet jede Änderung der Verteilung einen Pull Request, einen Build und ein Deployment.
Das Paradebeispiel ist eine Wildcard. Bestellungen werden mit Subjects wie orders.eu.created, orders.us.shipped und orders.apac.cancelled veröffentlicht, und ein Audit-Service benötigt jedes Bestell-Event. In RabbitMQ genügen dafür ein Topic Exchange und ein Binding mit dem Key orders.#. Wenn im nächsten Quartal orders.latam.created hinzukommt, erhält die Audit-Queue diese Nachrichten ohne Änderung am Producer und ohne erneutes Deployment. In Kafka haben Sie die Wahl zwischen zwei unvollkommenen Optionen: Entweder legen Sie pro Subject ein physisches Topic an und abonnieren per Muster – die Anzahl der Topics wächst dann mit Ihren Geschäftsdimensionen. Oder Sie veröffentlichen alles in ein Topic orders und filtern im Consumer, wobei jede Nachricht über das Netzwerk gezogen wird, um die meisten zu verwerfen. Bei drei Subjects ist das Geschmackssache. Bei dreitausend – pro Mandant, Region oder Geräteklasse – entscheidet es, ob das Design trägt.
RabbitMQ unterstützt außerdem Exchange-to-Exchange-Bindings: Ein Fan-out kann so mehrere Topic Exchanges speisen, ohne dass diese Struktur im Anwendungscode liegt. Die Kehrseite: Brokerseitiges Routing kostet Broker-CPU, und eine Topologie mit Tausenden ständig wechselnden Bindings ist echte Last. Wir haben erlebt, dass exzessiver Binding-Churn in Kombination mit tief verschachtelten Wildcard-Keys zu einem echten Performance-Problem wurde – meist ein Zeichen dafür, dass die Subject-Hierarchie flacher werden muss, nicht dafür, dass Routing der falsche Ansatz ist.
Das producerseitige Partitionieren in Kafka ist ein bewusster Kompromiss, kein Versäumnis. Weil der Producer die Partition wählt, verteilt sich ein Topic über viele Broker und wird von einer Consumer Group parallel konsumiert; ein Broker, der kein Routing übernimmt, hat weniger Möglichkeiten, zum Engpass zu werden. Die Frage ist also, ob Ihr Problem aus vielen Subjects mit selektiven Consumern besteht – dann ist brokerseitiges Routing bares Geld wert – oder aus einem riesigen, breit konsumierten Stream, bei dem Partitionierung mehr bringt.
Protokollvielfalt: Ein Cluster, viele Clients
Weil RabbitMQ zentral routet, kann es eine Nachricht über ein Protokoll annehmen und über ein anderes zustellen. Ein Cluster bedient AMQP 1.0, AMQP 0-9-1, MQTT, STOMP, JMS und ein eigenes Stream-Protokoll, und RabbitMQ dokumentiert, wie Nachrichten-Header konvertiert werden, wenn eine Nachricht zwischen ihnen wechselt.
Das entscheidet manche Architekturen von vornherein. IoT-Geräte mit MQTT, ältere Java-Anwendungen mit JMS und moderne Services mit AMQP 1.0 können sich einen RabbitMQ-Cluster teilen. Kafka spricht ausschließlich das Kafka-Protokoll. Es ist ein gutes Protokoll und der De-facto-Standard für Streaming, doch für alles andere brauchen Sie Bridges oder Connectors als separate Infrastruktur, die bereitgestellt, überwacht, abgesichert und gepatcht werden muss. Für eine Kafka-native Architektur ist das kein Thema. Für eine heterogene IT-Landschaft sind das dauerhafte Betriebskosten, die im ersten Vergleich selten auftauchen. Geht es bei dieser Entscheidung um Architektur statt um einen akuten Vorfall, setzen AceMQs Kafka-Beratung und RabbitMQ-Services namentlich zugeordnete Senior Engineers darauf an.
Wo RabbitMQ tatsächlich unterliegt
Diesen Abschnitt kann keine Herstellerdokumentation schreiben – und wenn Sie vor einer echten Entscheidung stehen, lohnt es sich, ihn zweimal zu lesen.
Es gibt kein Sharding auf Queue-Ebene
Eine Quorum Queue ist nicht partitioniert. Ihre Durchsatzgrenze liegt mit Replikation und fsync bei etwa 80.000 Nachrichten pro Sekunde, und Sie können eine einzelne Queue nicht über mehrere Knoten aufteilen, um schneller zu werden. Der Gesamtdurchsatz des Clusters skaliert problemlos – verteilen Sie die Arbeit auf viele Queues, und RabbitMQ bewältigt sie mühelos. Aber ein extrem heißer Fluss durch ein einziges Ziel ist eine echte Grenze, und genau diese Einschränkung müssen wir Kunden am häufigsten erklären. Kafka teilt ein Topic gerade deshalb in Partitionen auf, und bei einem echten Single-Stream-Firehose gewinnt diese Architektur.
Der Workaround ist Sharding auf Anwendungsebene – Nachrichten mit einem lastverteilenden Routing Key über N Queues veröffentlichen. Das funktioniert, ist aber Ihr Designproblem und nichts, was der Broker für Sie erledigt.
Cloud-Elastizität und Umskalieren erfordern mehr Planung
Einen Kafka-Cluster vergrößern heißt: Broker hinzufügen und Partitionen per Rebalancing neu verteilen. Einen RabbitMQ-Cluster vergrößern heißt: sich mit der Replikat-Mitgliedschaft der Quorum Queues befassen – welche Queues wo Replikate haben, wie man sie verschiebt und wie sich das Quorum währenddessen verhält. Das ist klar definiert und nicht gefährlich, entspricht aber nicht dem elastischen Scale-out, den Cloud-native Teams standardmäßig erwarten.
Zur Einordnung realer Topologien: In den von uns betreuten Clustern sind drei Knoten die übliche Basis, fünf sehr häufig, sieben kommen gelegentlich vor, und wir haben in freier Wildbahn auch einen Cluster mit dreizehn Knoten gesehen – aufgebaut, um viele parallele Verarbeitungspfade horizontal zu betreiben, nicht aus Quorum-Gründen. Die meisten Teams brauchen nicht mehr als fünf. Wer jedoch echtes elastisches Umskalieren will, sollte wissen, dass das Planung erfordert.
Drei Fähigkeiten, die Kafka hat und RabbitMQ nicht
- Tiered Storage. Kafka kann ältere Log-Segmente in Object Storage auslagern, was sehr lange Retention wirtschaftlich macht. RabbitMQ hat dafür heute kein Gegenstück.
- Log Compaction. Nur den jeweils neuesten Wert pro Key zu behalten, ist in Kafka nativ. Auf RabbitMQ können Sie das selbst bauen – aber Sie müssen es eben bauen.
- Das Stream-Processing-Ökosystem. Kafka Streams samt Connector- und Analytics-Ökosystem ist deutlich ausgereifter. Wenn Ihr Team zustandsbehaftete Joins, Windowing und Aggregationen als zentralen Bestandteil des Produkts betreibt, ist dieses Ökosystem ein echter Grund für Kafka – und zwar ein eindeutiger.
Trifft eine dieser drei Anforderungen auf Sie zu, lautet die ehrliche Empfehlung: Kafka. Und das sagen wir Ihnen auch.
Push vs. Pull – und warum sich das in Ihren Latenzwerten zeigt
Classic und Quorum Queues in RabbitMQ arbeiten nach dem Push-Modell: Der Broker stellt Nachrichten bis zu einem Prefetch-Limit an Consumer zu, sodass eine Nachricht, die in einer leeren Queue ankommt, sofort einen Consumer erreicht. Kafka arbeitet nach dem Pull-Modell: Consumer pollen und verwalten ihren Offset selbst.
Bei Background Jobs und Request/Reply ist das Push-Modell der Grund, warum RabbitMQ in der Regel eine niedrigere End-to-End-Latenz erzielt – zwischen Ankunft und Zustellung liegt kein Poll-Intervall. Für Replay, Reprocessing und Consumer, die sich unabhängig durch die Historie bewegen müssen, ist das Pull-Modell sauberer, weil der Offset dem Consumer gehört, statt dass der Broker den Zustellstatus pro Consumer verfolgt.
RabbitMQ Streams sind die Ausnahme und verhalten sich wie Kafka: Consumer setzen an einem Offset an und lesen vorwärts, und die Daten bleiben nach dem Konsum für ein Replay verfügbar. Das ist das häufigste Missverständnis, das wir korrigieren: RabbitMQ löscht eine Nachricht nicht in dem Moment, in dem jemand sie liest, wenn Sie einen Stream verwenden. Das galt für Classic Queues und hat die Annahmen einer ganzen Generation geprägt.
Ein Wechsel zwischen beiden ist eine Architekturänderung, keine Umkonfiguration
Teams, die einen Wechsel prüfen, unterschätzen das meist – und es ist die teuerste Annahme im gesamten Vergleich.
Von Kafka zu RabbitMQ ist kein Plug-and-Play. Consumer Groups, partitionsbasierte Reihenfolge und Offset-Management haben keine eins-zu-eins-Entsprechung. Alles, was als Read-Process-Write-Schleife über Partitionen gebaut ist, und alles mit Kafka Streams muss neu entworfen statt umkonfiguriert werden. Erfolgreiche Migrationen werden von Anfang an als Architekturänderung geplant, mit einer Topologie, die rund um Exchanges, Bindings und den passenden Queue-Typ pro Fluss neu aufgebaut wird.
Auch die Richtung spielt eine Rolle, und wir beobachten eine klare Asymmetrie:
- Teams, die bereits RabbitMQ betreiben und Streaming brauchen, sind der einfache Fall. Streams sind in dem Broker enthalten, den sie ohnehin betreiben, das Team kennt die Tools bereits, und es muss keine zweite Plattform personell besetzt werden.
- Teams, die bereits Kafka betreiben und echte Messaging-Semantik brauchen, sind der interessante Fall. Wenn sie sich die Gesamtkosten, den Betriebsaufwand des Clusters und den tatsächlichen Wert von fsync-before-confirm genau ansehen, spricht das Ergebnis meist für sich – für RabbitMQ. Schauen sie nicht so genau hin, bauen sie auf Kafka tendenziell immer aufwendigere Workarounds für Probleme, die ein Message Broker nativ löst.
Gehören Sie zur zweiten Gruppe, hilft keine Feature-Checkliste. Rechnen Sie lieber durch, was Sie derzeit aufwenden, damit sich Kafka wie eine Queue verhält.
Ein Entscheidungsrahmen, der in der Praxis trägt
Jeder Anwendungsfall dem passenden System zugeordnet – auf Basis dessen, was das Ergebnis tatsächlich bestimmt, nicht auf Basis von Kategorie-Etiketten:
| Task Queues und Background Jobs | RabbitMQ – Acknowledgement pro Nachricht, Retries, Dead-Lettering |
| Zahlungen, Bestellungen, Workloads in regulierten Branchen | RabbitMQ – Quorum Queues replizieren und schreiben per fsync, bevor sie bestätigen |
| Prioritäten und SLAs pro Nachricht | RabbitMQ – kein Gegenstück in Kafka |
| Request/Reply zwischen Microservices | RabbitMQ – niedrige Latenz, Push-Zustellung, Direct Reply-to |
| IoT und Geräteanbindung | RabbitMQ – natives MQTT in großem Maßstab auf demselben Cluster |
| Viele logische Subjects oder Isolation pro Mandant | RabbitMQ – brokerseitiges Routing, Virtual Hosts, Tausende günstige Queues |
| Event-Streaming mit Replay | Beide – die Designs haben sich angenähert; nehmen Sie das, was Sie bereits betreiben |
| Website-Activity-Tracking, Logs, Telemetrie | Beide – der Durchsatz ist inzwischen vergleichbar |
| Extremer Durchsatz durch einen einzigen Fluss | Kafka – Partitionierung teilt ein heißes Topic auf; Queues kennen kein Sharding |
| Mehrjährige Retention auf günstigem Speicher | Kafka – Tiered Storage in Object Storage |
| Semantik „neuester Wert pro Key“ | Kafka – native Log Compaction |
| Zustandsbehaftetes Stream Processing und Analytics | Kafka – Kafka Streams und das umgebende Ökosystem |
Das Muster in dieser Tabelle lautet nicht „RabbitMQ gewinnt“. Es lautet: RabbitMQ gewinnt bei Messaging-Semantik und betrieblicher Bandbreite, Kafka bei der Log-Ökonomie und dem Processing-Ökosystem. Das sind unterschiedliche Fragen, und die meisten Teams wissen, welche sie tatsächlich stellen, sobald man es so formuliert.
Dieselbe Aufteilung gilt, wenn die Consumer KI-Agenten und LLM-Worker statt Services sind. Unser Vergleich RabbitMQ vs. Kafka vs. NATS für KI-Agenten behandelt diesen Fall im Detail.
Beide zu betreiben ist eine legitime Antwort
Die Formulierung „RabbitMQ vs. Kafka“ suggeriert einen Sieger – viele ausgereifte Architekturen haben schlicht keinen. Ein Muster, das in ereignisgesteuerten Systemen immer wieder funktioniert: RabbitMQ übernimmt das operative Messaging – Task Queues, Request/Reply, Geräteanbindung, Isolation pro Mandant –, während Kafka die Analytics- und Event-History-Schicht trägt, in der sich Tiered Storage und Stream Processing bezahlt machen. Das ist ein typischer Anwendungsfall für den Betrieb beider Systeme.
Die Kosten dieser Aufteilung sind real: zwei Plattformen, die besetzt, überwacht, gepatcht und abgesichert werden müssen. Sie lohnen sich, wenn beide Anforderungsprofile tatsächlich vorhanden sind, und sollten vermieden werden, wenn ein System alles abdecken würde. Unser grundsätzlicher Rat an Teams, die neu starten: Beginnen Sie mit dem Message Broker, der die größte Bandbreite Ihrer Anforderungen abdeckt, und ergänzen Sie das zweite System, sobald Sie auf etwas stoßen, das nur dieses kann. Für die meisten Enterprise-Workloads heißt das: mit RabbitMQ beginnen und Kafka hinzunehmen, falls und sobald Log-Ökonomie oder Processing-Ökosystem zur entscheidenden Einschränkung werden.
Wenn Sie diese Entscheidung anhand eines echten Workloads statt abstrakt abwägen, ist das genau das Gespräch, das wir am häufigsten führen. AceMQ betreibt beide Plattformen in Produktion für Enterprise-Kunden – siehe unsere RabbitMQ-Services und unseren Kafka-Support, oder sprechen Sie mit uns darüber, welches System zu Ihrer Architektur passt. Wir sagen Ihnen genauso gern, wenn die Antwort Kafka lautet.
Zwei verwandte Vergleiche: Kafka vs. Pulsar, falls Sie noch eine Streaming-Plattform auswählen, und Wechsel von Kafka zu RabbitMQ, falls Sie zu dem Schluss gekommen sind, dass die Wahl nicht passt.
RabbitMQ vs. Kafka bei der Skalierung: Was wirklich skaliert – und was nicht
„Was skaliert besser?“ ist die Frage, die wir am häufigsten hören – und es ist die falsche Frage. Beide Broker skalieren, aber entlang unterschiedlicher Achsen, und was Sie für mehr Kapazität hinzufügen, unterscheidet sich jeweils. Wählen Sie diese Einheit richtig, trägt jedes der beiden Systeme mehr, als die meisten Unternehmen jemals hindurchschicken.
Die Skalierungseinheit. In Kafka ist die Einheit die Partition. Ein Topic ist eine Menge von Partitionen, jede ein geordnetes Log mit einem Leader, und der Durchsatz eines Topics ist die Summe seiner Partitionen. Mehr Partitionen bedeuten mehr Parallelität – um den Preis der Reihenfolge über das gesamte Topic und eines Rebalance für jede angebundene Consumer Group.
In RabbitMQ ist die Einheit die Queue. Eine Quorum Queue ist eine Raft-Gruppe mit einem Leader auf einem Knoten. Sie wird zur Sicherheit repliziert, nicht für Durchsatz geshardet; eine einzelne Quorum Queue ist daher durch das begrenzt, was CPU und Festplatte eines Knotens für diese Queue leisten. Streams und Super Streams sind die partitionierte Antwort: Ein Super Stream ist eine Menge von Stream-Partitionen mit derselben Struktur und denselben Kompromissen wie ein Kafka-Topic. Diesen Vergleich behandeln wir ausführlich in RabbitMQ Streams vs. Kafka. Für klassische Workloads ohne Bedarf an einem wiederabspielbaren Log verteilt der Consistent-Hash-Exchange den Traffic per Routing Key auf viele Queues – so verteilen Sie einen heißen Fluss auf mehrere Knoten, ohne die Producer anzufassen.
Was linear skaliert und was an eine Grenze stößt. In RabbitMQ skalieren viele Queues nahezu linear über einen Cluster, weil der Leader jeder Queue auf einem anderen Knoten liegen kann. Eine einzelne heiße Queue nicht. Das ist die Grenze, die wir am häufigsten sehen: alles durch eine Queue geroutet, ein Knoten ausgelastet, der Rest des Clusters im Leerlauf. Die Lösung liegt im Design, nicht in der Hardware.
In Kafka skaliert der Durchsatz mit der Partitionsanzahl, Consumer können aber nicht darüber hinaus skalieren. Eine Consumer Group mit mehr Mitgliedern als Partitionen lässt die überzähligen untätig, und eine sehr hohe Partitionsanzahl pro Broker verlängert die Leader Election, erhöht die Zahl offener File Handles und verlängert die Recovery nach einem Neustart. Partitionen sind günstig – bis sie es nicht mehr sind.
Beide haben Limits pro Knoten, die nichts mit der Nachrichtenrate zu tun haben. RabbitMQ zählt Verbindungen und Channels pro Knoten, und Tausende gesprächige Clients mit jeweils mehreren Channels erschöpfen Speicher und Scheduler-Zeit, lange bevor der Nachrichtendurchsatz zum Problem wird. Die Raft-Replikation bei Quorum Queues kostet pro Batch einen Netzwerk-Roundtrip und einen Festplattenschreibvorgang auf einer Mehrheit der Replikate. Eine Quorum Queue ist daher konstruktionsbedingt langsamer als eine Classic Queue, und fünf Replikate sind langsamer als drei. Wie Sie für einen Workload zwischen beiden wählen, lesen Sie in Classic vs. Quorum Queues.
- Horizontale Skalierung der Broker. Einen Kafka-Broker hinzuzufügen bewirkt für sich genommen nichts. Sie weisen ihm Partitionen zu, und die Neuzuweisung kopiert Daten über das Netzwerk, während der Cluster weiterläuft. Auch ein neuer RabbitMQ-Knoten bewirkt für sich genommen nichts. Bestehende Queues ziehen nicht um; ihre Leader bleiben dort, wo sie deklariert wurden. Neue Queues lassen sich auf dem neuen Knoten platzieren, die Mitgliedschaft von Quorum Queues kann um ihn erweitert und Leader können neu verteilt werden – aber nichts davon geschieht automatisch. Beide brauchen einen Operator mit einem Plan, und dieser Plan sollte besser vor dem Incident-Call existieren.
- Skalierung der Consumer. RabbitMQ nutzt Competing Consumers: Hängen Sie weitere Consumer an eine Queue, verteilt der Broker die Zustellungen auf sie, begrenzt durch Prefetch. Kein Rebalance, keine Pause, kein Koordinationsprotokoll. Deshalb kommt RabbitMQ so gut mit stoßweise belasteten Worker-Pools zurecht. Kafka skaliert Consumer über das Rebalance der Consumer Group, das Partitionen neu verteilt und die Verarbeitung der Gruppe kurz anhält. Cooperative Rebalancing mildert das ab, doch die Obergrenze bleibt die Partitionsanzahl. Single Active Consumer in RabbitMQ sorgt für strikte Reihenfolge auf einer Queue auf Kosten der Parallelität – derselbe Kompromiss, den Kafka pro Partition eingeht.
- Betriebskosten. In Kafka zeigen sich die Skalierungskosten bei der Partitionsplanung, der Neuzuweisung und den Tools für Consumer Lag. In RabbitMQ bei Queue-Platzierung, sauberem Verbindungsmanagement und Memory Watermarks. Kostenlos ist keines von beiden. Die Cluster-Dimensionierung ist ein eigenes Thema und wird in unserer FAQ zu HA und Cluster-Dimensionierung behandelt, daher wiederholen wir sie hier nicht.
- Fazit. Kafka skaliert eine kleine Zahl geordneter Streams mit sehr hohem Volumen besser. RabbitMQ skaliert eine große Zahl moderater Flüsse mit Routing besser. Beide skalieren weit über die meisten Enterprise-Workloads hinaus. In unseren Projekten ist die Grenze, an die ein Kunde stößt, fast immer eine Designgrenze – eine heiße Queue oder ein riesiges Topic –, nicht die des Brokers. Wir betreiben beide Systeme in Produktion für Enterprise-Kunden, und die Lösung besteht meist darin, den Workload neu zu partitionieren, statt den Broker zu wechseln. Siehe unsere RabbitMQ-Beratung und Kafka-Beratung.
FAQ
Was ist 2026 der eigentliche Unterschied zwischen RabbitMQ und Kafka?
Die ehrliche Antwort lautet nicht mehr „Kafka für Streaming, RabbitMQ für Queuing“. RabbitMQ bietet seit 3.9 Streams, und Kafka hat Share Groups für Queue-artige Verarbeitung eingeführt. Beide Systeme erledigen heute beide Aufgaben. Die eigentlichen Unterschiede liegen in den Standards zur Dauerhaftigkeit (RabbitMQ Quorum Queues replizieren und schreiben per fsync, bevor sie bestätigen; Kafka repliziert, führt aber standardmäßig kein fsync aus), in der Kontrolle pro Nachricht (TTL, Prioritäten, Dead-Letter-Routing und Verzögerungen gibt es in RabbitMQ, nicht in Kafka), im brokerseitigen Routing und in der Protokollunterstützung. Die verbleibenden strukturellen Vorteile von Kafka sind Tiered Storage, Log Compaction und ein weitaus größeres Stream-Processing-Ökosystem.
Warum RabbitMQ statt Kafka einsetzen?
Wählen Sie RabbitMQ, wenn einzelne Nachrichten als eigenständige Arbeitseinheiten zählen: wenn Sie TTL pro Nachricht, strikte Prioritätsstufen, Dead-Letter-Routing oder verzögerte Retries benötigen; wenn Sie brokerseitiges Routing brauchen, damit Publisher die Consumer-Topologie nicht kennen müssen; wenn Sie mehr als ein Protokoll benötigen (AMQP 1.0, AMQP 0-9-1, MQTT, STOMP, JMS); wenn Sie Tausende logische Queues statt einer Handvoll großer Topics brauchen; oder wenn der Verlust einer bestätigten Nachricht durch einen Stromausfall inakzeptabel ist und Sie Dauerhaftigkeit per fsync-before-confirm benötigen.
Arbeitet RabbitMQ nach dem Push- oder dem Pull-Modell?
Classic und Quorum Queues in RabbitMQ arbeiten Push-basiert: Der Broker stellt Nachrichten bis zu einem Prefetch-Limit an Consumer zu – daher die niedrige Latenz bei Task Queues. Kafka arbeitet Pull-basiert: Consumer pollen Partitionen und verwalten ihren Offset selbst. RabbitMQ Streams sind die Ausnahme und verhalten sich eher wie Kafka: Consumer lesen ab einem gewählten Offset. Das Push-Modell ist der Grund, warum RabbitMQ bei Background Jobs meist eine niedrigere End-to-End-Latenz zeigt, und das Pull-Modell der Grund, warum Kafka Replay und Reprocessing natürlicher handhabt.
Wo liegt die Durchsatzgrenze von RabbitMQ im Vergleich zu Kafka?
Entscheidend ist der Wert pro Ziel, nicht der Gesamtwert. Eine einzelne Quorum Queue mit Replikation und fsync liegt bei etwa 80.000 Nachrichten pro Sekunde, Classic Queues etwas darüber, und RabbitMQ Streams erreichen mehrere Millionen – vergleichbar mit Kafka, weil sich die Streaming-Designs angenähert haben. Der Gesamtdurchsatz des Clusters skaliert über viele Queues problemlos. Die Einschränkung: Eine Quorum Queue ist nicht geshardet. Ein einzelner extrem heißer Fluss lässt sich daher nicht so auf Knoten aufteilen, wie sich ein Kafka-Topic auf Partitionen verteilt.
Kann man von Kafka zu RabbitMQ migrieren?
Ja, aber es ist kein Drop-in-Ersatz – und wer etwas anderes behauptet, hat noch keine solche Migration durchgeführt. Das Consumer-Group- und Offset-Modell von Kafka, die partitionsbasierte Reihenfolge und jede Kafka-Streams-Topologie haben keine eins-zu-eins-Entsprechung. Anwendungen, die auf Read-Process-Write-Schleifen oder Reihenfolge auf Partitionsebene aufbauen, müssen überarbeitet statt umkonfiguriert werden. Erfolgreich sind Migrationen, die als Architekturänderung geplant werden und deren Messaging-Topologie rund um Exchanges und Queues neu entworfen wird.
Lassen sich Kafka und RabbitMQ gemeinsam einsetzen?
Häufig – und oft ist das die richtige Antwort. Ein verbreitetes Produktionsmuster nutzt RabbitMQ für operatives Messaging – Task Queues, Request/Reply, Isolation pro Mandant, Geräteanbindung – und Kafka für die Analytics- und Event-History-Schicht, in der Tiered Storage, Log Compaction und das Stream-Processing-Ökosystem ihren Nutzen entfalten. Beide lassen sich in jede Richtung unkompliziert verbinden. Beide zu betreiben ist eine legitime Architektur, kein Zeichen von Entscheidungsschwäche.
Was ist einfacher zu betreiben, Kafka oder RabbitMQ?
RabbitMQ lässt sich in der Regel einfacher aufsetzen und überwachen: Management-UI und Prometheus-Endpoint sind integriert, Windows wird unterstützt, und die Erlang-Runtime isoliert Fehler, sodass eine fehlerhafte Queue oder Verbindung allein abstürzt, statt einen Knoten mitzureißen. Kafka benötigt einen JMX-Exporter für Metriken und eine Drittanbieter- oder kommerzielle UI, und Windows wird praktisch nicht unterstützt. Der Betrieb von Kafka hat sich mit KRaft, das die Abhängigkeit von ZooKeeper beseitigt, deutlich verbessert. Schwieriger ist RabbitMQ beim elastischen Umskalieren: Die Replikat-Mitgliedschaft von Quorum Queues beim Wachstum eines Clusters anzupassen, erfordert mehr Planung, als Kafka-Broker hinzuzufügen und Partitionen per Rebalancing neu zu verteilen.
Was skaliert besser, RabbitMQ oder Kafka?
Keines gewinnt eindeutig. Kafka skaliert wenige geordnete Streams mit sehr hohem Volumen besser, weil der Durchsatz eines Topics die Summe seiner Partitionen ist und sich Partitionen über Broker verteilen. RabbitMQ skaliert viele moderate Flüsse besser, weil jede Queue ihren Leader auf einem anderen Knoten haben kann und der Broker ohne Änderungen am Producer zwischen ihnen routet. Beide übertreffen, was die meisten Enterprise-Workloads benötigen. In unseren Projekten ist die Grenze fast immer eine heiße Queue oder ein überdimensioniertes Topic – also ein Designproblem. Das Design zu korrigieren kostet weit weniger als ein Broker-Wechsel.
Wie skaliert man RabbitMQ horizontal?
Fügen Sie Knoten hinzu und geben Sie ihnen dann Arbeit, denn bestehende Queues migrieren nicht von selbst. Verteilen Sie die Queues so, dass jeder Knoten seinen Anteil als Leader übernimmt, nutzen Sie den Consistent-Hash-Exchange, um einen heißen klassischen Workload auf Queues zu sharden, und setzen Sie Super Streams ein, wenn Sie partitionierte, wiederabspielbare Logs brauchen. Erweitern Sie die Mitgliedschaft von Quorum Queues gezielt auf neue Knoten und verteilen Sie die Leader anschließend neu. Halten Sie Verbindungen und Channels pro Knoten durch clientseitiges Pooling im Rahmen. Consumer skalieren Sie, indem Sie einer Queue weitere Competing Consumers mit sinnvollem Prefetch hinzufügen. Knotenzahlen und Replikationsfaktoren behandelt unsere FAQ zu HA und Cluster-Dimensionierung.
Steht ein Wechsel an, finden Sie Pattern-Mapping, Tools und die Kosten des Parallelbetriebs in Migration von RabbitMQ zu Kafka: Tools, Kosten und wann Sie bleiben sollten. Fragen Sie sich, ob eine andere Streaming-Engine besser passt, lesen Sie Alternativen zu Kafka: Pulsar, Redpanda, RabbitMQ Streams, NATS.
Was ist der Unterschied zwischen einem RabbitMQ-Exchange und einem Kafka-Topic?
Ein Exchange ist eine Routing-Komponente: Publisher senden an ihn, und Bindings legen fest, welche Queues eine Kopie erhalten. Ein Kafka-Topic ist eine Speicherkomponente: Der Producer entscheidet vor dem Senden, in welche Partition er schreibt. Praktisch bedeutet das: Die Routing-Logik liegt bei RabbitMQ auf dem Broker und bei Kafka in Ihrem Anwendungscode. Wohin Nachrichten fließen, ändern Sie im einen Fall per Binding zur Laufzeit, im anderen per Codeänderung und erneutem Deployment.
Unterstützt Kafka AMQP oder MQTT?
Nicht nativ. Kafka spricht das Kafka-Protokoll – den De-facto-Standard für Streaming, aber auch das einzige Protokoll, das Kafka bedient. Um MQTT-Geräte oder JMS-Anwendungen an Kafka anzubinden, brauchen Sie Bridges oder Connectors als zusätzliche Infrastruktur. RabbitMQ bedient AMQP 1.0, AMQP 0-9-1, MQTT, STOMP, JMS und ein eigenes Stream-Protokoll auf einem Cluster, mit dokumentierter Konvertierung, wenn eine Nachricht über ein Protokoll veröffentlicht und über ein anderes konsumiert wird.
Wie bildet man in Kafka ein Wildcard-Subject wie orders.# ab?
Entweder legen Sie pro Subject ein eigenes physisches Topic an und lassen Consumer per Muster abonnieren, oder Sie veröffentlichen alles in ein Topic und filtern clientseitig – und ziehen Daten über das Netzwerk, nur um den Großteil zu verwerfen. In RabbitMQ erledigt das ein Topic Exchange mit einem einzigen Binding orders.# direkt auf dem Broker, und ein neues Subject erfordert keinerlei Änderung am Producer.
Lässt sich das RabbitMQ-Routing ohne erneutes Deployment ändern, und kostet brokerseitiges Routing Performance?
Zur ersten Frage: ja. Bindings sind Laufzeitkonfiguration und lassen sich im laufenden Betrieb über die Management-UI, die HTTP-API oder die CLI ändern, ohne dass Publisher davon etwas merken. Brokerseitiges Routing kostet etwas Broker-CPU, spart aber Netzwerkbandbreite und Arbeit auf Client-Seite, weil Consumer nur erhalten, was sie angefordert haben, statt alles. Aus demselben Grund unterstützt RabbitMQ auch Bloom-Filter auf Streams. Die Rechnung kippt erst, wenn nahezu jeder Consumer nahezu jede Nachricht benötigt.
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.
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

