BlogKafka

RabbitMQ ou Kafka : ce qui fait vraiment la différence en production

Scott Sternloff

Par Scott Sternloff, Architecte d’entreprise senior

LinkedIn · Mis à jour le · Lecture : 29 min

RabbitMQ ou Kafka : ce qui fait vraiment la différence en production
Sur cette page

RabbitMQ route les messages sur le broker et écrit les quorum queues sur disque (fsync) avant de confirmer ; Kafka route dans le producteur et répartit un topic sur plusieurs partitions. Choisissez RabbitMQ pour les files de tâches, le contrôle par message et la diversité des protocoles. Choisissez Kafka pour un flux unique à très fort volume, une rétention longue et le traitement de flux. Les deux proposent désormais des streams et une consommation de type file d'attente.

Tableau comparatif RabbitMQ vs Kafka

RabbitMQApache Kafka
Où se fait le routageSur le broker : exchanges et bindings, modifiables à chaudDans le producteur, qui choisit la partition ; tout changement passe par une livraison de code
Durabilité par défautLes quorum queues répliquent et font un fsync sur disque avant de confirmer ; les streams répliquent sans fsyncRéplication uniquement ; pas de fsync avant acquittement par défaut
Contrôle par messageTTL, priorités strictes, routage dead-letter, délaisAucun par message ; les share groups ajoutent des lectures de type file d'attente, sans ces fonctions
Modèle de livraisonPush jusqu'à une limite de prefetch ; les streams lisent à partir d'un offsetPull ; le consommateur suit son propre offset
Débit par destinationEnviron 80 000 msg/s pour une quorum queue ; les streams atteignent plusieurs millionsÉvolue avec les partitions ; plusieurs millions de msg/s par topic sur un matériel comparable
Unité de montée en chargeLa file d'attente (sans sharding) ; les super streams partitionnent un journalLa partition
Rétention et rejeuRejeu via les streams ; rétention limitée par le disque localRejeu, stockage hiérarchisé (tiered storage) et compaction du journal
ProtocolesAMQP 1.0, AMQP 0-9-1, MQTT, STOMP, JMS et un protocole streamProtocole Kafka uniquement
Traitement de fluxConsommateurs et clients à développer vous-mêmeKafka Streams, Connect et un vaste écosystème
ExploitationInterface de gestion et endpoint Prometheus intégrés ; le redimensionnement élastique demande plus de préparationExporteur JMX et interface séparée ; ajouter des brokers et rééquilibrer les partitions est une opération courante

Les chiffres de débit et de durabilité proviennent de la comparaison RabbitMQ et Kafka publiée par l'équipe principale (core team) de RabbitMQ ; les share groups de Kafka sont prêts pour la production depuis Kafka 4.2. Les sections ci-dessous détaillent chaque ligne. Pour le type de file d'attente journal de RabbitMQ en lui-même, consultez RabbitMQ Streams : performances, optimisation et comparaison avec Kafka.

La comparaison sur laquelle s'appuient la plupart des équipes a une bonne dizaine d'années de retard. « Kafka pour le streaming, RabbitMQ pour les files » décrivait fidèlement le monde de 2015, et très mal celui de 2026. RabbitMQ dispose des streams depuis la 3.9. Kafka a ajouté les share groups, qui lui offrent une consommation de type file d'attente. Les deux systèmes couvrent désormais les deux usages : la décision ne porte plus sur ce que chacun sait faire, mais sur ce que chacun fait bien sous charge, et ce qu'il vous coûte en exploitation.

L'équipe principale (core team) de RabbitMQ a récemment publié une comparaison technique de RabbitMQ et Kafka vraiment excellente : c'est la meilleure référence fonctionnelle sur le sujet. Cet article ne la remplace pas. Il en est l'autre moitié : ce que nous constatons lorsque c'est nous qui exploitons ces systèmes en production pour nos clients, y compris là où RabbitMQ perd réellement, ce que la documentation officielle, on le comprend, ne va pas mettre en avant.

AceMQ assure le support de RabbitMQ comme d'Apache Kafka en production pour des clients grands comptes. Cela nous donne un point de vue rare : nous n'avons aucun intérêt à prétendre que l'un ou l'autre broker de messages est la bonne réponse universelle, puisqu'on nous appelle dans les deux cas.

Pourquoi l'ancien partage « Kafka pour le streaming, RabbitMQ pour les files » n'est plus vrai

Le partage d'origine était réel. Kafka a été conçu comme un commit log distribué, une plateforme de streaming d'événements pour des pipelines de données temps réel à gros volume, où le flux de données durable est l'abstraction principale. RabbitMQ a été conçu comme un broker de messages AMQP chargé de router des unités de travail distinctes entre applications. Choisir entre ces deux systèmes de messagerie revenait alors à se demander quelle forme avait votre problème.

Deux évolutions ont fait tomber cette distinction. Les streams de RabbitMQ sont arrivés sous la forme d'un log persistant, rejouable, en ajout seul, que les consommateurs lisent à partir d'un offset : la primitive même sur laquelle Kafka est bâti. Et les share groups de Kafka sont arrivés pour permettre à plusieurs consommateurs de lire un topic sans attribution exclusive des partitions, ce qui correspond exactement à ce que l'on entend lorsqu'on dit vouloir une file d'attente.

Sur le papier, les deux cases sont donc cochées. Le piège est de croire que cocher la case signifie la parité. Un stream RabbitMQ n'est pas un topic Kafka au rabais et les share groups de Kafka ne sont pas une file RabbitMQ au rabais, mais aucun des deux ne remplace purement et simplement ce qu'il imite, et c'est précisément dans ces écarts que naissent les incidents de production.

Schémas d'architecture côte à côte : à gauche, un éditeur RabbitMQ publie vers un exchange, puis vers une quorum queue ou un stream ; à droite, un producteur Kafka écrit dans un topic dont les partitions sont consommées par un consumer group ou un share group

Là où Kafka et RabbitMQ se rejoignent désormais vraiment

Côté streaming, les deux architectures ont convergé de façon frappante, et RabbitMQ ne cache pas avoir repris des choix de conception éprouvés. Les deux systèmes traitent les messages par lots comme unité de travail. Les deux utilisent un format binaire unique du producteur au consommateur en passant par le disque, sans aucun réencodage intermédiaire. Les deux font des lectures zero-copy via sendfile. Les deux s'appuient sur le page cache du système d'exploitation plutôt que de garder les messages dans le heap applicatif. Les deux prennent en charge la déduplication côté éditeur. Les deux utilisent désormais Raft pour les métadonnées du cluster : KRaft dans Kafka, Khepri dans RabbitMQ.

Conséquence pratique : le débit en streaming n'est plus un critère de différenciation significatif. Les streams de RabbitMQ comme les topics Kafka atteignent plusieurs millions de messages par seconde sur un matériel comparable. Si l'on vous conseille de choisir Kafka plutôt que RabbitMQ parce que RabbitMQ ne tiendrait pas le volume, on vous cite un benchmark issu d'une version retirée depuis de nombreuses années.

Cela change la façon de lire les comparaisons plus anciennes. La plupart des contenus « Kafka vs RabbitMQ » qui circulent encore ont été écrits avant l'existence des streams : leurs conclusions sur les performances étaient justes à l'époque, et elles sont fausses aujourd'hui.

La différence de durabilité que la plupart des comparaisons passent sous silence

C'est la différence technique la plus lourde de conséquences entre les deux systèmes, et elle n'est presque jamais abordée dans les articles comparatifs généralistes.

Par défaut, Kafka s'appuie uniquement sur la réplication. Lorsqu'un broker acquitte votre message, celui-ci se trouve dans le page cache de plusieurs brokers ; il n'a pas forcément été écrit sur disque. La réplication entre nœuds est un mécanisme solide de réduction des risques, et elle couvre le cas de panne courant qu'est la perte d'une machine. Ce qu'elle ne couvre pas, ce sont les pannes corrélées. Si vos zones de disponibilité partagent la même alimentation électrique, ou si vous êtes on-premise dans un seul site, une coupure de courant peut emporter des messages déjà acquittés.

Les quorum queues de RabbitMQ répliquent et font un fsync sur disque avant de confirmer à l'éditeur. Le message est durablement écrit sur disque sur un quorum de nœuds avant que votre application ne soit informée de son acceptation. C'est une garantie nettement plus forte et, pour les paiements, les commandes et tout ce qui doit laisser une trace réglementaire, c'est souvent le facteur décisif.

La nuance à bien comprendre : les streams de RabbitMQ font le même compromis que Kafka. Ils s'appuient sur la réplication et le page cache, sans fsync avant confirmation. Il ne s'agit donc pas de dire « RabbitMQ est plus sûr que Kafka », mais que RabbitMQ vous laisse choisir destination par destination. Faites passer les messages que vous ne pouvez pas perdre par une quorum queue, et la télémétrie à gros volume par un stream, dans le même cluster.

Si RabbitMQ peut se le permettre, c'est pour une raison d'architecture. Dans Kafka, le fsync coûte cher parce qu'il s'effectue partition par partition. Dans RabbitMQ, les quorum queues partagent un write-ahead log : le coût d'un flush est donc amorti sur de nombreuses files au lieu d'être payé séparément par chacune. C'est ce qui permet d'avoir à la fois de nombreuses files, la réplication avec fsync et du débit, trois propriétés entre lesquelles Kafka vous oblige généralement à n'en choisir que deux.

Matrice comparant les topics Kafka, les streams RabbitMQ et les quorum queues RabbitMQ sur la réplication, le fsync avant confirmation et la résistance à une coupure de courant sur tout le site

Là où RabbitMQ l'emporte : contrôle par message et routage côté broker

La différence philosophique la plus profonde porte sur ce qu'est un message. Dans RabbitMQ, un message est une unité de travail indépendante, avec son propre cycle de vie. Dans Kafka, un message est une position fixe dans un log partagé, et son sort est lié à celui de ses voisins.

C'est pour cette raison que les quorum queues de RabbitMQ appliquent le consensus Raft jusqu'au niveau du message individuel, y compris l'état de livraison : quel message est attribué à quel consommateur, et combien de crédits ce consommateur détient. Lors d'un basculement de leader, le nouveau leader reprend avec cet état intact. La sémantique de Kafka est plus faible sur ce point : la reprise implique généralement de relivrer un lot, ce qui convient au traitement at-least-once mais ne constitue pas la même garantie.

Concrètement, cela donne une boîte à outils par message sans équivalent dans Kafka :

  • TTL par message : chaque message expire selon son propre calendrier.
  • Niveaux de priorité stricts : le travail urgent passe devant l'arriéré en file au lieu d'attendre derrière.
  • Routage vers une dead-letter queue : les messages en échec sont automatiquement routés vers une destination utile au lieu de bloquer ou de disparaître.
  • Délais et retries différés : du backoff sans ordonnanceur externe.
  • Intercepteurs de messages côté broker : une logique qui s'exécute sur le broker plutôt que dans chaque client.

Les share groups de Kafka offrent une consommation de type file, mais ils n'apportent ni TTL par message, ni priorités, ni routage vers une dead-letter queue, et le blocage en tête de file n'est pas totalement éliminé. Si votre charge de travail est réellement une file de tâches avec des SLA et une gestion des échecs, cet écart suffit à trancher.

Le second avantage de RabbitMQ est le routage et le filtrage côté broker. Les exchanges, les bindings et les files permettent au broker de décider où va un message, et les bindings peuvent être reconfigurés à chaud sans redéployer les éditeurs. Dans Kafka, c'est le producteur qui décide de la partition dans laquelle il écrit : la logique de routage vit donc dans le code applicatif. Un motif de topic comme orders.# correspond à un seul binding dans RabbitMQ ; dans Kafka, c'est soit plusieurs topics physiques, soit un filtrage côté client qui fait transiter des données sur le réseau pour finalement les jeter. Cette différence pèse de plus en plus lourd lorsque vous avez des milliers de sujets logiques plutôt qu'une douzaine.

Ajoutez à cela la prise en charge multiprotocole (AMQP 1.0, AMQP 0-9-1, MQTT, STOMP et JMS sur un même cluster, avec une conversion des en-têtes documentée entre eux) et RabbitMQ couvre les architectures orientées événements où objets connectés, applications Java et microservices ont tous besoin du même broker de messages. Kafka, lui, parle le protocole Kafka.

Routage : où réside la logique, et qui en paie le prix

La conséquence profonde du routage côté broker est organisationnelle. Quand le routage réside dans le broker, modifier un flux de messages est un changement de configuration : ajouter un consommateur à un flux existant revient à déclarer une file d'attente et un binding à chaud, via l'interface de gestion, l'API HTTP ou la CLI, sans impliquer les applications émettrices. Quand le routage réside dans le producteur, comme dans Kafka, modifier un flux de messages est un changement de code : le producteur choisit la partition, donc toute modification de la distribution passe par une pull request, un build et un déploiement.

L'exemple type est le joker. Des commandes sont publiées avec des sujets comme orders.eu.created, orders.us.shipped et orders.apac.cancelled, et un service d'audit a besoin de tous les événements de commande. Dans RabbitMQ, il suffit d'un topic exchange et d'un binding avec la clé orders.#. Quand orders.latam.created commencera à circuler le trimestre prochain, la file d'audit le recevra sans modification du producteur ni redéploiement. Dans Kafka, vous choisissez entre deux options imparfaites : créer un topic physique par sujet et s'abonner par motif, si bien que le nombre de topics croît avec les dimensions de votre activité, ou tout publier dans un topic orders unique et filtrer dans le consommateur, en rapatriant chaque message sur le réseau pour en jeter la plupart. Avec trois sujets, c'est une affaire de goût. Avec trois mille, par client, région ou type d'équipement, c'est ce qui détermine si l'architecture tient.

Comparaison : RabbitMQ traite orders.# avec une seule liaison d’échange topic vers une file, Kafka exige des topics séparés ou un filtrage côté client, et ce qui se passe à l’ajout d’une nouvelle région

RabbitMQ prend aussi en charge les bindings d'exchange à exchange : un fan-out peut ainsi alimenter plusieurs topic exchanges sans que cette structure ne réside dans le code applicatif. Le revers, c'est que le routage côté broker consomme du CPU sur le broker, et une topologie de milliers de bindings en évolution constante représente une charge réelle. Nous avons vu un renouvellement excessif des bindings, combiné à des clés génériques très imbriquées, devenir un vrai problème de performances ; c'est généralement le signe que la hiérarchie des sujets doit être aplatie, et non que le routage est la mauvaise approche.

Le partitionnement côté producteur de Kafka est un compromis délibéré, pas un oubli. Comme le producteur choisit la partition, un topic se répartit sur de nombreux brokers et est consommé en parallèle par un consumer group, et un broker qui ne fait aucun routage a moins de raisons de devenir le goulot d'étranglement. La question est donc de savoir si votre problème relève de nombreux sujets avec des consommateurs sélectifs, où le routage côté broker vaut de l'argent, ou d'un flux énorme consommé largement, où le partitionnement vaut davantage.

Couverture protocolaire : un cluster, de nombreux clients

Comme RabbitMQ route de façon centralisée, il peut accepter un message sur un protocole et le livrer sur un autre. Un même cluster sert AMQP 1.0, AMQP 0-9-1, MQTT, STOMP, JMS et son propre protocole stream, et RabbitMQ documente la conversion des en-têtes lorsqu'un message passe de l'un à l'autre.

Matrice de prise en charge des protocoles par RabbitMQ et Apache Kafka : AMQP 1.0, AMQP 0-9-1, MQTT, STOMP, JMS, protocole stream, protocole Kafka et transports WebSocket

Ce point tranche d'emblée certaines architectures. Des objets connectés en MQTT, des applications Java historiques en JMS et des services modernes en AMQP 1.0 peuvent partager un même cluster RabbitMQ. Kafka ne parle que le protocole Kafka. C'est un bon protocole et le standard de facto du streaming, mais connecter quoi que ce soit d'autre implique d'exploiter des passerelles ou des connecteurs comme une infrastructure distincte à déployer, superviser, sécuriser et maintenir à jour. Pour une architecture nativement Kafka, ce n'est pas un sujet. Pour un parc hétérogène, c'est un coût d'exploitation permanent qui figure rarement dans la première comparaison. Si cette décision relève de l'architecture plutôt que d'un incident en cours, le conseil Kafka et les services RabbitMQ d'AceMQ y affectent un ingénieur senior attitré.

Là où RabbitMQ perd vraiment

C'est la section que la documentation d'un éditeur ne peut pas écrire, et celle qui mérite une double lecture si vous avez une vraie décision à prendre.

Pas de sharding au niveau de la file d'attente

Une quorum queue n'est pas partitionnée. Son plafond de débit se situe aux alentours de 80 000 messages par seconde avec réplication et fsync, et vous ne pouvez pas répartir une file unique sur plusieurs nœuds pour aller plus vite. Le débit global du cluster évolue sans problème : répartissez le travail sur de nombreuses files d'attente et RabbitMQ l'absorbe aisément. Mais un flux extrêmement chaud passant par une seule destination constitue un vrai plafond, et c'est la contrainte que nous devons le plus souvent expliquer à nos clients. Kafka répartit un topic sur plusieurs partitions précisément pour l'éviter, et pour un véritable déluge sur un flux unique, cette architecture l'emporte.

Le contournement est un sharding applicatif — publier sur N files d'attente avec une clé de routage qui répartit la charge — et il fonctionne, mais c'est à vous de résoudre ce problème de conception, le broker ne le fait pas pour vous.

L'élasticité cloud et le redimensionnement demandent plus de préparation

Agrandir un cluster Kafka consiste à ajouter des brokers et à rééquilibrer les partitions. Agrandir un cluster RabbitMQ oblige à réfléchir à la composition des réplicas des quorum queues : quelles files ont des réplicas où, comment les déplacer, et comment le quorum se comporte pendant l'opération. C'est bien défini et sans danger, mais ce n'est pas la montée en charge élastique à laquelle les équipes cloud-native s'attendent par défaut.

Pour situer la topologie réelle : parmi les clusters que nous supportons, trois nœuds constituent la base courante, cinq sont très bien représentés, sept apparaissent à l'occasion, et nous avons croisé un cluster de treize nœuds — conçu pour exécuter horizontalement de nombreux chemins de traitement concurrents, et non pour une raison liée au quorum. La plupart des équipes n'ont pas besoin de dépasser cinq, mais celles qui veulent un vrai redimensionnement élastique doivent savoir que cela se planifie.

Trois capacités que Kafka possède et pas RabbitMQ

  • Stockage hiérarchisé (tiered storage). Kafka peut déporter les anciens segments de journal vers un stockage objet, ce qui rend économique une rétention très longue. RabbitMQ n'a pas d'équivalent aujourd'hui.
  • Compaction du journal. Ne conserver que la dernière valeur par clé est natif dans Kafka. Vous pouvez le construire vous-même sur RabbitMQ, mais c'est vous qui le construisez.
  • L'écosystème de traitement de flux. Kafka Streams, ainsi que l'écosystème de connecteurs et d'analytique qui l'entoure, est nettement plus mature. Si votre équipe fait des jointures stateful, du fenêtrage et des agrégations au cœur de son produit, cet écosystème est une vraie raison de choisir Kafka, et de loin.

Si vos exigences touchent l'une de ces trois capacités, la recommandation honnête est de choisir Kafka, et nous vous le dirons.

Histogramme du débit par destination : une quorum queue RabbitMQ à environ 80 000 messages par seconde, une classic queue un peu au-dessus, les streams RabbitMQ et les topics Kafka à plusieurs millions

Push ou pull, et pourquoi cela se voit dans vos chiffres de latence

Les files classiques et les quorum queues de RabbitMQ utilisent un modèle push : le broker livre aux consommateurs jusqu'à une limite de prefetch, si bien qu'un message arrivant sur une file inactive atteint immédiatement un consommateur. Kafka utilise un modèle pull : les consommateurs interrogent le broker et gèrent leur propre offset.

Pour les tâches de fond et les échanges requête/réponse, le modèle push explique pourquoi RabbitMQ affiche généralement une latence de bout en bout plus faible : aucun intervalle d'interrogation ne s'intercale entre l'arrivée et la livraison. Pour le rejeu, le retraitement et les consommateurs qui doivent parcourir l'historique indépendamment, le modèle pull est plus propre, car l'offset appartient au consommateur au lieu que le broker suive l'état de livraison de chaque consommateur.

Les streams RabbitMQ font exception et se comportent comme Kafka : les consommateurs se rattachent à un offset et lisent vers l'avant, et les données restent disponibles pour le rejeu après consommation. C'est l'idée reçue que nous corrigeons le plus souvent : RabbitMQ ne supprime pas un message dès qu'il est lu si vous utilisez un stream. C'était vrai des files classiques, et cela a façonné toute une génération d'hypothèses.

Migrer de l'un à l'autre est un changement d'architecture, pas une reconfiguration

Les équipes qui envisagent une bascule le sous-estiment généralement, et c'est l'hypothèse la plus coûteuse de toute la comparaison.

Passer de Kafka à RabbitMQ n'a rien de plug-and-play. Les consumer groups, l'ordre basé sur la clé de partition et la gestion des offsets n'ont pas d'équivalent ligne à ligne. Tout ce qui est construit comme une boucle lecture-traitement-écriture sur des partitions, et tout ce qui utilise Kafka Streams, doit être repensé plutôt que reconfiguré. Les migrations réussies sont cadrées dès le départ comme un changement d'architecture, avec une topologie reconstruite autour des exchanges, des bindings et du bon type de file d'attente pour chaque flux.

Le sens de la migration compte aussi, et nous constatons une nette asymétrie :

  • Les équipes qui exploitent déjà RabbitMQ et ont besoin de streaming sont le cas simple. Les streams sont dans le broker qu'elles exploitent déjà, l'équipe connaît l'outillage, et il n'y a pas de seconde plateforme à staffer.
  • Les équipes qui exploitent déjà Kafka et ont besoin d'une vraie sémantique de messagerie sont le cas intéressant. Quand elles examinent de près le coût total, la charge d'exploitation du cluster et ce que vaut réellement pour elles une durabilité avec fsync avant confirmation, RabbitMQ s'impose généralement de lui-même. Quand elles ne vont pas aussi loin, elles finissent par empiler sur Kafka des contournements de plus en plus élaborés pour des problèmes qu'un broker de messages résout nativement.

Si vous êtes dans le second groupe, l'exercice utile n'est pas une check-list de fonctionnalités. C'est de chiffrer ce que vous dépensez aujourd'hui pour faire se comporter Kafka comme une file d'attente.

Une grille de décision qui tient la route

Associer chaque cas d'usage au bon système, en fonction de ce qui détermine réellement le résultat plutôt que des étiquettes de catégorie :

Files de tâches et traitements de fondRabbitMQ — acquittement par message, nouvelles tentatives, dead-lettering
Paiements, commandes, charges des secteurs réglementésRabbitMQ — les quorum queues répliquent et font un fsync avant de confirmer
Priorités et SLA par messageRabbitMQ — aucun équivalent dans Kafka
Requête/réponse entre microservicesRabbitMQ — faible latence, livraison push, direct reply-to
IoT et connectivité des équipementsRabbitMQ — MQTT natif à grande échelle sur le même cluster
Nombreux sujets logiques ou isolation par clientRabbitMQ — routage côté broker, virtual hosts, des milliers de files d'attente peu coûteuses
Streaming d'événements avec rejeuLes deux — les conceptions ont convergé ; prenez celui que vous exploitez déjà
Suivi d'activité web, logs, télémétrieLes deux — le débit est désormais comparable
Débit extrême sur un flux uniqueKafka — le partitionnement divise un topic chaud ; les files d'attente ne se shardent pas
Rétention pluriannuelle sur stockage bon marchéKafka — stockage hiérarchisé (tiered storage) vers un stockage objet
Sémantique « dernière valeur par clé »Kafka — compaction native du journal
Traitement de flux stateful et analytiqueKafka — Kafka Streams et l'écosystème qui l'entoure

Ce tableau ne dit pas « RabbitMQ gagne ». Il dit que RabbitMQ l'emporte sur la sémantique des messages et l'étendue opérationnelle, Kafka sur l'économie du journal et l'écosystème de traitement. Ce sont des questions différentes, et la plupart des équipes savent laquelle elles se posent vraiment une fois le problème présenté ainsi.

Le même partage s'applique lorsque les consommateurs sont des agents IA et des workers LLM plutôt que des services. Notre comparaison RabbitMQ vs Kafka vs NATS pour les agents IA traite ce cas en détail.

Arbre de décision en quatre questions (fonctions par message, durabilité en cas de coupure de courant, stockage hiérarchisé, débit d’un flux unique), chacune menant à RabbitMQ ou à Kafka

Exploiter les deux est une réponse légitime

La formule « RabbitMQ vs Kafka » suppose un vainqueur, et bien des architectures matures n'en ont tout simplement pas. Un schéma que nous voyons fonctionner régulièrement dans les systèmes orientés événements : RabbitMQ porte la messagerie opérationnelle — files de tâches, requête/réponse, connectivité des équipements, isolation par client — tandis que Kafka porte la couche analytique et d'historique d'événements, où le stockage hiérarchisé et le traitement de flux sont rentables. C'est un cas d'usage courant pour exploiter les deux.

Le coût de ce partage est réel : deux plateformes à staffer, superviser, maintenir à jour et sécuriser. Il vaut la peine d'être payé lorsque les deux ensembles d'exigences sont réellement présents, et d'être évité lorsqu'un seul système couvrirait tout. Notre conseil général aux équipes qui partent de zéro : commencez par le broker de messages qui couvre le plus large éventail de vos exigences, et ajoutez le second système quand vous rencontrez un besoin que lui seul sait traiter — ce qui, pour la plupart des charges d'entreprise, revient à commencer par RabbitMQ et à ajouter Kafka si et quand l'économie du journal ou l'écosystème de traitement deviennent la contrainte déterminante.

Si vous pesez cette décision face à une charge réelle plutôt que dans l'abstrait, c'est la conversation que nous avons le plus souvent. AceMQ exploite les deux plateformes en production pour des clients grands comptes — découvrez nos services RabbitMQ et notre support Kafka, ou échangez avec nous sur celui qui convient à votre architecture. Nous vous dirons tout aussi volontiers que la réponse est Kafka.

Deux comparaisons connexes : Kafka ou Pulsar si vous choisissez encore une plateforme de streaming, et passer de Kafka à RabbitMQ si vous avez conclu que le choix n'était pas le bon.

RabbitMQ ou Kafka pour la montée en charge : ce qui passe à l'échelle, et ce qui ne passe pas

« Lequel monte le mieux en charge ? » est la question que nous entendons le plus, et c'est la mauvaise question. Les deux brokers montent en charge, mais selon des axes différents, et ce que vous ajoutez pour gagner en capacité diffère dans chacun. Identifiez la bonne unité, et l'un comme l'autre absorbera plus que ce que la plupart des entreprises y feront jamais transiter.

L'unité de montée en charge. Dans Kafka, l'unité est la partition. Un topic est un ensemble de partitions, chacune étant un journal ordonné avec un leader, et le débit d'un topic est la somme de ses partitions. Ajouter des partitions ajoute du parallélisme, au prix de l'ordre à l'échelle du topic et d'un rééquilibrage pour chaque consumer group qui y est rattaché.

Dans RabbitMQ, l'unité est la file d'attente. Une quorum queue est un groupe Raft avec un leader sur un nœud. Elle est répliquée pour la sécurité, pas shardée pour le débit : une quorum queue unique plafonne donc à ce que le CPU et le disque d'un nœud peuvent fournir pour elle. Les streams et super streams sont la réponse partitionnée : un super stream est un ensemble de partitions de stream ayant la même forme et les mêmes compromis qu'un topic Kafka, comparaison que nous détaillons dans RabbitMQ Streams ou Kafka. Pour les charges classiques qui n'ont pas besoin d'un journal rejouable, le consistent-hash exchange répartit le trafic sur de nombreuses files d'attente selon la clé de routage : c'est ainsi qu'on étale un flux chaud sur plusieurs nœuds sans toucher aux producteurs.

Ce qui évolue linéairement, et ce qui bute sur un mur. Dans RabbitMQ, de nombreuses files d'attente évoluent de façon quasi linéaire dans un cluster, car le leader de chaque file peut se trouver sur un nœud différent. Une file chaude, non. C'est le mur que nous rencontrons le plus souvent : tout passe par une seule file, un nœud saturé, le reste du cluster inactif. La solution relève de la conception, pas du matériel.

Dans Kafka, le débit évolue avec le nombre de partitions, mais les consommateurs ne peuvent pas aller au-delà. Un consumer group comptant plus de membres que de partitions laisse les surnuméraires inactifs, et un très grand nombre de partitions par broker allonge le temps d'élection de leader, augmente le nombre de descripteurs de fichiers ouverts et le temps de récupération après redémarrage. Les partitions ne coûtent rien, jusqu'au jour où elles coûtent.

Les deux ont des limites par nœud sans rapport avec le débit de messages. RabbitMQ comptabilise connexions et canaux par nœud, et des milliers de clients bavards ouvrant chacun plusieurs canaux épuiseront la mémoire et le temps d'ordonnancement bien avant que le débit ne pose problème. La réplication Raft des quorum queues coûte un aller-retour réseau et une écriture disque sur une majorité de réplicas par lot : une quorum queue est donc plus lente qu'une file classique par conception, et cinq réplicas sont plus lents que trois. Le choix entre les deux pour une charge donnée est traité dans files classiques ou quorum queues.

  • Montée en charge horizontale des brokers. Ajouter un broker Kafka ne change rien en soi. Vous devez lui réaffecter des partitions, et la réaffectation copie les données sur le réseau pendant que le cluster continue de servir. Ajouter un nœud RabbitMQ ne change rien en soi non plus. Les files existantes ne bougent pas ; leurs leaders restent là où elles ont été déclarées. Les nouvelles files peuvent être placées sur le nouveau nœud, la composition des quorum queues peut être étendue pour l'inclure et les leaders rééquilibrés, mais rien de tout cela n'est automatique. Les deux exigent un opérateur avec un plan, et nous préférons que ce plan existe avant la cellule de crise.
  • Montée en charge des consommateurs. RabbitMQ utilise des consommateurs concurrents : rattachez plus de consommateurs à une file et le broker répartit les livraisons entre eux, dans la limite du prefetch. Ni rééquilibrage, ni pause, ni protocole de coordination. C'est pourquoi RabbitMQ gère si bien les pools de workers à charge irrégulière. Kafka fait monter les consommateurs en charge via le rééquilibrage du consumer group, qui redistribue les partitions et interrompt brièvement la consommation du groupe. Le rééquilibrage coopératif atténue cet effet, mais le plafond reste le nombre de partitions. Le single active consumer de RabbitMQ garantit un ordre strict sur une file au détriment du parallélisme, soit le même compromis que Kafka par partition.
  • Coût d'exploitation. Dans Kafka, le coût de la montée en charge se manifeste dans la planification des partitions, la réaffectation et l'outillage de suivi du consumer lag. Dans RabbitMQ, dans le placement des files, l'hygiène des connexions et les seuils mémoire. Aucun n'est gratuit. Le dimensionnement de l'un ou l'autre cluster est un sujet à part entière, traité dans notre FAQ haute disponibilité et dimensionnement du cluster ; nous ne le répéterons pas ici.
  • Verdict. Kafka fait mieux monter en charge un petit nombre de flux ordonnés à très fort volume. RabbitMQ fait mieux monter en charge un grand nombre de flux modérés avec routage. Les deux dépassent largement les besoins de la plupart des charges d'entreprise. Dans nos missions, le plafond atteint par un client est presque toujours un plafond de conception — une file chaude ou un topic géant — et non celui du broker. Nous exploitons les deux en production pour des clients grands comptes, et la solution consiste généralement à repartitionner la charge plutôt qu'à changer de broker. Découvrez notre conseil RabbitMQ et notre conseil Kafka.

Questions fréquentes

Quelle est la vraie différence entre RabbitMQ et Kafka en 2026 ?

La réponse honnête n'est plus « Kafka pour le streaming, RabbitMQ pour les files ». RabbitMQ dispose des streams depuis la 3.9, et Kafka a ajouté les share groups pour une consommation de type file d'attente. Les deux systèmes couvrent désormais les deux usages. Les vraies différences portent sur la durabilité par défaut (les quorum queues RabbitMQ répliquent et font un fsync avant de confirmer ; Kafka réplique mais ne fait pas de fsync par défaut), le contrôle par message (TTL, priorités, routage dead-letter et délais existent dans RabbitMQ, pas dans Kafka), le routage côté broker et la prise en charge des protocoles. Les avantages structurels qui restent à Kafka sont le stockage hiérarchisé (tiered storage), la compaction du journal et un écosystème de traitement de flux bien plus vaste.

Pourquoi choisir RabbitMQ plutôt que Kafka ?

Choisissez RabbitMQ lorsque chaque message compte comme une unité de travail indépendante : lorsque vous avez besoin de TTL par message, de niveaux de priorité stricts, de routage dead-letter ou de nouvelles tentatives différées ; lorsque vous avez besoin d'un routage côté broker pour que les éditeurs n'aient pas à connaître la topologie des consommateurs ; lorsque vous avez besoin de plusieurs protocoles (AMQP 1.0, AMQP 0-9-1, MQTT, STOMP, JMS) ; lorsque vous avez besoin de milliers de files d'attente logiques plutôt que de quelques gros topics ; ou lorsque perdre un message acquitté lors d'une coupure de courant est inacceptable et qu'il vous faut une durabilité avec fsync avant confirmation.

RabbitMQ fonctionne-t-il en mode push ou en mode pull ?

Les files classiques et les quorum queues de RabbitMQ fonctionnent en push : le broker livre les messages aux consommateurs jusqu'à une limite de prefetch, ce qui lui confère une faible latence sur les files de tâches. Kafka fonctionne en pull : les consommateurs interrogent les partitions et suivent leur propre offset. Les streams RabbitMQ font exception et se comportent davantage comme Kafka, les consommateurs lisant à partir d'un offset choisi. Le modèle push explique pourquoi RabbitMQ affiche généralement une latence de bout en bout plus faible pour les tâches de fond, et le modèle pull pourquoi Kafka gère plus naturellement le rejeu et le retraitement.

Quel est le plafond de débit de RabbitMQ par rapport à Kafka ?

Le chiffre qui compte est celui par destination, pas le débit global. Une quorum queue unique avec réplication et fsync se situe aux alentours de 80 000 messages par seconde, les files classiques un peu au-dessus, et les streams RabbitMQ atteignent plusieurs millions — comparable à Kafka, car les conceptions de streaming ont convergé. Le débit global du cluster évolue sans problème sur de nombreuses files d'attente. La contrainte : une quorum queue n'est pas shardée, donc un flux unique extrêmement chaud ne peut pas être réparti sur plusieurs nœuds comme un topic Kafka l'est sur ses partitions.

Peut-on migrer de Kafka vers RabbitMQ ?

Oui, mais ce n'est pas un remplacement direct, et quiconque prétend le contraire n'en a jamais fait. Le modèle consumer group et offset de Kafka, l'ordre basé sur la clé de partition et toute topologie Kafka Streams n'ont pas d'équivalent ligne à ligne. Les applications construites autour de boucles lecture-traitement-écriture ou d'un ordre au niveau de la partition doivent être retravaillées, pas reconfigurées. Les migrations réussies sont celles cadrées comme un changement d'architecture, avec une topologie de messagerie repensée autour des exchanges et des files d'attente.

Kafka et RabbitMQ peuvent-ils fonctionner ensemble ?

Souvent, et c'est fréquemment la bonne réponse. Un schéma de production courant utilise RabbitMQ pour la messagerie opérationnelle — files de tâches, requête/réponse, isolation par client, connectivité des équipements — et Kafka pour la couche analytique et d'historique d'événements, où le stockage hiérarchisé, la compaction du journal et l'écosystème de traitement de flux sont rentables. Relier les deux est simple, dans un sens comme dans l'autre. Exploiter les deux est une architecture légitime, pas un renoncement à choisir.

Lequel est le plus simple à exploiter, Kafka ou RabbitMQ ?

RabbitMQ est généralement plus simple à mettre en place et à superviser : une interface de gestion et un endpoint Prometheus sont fournis d'origine, Windows est pris en charge, et le runtime Erlang isole les pannes, de sorte qu'une file ou une connexion défaillante plante seule sans entraîner le nœud. Kafka nécessite un exporteur JMX pour les métriques et une interface tierce ou commerciale, et Windows n'est pas réellement pris en charge. L'exploitation de Kafka s'est nettement améliorée avec KRaft, qui supprime la dépendance à ZooKeeper. RabbitMQ est plus exigeant sur le redimensionnement élastique : faire évoluer la composition des réplicas des quorum queues lorsqu'un cluster grandit demande plus de préparation qu'ajouter des brokers Kafka et rééquilibrer les partitions.

Lequel monte le mieux en charge, RabbitMQ ou Kafka ?

Aucun ne l'emporte nettement. Kafka fait mieux monter en charge quelques flux ordonnés à très fort volume, car le débit d'un topic est la somme de ses partitions et que celles-ci se répartissent sur les brokers. RabbitMQ fait mieux monter en charge de nombreux flux modérés, car chaque file peut avoir son leader sur un nœud différent et le broker route entre elles sans modification des producteurs. Les deux dépassent les besoins de la plupart des charges d'entreprise. Dans nos missions, la limite est presque toujours une file chaude ou un topic surdimensionné, c'est-à-dire un problème de conception, et corriger la conception coûte bien moins cher que changer de broker.

Comment faire monter RabbitMQ en charge horizontalement ?

Ajoutez des nœuds, puis donnez-leur du travail, car les files existantes ne migrent pas d'elles-mêmes. Répartissez les files pour que chaque nœud porte sa part de leaders, utilisez le consistent-hash exchange pour sharder une charge classique chaude sur plusieurs files d'attente, et utilisez les super streams lorsque vous avez besoin de journaux partitionnés et rejouables. Étendez délibérément la composition des quorum queues aux nouveaux nœuds, puis rééquilibrez les leaders. Maîtrisez le nombre de connexions et de canaux par nœud grâce au pooling côté client. Les consommateurs montent en charge en ajoutant des consommateurs concurrents sur une file, avec un prefetch raisonnable. Le nombre de nœuds et les facteurs de réplication sont traités dans notre FAQ haute disponibilité et dimensionnement du cluster.

Si la réponse est une migration, la correspondance des patterns, les outils et le coût d'exploitation en parallèle sont détaillés dans Migration de RabbitMQ vers Kafka : outils, coût et quand rester. Si la question est de savoir si un autre moteur de streaming conviendrait mieux, consultez Alternatives à Kafka : Pulsar, Redpanda, RabbitMQ Streams, NATS.

Quelle différence entre un exchange RabbitMQ et un topic Kafka ?

Un exchange est un composant de routage : les éditeurs lui envoient les messages, et les bindings déterminent quelles files d'attente en reçoivent une copie. Un topic Kafka est un composant de stockage : le producteur choisit la partition dans laquelle écrire avant l'envoi. Conséquence pratique : la logique de routage réside sur le broker dans RabbitMQ et dans le code applicatif dans Kafka. Modifier la destination des messages se résume donc à un changement de binding à chaud dans l'un, et à une modification de code suivie d'un redéploiement dans l'autre.

Kafka prend-il en charge AMQP ou MQTT ?

Pas nativement. Kafka parle le protocole Kafka, standard de facto du streaming, mais c'est le seul protocole qu'il sert. Connecter des équipements MQTT ou des applications JMS à Kafka implique d'exploiter des passerelles ou des connecteurs comme infrastructure supplémentaire. RabbitMQ sert AMQP 1.0, AMQP 0-9-1, MQTT, STOMP, JMS et son propre protocole stream sur un même cluster, avec une conversion documentée lorsqu'un message est publié sur un protocole et consommé sur un autre.

Comment gérer un sujet générique comme orders.# dans Kafka ?

Soit vous créez un topic physique distinct par sujet et les consommateurs s'abonnent à un motif, soit vous publiez tout dans un seul topic et filtrez côté client, en rapatriant les données sur le réseau pour en jeter la majeure partie. Dans RabbitMQ, un topic exchange avec un unique binding orders.# s'en charge sur le broker, et l'ajout d'un nouveau sujet ne nécessite aucune modification côté producteur.

Peut-on modifier le routage RabbitMQ sans redéployer, et le routage côté broker pénalise-t-il les performances ?

Oui pour la première question : les bindings relèvent de la configuration d'exécution, modifiable via l'interface de gestion, l'API HTTP ou la CLI pendant que le système tourne, sans que les éditeurs ne s'en aperçoivent. Le routage côté broker consomme effectivement un peu de CPU sur le broker, mais il économise de la bande passante réseau et du travail côté client, car les consommateurs reçoivent ce qu'ils ont demandé plutôt que tout. RabbitMQ prend aussi en charge les filtres de Bloom sur les streams pour la même raison. Le compromis ne s'inverse que lorsque presque tous les consommateurs veulent presque tous les messages.

Scott Sternloff

Auteur

Scott SternloffArchitecte d’entreprise senior

Architecte d’entreprise senior chez AceMQ. Il signe ici les contenus techniques : architecture RabbitMQ, Kafka et Redis, clustering et migrations.

Parler à un ingénieur

Besoin d’un coup de main sur Kafka ?

Des ingénieurs seniors qui l’exploitent en production. Demandez un devis ou une consultation gratuite, sans argumentaire commercial.

Consultation gratuite

Un regard expert sur votre cluster Kafka

Que vous deviez résoudre un incident de production, planifier une migration ou obtenir un second avis sur votre architecture, notre équipe est prête. Pas d’argumentaire commercial, seulement des réponses.

Nous écrire