# Exchanges, files d'attente et bindings RabbitMQ pour les microservices
Pour des microservices, les exchanges, files d'attente et bindings RabbitMQ forment une seule unité de conception : le type d'exchange route les messages, la file d'attente les conserve pour un consumer group, et le binding détermine quels messages atteignent quelle file. Si vous vous trompez de type d'exchange, soit vous diffusez des messages vers des services qui ne devraient jamais les voir, soit vous perdez silencieusement ceux qui auraient dû aller ailleurs. Ce guide vous donne les règles de décision, une convention de clé de routage et un exemple concret.
Choisir le type d'exchange selon la forme de l'ensemble des consommateurs, pas par préférence
La question qui tranche le type d'exchange : combien de consumer groups distincts ont besoin de ce message, et ont-ils besoin du même sous-ensemble ? Les habitudes de l'équipe et ce qu'utilisait le dernier projet sont secondaires.
Direct exchange : un consumer group par clé de routage exacte. Utilisez-le lorsqu'un message a exactement une destination correcte qui ne changera pas, par exemple payment.charge.requested routé vers une unique file payment-processing. Les direct exchanges deviennent peu pratiques dès qu'un second consumer group a besoin de la même clé.
Fanout exchange : chaque file liée reçoit chaque message, sans évaluation de la clé de routage. Utilisez-le pour de véritables signaux de diffusion : invalidation de cache, « configuration rechargée », coupe-circuit. N'optez pas pour le fanout par défaut simplement parce qu'il est facile à configurer ; un cinquième consumer group ayant besoin d'un sous-ensemble filtré impose un filtrage côté application que vous auriez pu éviter.
Topic exchange : clés de routage hiérarchiques comparées à l'aide de jokers. C'est le choix par défaut en entreprise pour les microservices, car de nouveaux consumer groups peuvent lier leur propre portion du flux d'événements sans que l'émetteur change. En cas de doute, utilisez topic.
Headers exchange : route selon des paires clé/valeur d'en-têtes (x-match: all ou any) au lieu d'une clé de routage. Rare, et pertinent uniquement lorsque la décision de routage ne peut pas s'exprimer sous forme de chaîne séparée par des points, parce qu'elle dépend de combinaisons d'attributs indépendants, comme région ET niveau ET feature flag. Si la logique tient dans a.b.c, utilisez plutôt topic.
Adoptez une convention de clé de routage unique pour tout le système : ... Exemples : order.order.created, order.order.cancelled, payment.charge.succeeded, payment.charge.failed, inventory.reservation.failed, notification.email.queued.
Les consumer groups se lient avec des jokers selon ce modèle. * correspond à exactement un mot ; # à zéro mot ou plus. Un service de facturation qui ne s'intéresse qu'aux résultats de paiement lie payment.charge.*. Un service d'audit qui veut tout le domaine commande lie order.#. Gardez le segment de domaine stable, car le binding de chaque consommateur en dépend.
Pour voir comment le choix de l'exchange s'inscrit dans la conception complète d'un cluster de production, y compris le clustering et la planification de capacité, consultez le guide d'architecture RabbitMQ en production.
Une file d'attente par consumer group, pas par service
L'erreur de topologie la plus courante consiste à créer une file d'attente par service, calquée par habitude sur l'organigramme. Elle cède dès que deux équipes indépendantes ont besoin du même flux d'événements à des rythmes différents, ou qu'un consumer group doit monter en charge sans entraîner l'autre.
La bonne unité est le consumer group, pas le service. Trois instances d'inventory-service lisant la même file, ce sont des consommateurs concurrents : chaque message va à exactement une instance, et RabbitMQ répartit les livraisons en round-robin (sous réserve du prefetch) pour une mise à l'échelle horizontale sans partitionnement au niveau applicatif. Si une seconde préoccupation, logiquement distincte, a besoin des mêmes événements de manière indépendante, comme un sink analytique hébergé dans le même dépôt, il s'agit d'un second consumer group avec sa propre file et son propre binding, pas d'une file partagée.
Deux paramètres déterminent le comportement des consommateurs concurrents sous charge :
Prefetch count : le nombre de messages non acquittés que RabbitMQ confie à un canal consommateur avant d'en suspendre la livraison. Trop élevé, une instance lente accapare des messages que des instances plus rapides pourraient traiter ; trop bas, chaque message paie la latence d'un aller-retour. Consultez prefetch count RabbitMQ pour le dimensionner en fonction du temps de traitement et du nombre de consommateurs.
Type de file d'attente : les quorum queues doivent être le choix par défaut pour tout ce qui compte, et non les files classiques. Elles se répliquent entre les nœuds via Raft, survivent à la défaillance d'un nœud sans perdre les messages acquittés et continuent de bénéficier d'investissements dans RabbitMQ 4.x, alors que la mise en miroir classique est obsolète. Les files classiques restent adaptées aux charges à haut débit, non durables et mono-nœud, où le surcoût de la réplication ne se justifie pas. Consultez files classiques vs quorum queues pour les compromis.
Nommez les files d'après le consumer group et la portion d'événements, pas d'après l'exchange : inventory-service.order-events se lit bien mieux six mois plus tard que q1.
Bindings : un routage many-to-many sans explosion
Un binding est une relation orientée entre un exchange (ou une file) et un motif de routage, many-to-many par conception : un exchange peut avoir de nombreuses files liées avec des motifs différents, et une file peut se lier plusieurs fois au même exchange, ou à plusieurs exchanges.
La sémantique des jokers compte quand la pression monte : * correspond à exactement un mot entre deux points (order.*.created correspond à order.order.created, pas à order.line-item.detail.created) ; # correspond à zéro mot ou plus, y compris aucun (order.# correspond à order.created et à order.order.line-item.updated).
L'explosion des bindings survient lorsque les clés de routage tentent d'exprimer une logique fine d'autorisation ou de feature flags, au lieu de laisser ce filtrage au consommateur ou aux en-têtes. Si un seul consumer group a besoin de plus de quatre ou cinq bindings sur un même exchange pour exprimer son abonnement, revoyez la hiérarchie des clés de routage avant d'en ajouter un sixième.
Les bindings exchange-to-exchange résolvent le routage en couches : un point de publication unique avec des règles de fan-out en aval différentes par domaine. Un topic exchange en entrée (platform.events) se lie à des topic exchanges propres à chaque domaine (orders.events, payments.events, inventory.events), chacun étant lié à ses propres files de consommateurs. Les émetteurs ne connaissent que platform.events ; de nouveaux domaines peuvent être ajoutés en liant un nouvel exchange, sans toucher à chaque émetteur. C'est le mécanisme derrière la plupart des topologies de files d'attente d'intégration d'entreprise : enchaîner en couches la même primitive exchange-binding, plutôt que d'en inventer une nouvelle.
Topologies de dead-lettering et de nouvelles tentatives
Chaque file d'attente de production a besoin d'une politique de dead-letter avant toute autre chose. Sans elle, un message qu'un consommateur ne peut pas traiter soit bloque la file en bouclant indéfiniment, soit est acquitté et silencieusement perdu.
La structure standard :
Un dead-letter exchange (DLX) est un exchange ordinaire défini sur la file principale via x-dead-letter-exchange. Un message rejeté avec requeue=false, expiré par TTL ou au-delà d'une limite de longueur est republié vers le DLX au lieu de disparaître.
Une dead-letter queue (DLQ) se lie à ce DLX et conserve les messages en échec pour inspection, alertes ou rejeu.
La nouvelle tentative basée sur un TTL avec file d'attente temporisée offre une nouvelle tentative différée sans plugin : publiez le message en échec vers une file temporisée avec un TTL fixe et sans consommateur, dont le propre DLX pointe vers l'exchange de traitement d'origine. À l'expiration du TTL, le message repasse par dead-letter dans le traitement normal. Empilez plusieurs files temporisées (retry-5s, retry-30s, retry-5m) pour un backoff.
Limite de livraison par défaut : dans RabbitMQ 4.x, les quorum queues plafonnent les nouvelles livraisons à un delivery-limit de 20 par défaut, via leur suivi intégré des messages empoisonnés. Au-delà, le message part automatiquement en dead-letter. Définissez-la explicitement si une topologie de nouvelles tentatives par files temporisées gère déjà le backoff, afin que les deux mécanismes ne se contrarient pas.
Gestion des messages empoisonnés : les messages qui échouent de façon déterministe (JSON mal formé, schéma impossible à parser) ne doivent pas consommer de budget de nouvelles tentatives. Détectez-les en tête du handler et envoyez-les immédiatement en dead-letter avec requeue=false, en contournant les files de retry.
Cartographier le flux de messages d'un parcours de commande distribué
Voici le pattern appliqué à une vraie application : une commande passée sur une boutique en ligne, qui transite par les services commande, paiement, stock et notification.
Le service commande possède order et publie vers un topic exchange, order.events. Passer une commande publie la clé de routage order.order.created avec l'ID de commande, l'ID client et les lignes de commande. Deux consumer groups se lient à cet exchange : paiement lie order.order.created dans payment-service.order-created, et stock lie la même clé dans inventory-service.order-created. Tous deux agissent indépendamment ; aucun ne connaît l'existence de l'autre.
Paiement traite le débit et publie vers son propre exchange, payment.events, avec payment.charge.succeeded ou payment.charge.failed. Commande lie payment.charge.* dans order-service.payment-outcomes pour mettre à jour l'état de la commande dans les deux cas. Notification lie le même motif dans notification-service.payment-outcomes pour envoyer un e-mail au client en cas d'échec.
Stock, après avoir réservé la marchandise, publie vers inventory.events avec inventory.reservation.succeeded ou inventory.reservation.failed. Commande ne lie que inventory.reservation.failed, puisqu'un succès n'exige aucun changement d'état de la commande. Notification lie la même clé comme déclencheur d'un e-mail de rupture de stock.
Documentez cela comme vous l'expliqueriez à voix haute, pas sous forme de tableau : pour chaque exchange, son type et son domaine ; pour chaque clé de routage, qui publie et qui consomme ; pour chaque file, son propriétaire, son motif de binding et sa politique de dead-letter. Rédigé en prose, ce document reste relisible dans une pull request, ce qu'un diagramme seul ne permet pas.
Pour découvrir ce flux dans un cluster où la documentation s'est écartée de la réalité, trois outils aident : rabbitmqctl list_bindings sur chaque vhost fournit les bindings bruts exchange-to-queue et exchange-to-exchange directement depuis le broker ; l'API HTTP de management (GET /api/exchanges/{vhost}/{name}/bindings/source) fournit les mêmes données en JSON pour des audits scriptés ; et le plugin de traçage des messages (rabbitmq_tracing, ou le firehose exchange) montre le trafic réel, ce qui révèle les bindings qui existent mais ne voient rien passer, ou le trafic qui ne va nulle part. Il a un coût réel, car le traçage publie en interne une copie de chaque message tracé : utilisez-le sur une fenêtre de diagnostic limitée, pas en permanence.
Des patterns orientés événements qui tiennent vraiment en production
Distinguez tôt les événements des commandes. Un événement (« commande créée ») est un fait déjà survenu ; l'émetteur ne se soucie pas de qui réagit, il diffuse donc via un topic exchange à tous les groupes liés. Une commande (« débiter ce client ») a exactement un destinataire prévu ; la router via une topologie de diffusion invite un second service à la traiter par erreur. Les commandes conviennent à un direct exchange ou à une file à consumer group unique ; les événements, à un topic.
Les consommateurs idempotents ne sont pas optionnels. La livraison at-least-once, comportement par défaut de RabbitMQ avec des acquittements manuels, signifie que chaque consommateur finira par voir un doublon, que ce soit une nouvelle livraison après un crash entre le traitement et l'ack, ou une topologie de nouvelles tentatives qui se déclenche après une tentative lente mais réussie. Indexez le traitement sur l'ID du message ou sur une clé métier stable (ID de commande plus type d'événement) et faites en sorte que le handler ne fasse rien en cas de répétition. C'est moins cher à construire dès le départ qu'à ajouter après un double débit en production.
Les garanties d'ordre n'existent qu'au sein d'une seule file d'attente, et uniquement pour un seul consommateur actif qui la lit. Dès qu'une file a des consommateurs concurrents, l'ordre sur l'ensemble de la file n'est plus garanti, car le traitement parallèle peut se terminer dans le désordre. Si une séquence précise doit être préservée (tous les événements d'un même ID de commande, par exemple), utilisez x-single-active-consumer pour qu'un seul consommateur traite pendant que les autres restent en secours à chaud, ou partitionnez selon une clé stable pour que les événements d'une entité arrivent toujours dans la même file.
Pour les changements d'état qui doivent être atomiques avec une publication, ne publiez pas depuis la transaction de base de données. Utilisez le pattern outbox : écrivez l'événement dans une table outbox au sein de la même transaction que le changement d'état, puis relayez de l'outbox vers RabbitMQ via un processus distinct ou un connecteur CDC (capture des changements de données). Cela élimine le problème de double écriture que les topologies « fanout en espérant que tout se passe bien » acceptent sans le dire.
Tournez-vous vers RabbitMQ Streams plutôt qu'une topologie fanout lorsque les consommateurs doivent rejouer l'historique, que le volume est suffisant pour que le surcoût du routage par message compte, ou que plusieurs consumer groups indépendants ont chacun besoin du journal complet à leur propre rythme sans se disputer les messages. Un fanout exchange avec une file par groupe s'en approche à faible volume, mais sans rejeu. Pour choisir entre streams et Kafka sur ce type de charge, consultez RabbitMQ streams vs Kafka.
Les patterns d'intégration d'entreprise dont vous aurez vraiment besoin
Alternate exchange pour les messages non routables : définissez x-alternate-exchange sur tout exchange où une publication pourrait ne correspondre à aucun binding, qu'il s'agisse d'une faute de frappe dans la clé de routage ou d'un consumer group qui s'est délié silencieusement. Sans cela, un message non routable est tout simplement perdu, sauf si l'émetteur a positionné le flag mandatory et surveille le retour : un mode de défaillance silencieux qu'il vaut mieux ne pas découvrir pendant un incident.
Routage par tenant : pour les systèmes multi-tenant, un vhost par tenant (ou par niveau) constitue une frontière d'isolation plus solide que le seul encodage de l'ID du tenant dans la clé de routage. Le sujet est assez vaste pour mériter son propre article sur le multi-tenant par vhost ; concevez le nommage des files et des exchanges de sorte qu'une séparation en vhosts reste un changement de configuration, pas une réécriture.
Requête/réponse avec reply_to : pour le rare appel d'apparence synchrone sur un transport asynchrone, positionnez reply_to sur la requête vers une file écoutée par le demandeur et corrélez les réponses avec correlation_id. Préférez la pseudo-file direct reply-to de RabbitMQ (amq.rabbitmq.reply-to) au provisionnement d'une nouvelle file de réponse par requête, au prix d'un demandeur qui doit rester connecté pendant toute la durée de l'appel.
Anti-patterns à éviter
Une file d'attente par microservice plutôt que par consumer group, ce qui couple silencieusement des préoccupations sans rapport au même flux.
Le fanout utilisé par défaut, faute d'avoir pris une décision sur la clé de routage, plutôt que pour une sémantique de diffusion délibérée.
Aucun dead-letter exchange configuré, si bien qu'un mauvais message bloque la file ou disparaît sans laisser de trace.
Des nouvelles tentatives implémentées sous forme de boucle applicative sleep-and-requeue au lieu de files temporisées basées sur un TTL, ce qui gaspille la capacité des consommateurs et masque l'état des nouvelles tentatives aux opérateurs.
Des clés de routage qui encodent des détails d'implémentation (« service-b-only ») au lieu de faits métier, et qui cassent dès qu'un nouveau consumer group a besoin du même événement.
L'explosion des bindings : une douzaine de bindings quasi identiques par file au lieu d'une hiérarchie de clés de routage exprimée en un ou deux motifs.
Des files classiques choisies par défaut pour des données importantes, alors que les quorum queues sont le choix le plus sûr et que les files classiques exigent une justification précise en termes de débit.
Aucun alternate exchange, si bien que les messages non routables disparaissent au lieu de remonter sous forme de condition pouvant déclencher une alerte.
Publier depuis une transaction de base de données au lieu d'utiliser un outbox, ce qui crée un risque de double écriture entre l'état et les événements.
Considérer l'ordre des messages comme garanti sur une file à consommateurs concurrents, puis déboguer des semaines plus tard un état « impossible » dans le désordre.
Si vous validez une conception de topologie avant sa mise en production, ou si vous déboguez une topologie qui s'est écartée de sa documentation, AceMQ accompagne plus de 160 clients entreprise dans plus de 26 pays avec des objectifs de réponse à partir de 15 minutes, selon le plan, un support de RabbitMQ 3.8.x à 4.x et une ligne directe avec l'équipe principale (core team) de RabbitMQ, en tant que seul partenaire MSP RabbitMQ désigné par Broadcom. Découvrez notre support RabbitMQ ou contactez-nous pour faire auditer une topologie.
Le dead-lettering mérite plus qu'un paragraphe dès qu'une file d'attente porte du chiffre d'affaires. Le traitement complet, y compris les limites de livraison des quorum queues, les boucles de retry sûres et le rejeu depuis une file de stationnement (parking lot), se trouve dans le guide entreprise des dead-letter queues RabbitMQ.
Questions fréquentes
Quel type d'exchange RabbitMQ choisir pour des microservices ?
Par défaut, un topic exchange avec une convention de clé de routage <domain>.<entity>.<event>. Il permet d'ajouter de nouveaux groupes de consommateurs sans modifier le producteur, puisque chacun lie son propre motif. N'utilisez un direct exchange que lorsqu'un message a une seule destination correcte, qui ne changera pas. Réservez le fanout aux véritables signaux diffusés à tous, comme l'invalidation de cache. N'ayez recours aux headers exchanges que lorsque la décision de routage dépend de combinaisons d'attributs indépendants impossibles à exprimer sous forme de clé de routage séparée par des points.
Comment cartographier le flux de messages RabbitMQ entre les services ?
Documentez, pour chaque exchange, son type et le domaine dont il est responsable ; pour chaque clé de routage, qui publie et qui consomme ; pour chaque file d'attente, le service propriétaire, le motif de binding et la politique de dead-lettering, le tout rédigé en texte pour rester relisible dans une pull request. Pour confronter cette documentation à la réalité, lancez rabbitmqctl list_bindings ou interrogez l'endpoint bindings de l'API de management pour obtenir l'état actuel, et utilisez le plugin de traçage des messages pendant une fenêtre limitée pour vérifier que le trafic circule bien là où les bindings l'indiquent.
Chaque microservice doit-il avoir sa propre file d'attente ?
Non. La file d'attente doit correspondre à un groupe de consommateurs, pas à un service. Si plusieurs instances d'un même service se partagent le travail, il s'agit d'une seule file avec des consommateurs concurrents, ce qui donne une mise à l'échelle horizontale gratuite. Si une préoccupation réellement distincte a besoin des mêmes événements de manière indépendante, c'est un second groupe de consommateurs avec sa propre file et son propre binding, même au sein du même code ou de la même équipe.
Quelle différence entre un dead-letter exchange et une file de retry ?
Un dead-letter exchange (DLX) est l'exchange vers lequel RabbitMQ republie automatiquement un message rejeté, expiré ou ayant dépassé une limite ; une dead-letter queue qui lui est liée est l'endroit où ces messages arrivent pour être examinés. Une file de retry est une file d'attente séparée, dotée d'un TTL, dont le propre DLX renvoie vers le flux de traitement d'origine : après un délai, le message est ainsi réinjecté dans le traitement normal. Les deux fonctionnent ensemble : le DLX est le mécanisme, et le retry via une file d'attente temporisée est un pattern construit dessus.
Comment éviter le traitement en double des messages dans RabbitMQ ?
RabbitMQ assure par défaut une livraison at-least-once avec des acquittements manuels : les doublons surviendront donc, que ce soit par une relivraison après un crash ou par une topologie de retry qui se déclenche tardivement. Concevez des consommateurs idempotents en indexant le traitement sur l'ID du message ou sur une clé métier stable, par exemple l'ID de commande et le type d'événement, et en traitant une répétition comme une opération sans effet. C'est bien moins coûteux à prévoir dès le départ qu'à ajouter après coup, une fois qu'un effet de bord en double a déjà atteint un client.
Quand utiliser RabbitMQ Streams plutôt qu'un fanout exchange ?
Optez pour Streams lorsque les consommateurs doivent rejouer l'historique, lorsque le volume est suffisamment élevé pour que le coût du routage message par message sur un exchange classique compte, ou lorsque plusieurs groupes de consommateurs indépendants doivent chacun lire l'intégralité du journal d'événements à leur propre rythme. Un fanout exchange avec une file par groupe de consommateurs peut s'en approcher à faible volume, mais il n'offre aucun rejeu et multiplie le coût de stockage et de routage pour chaque groupe, ce que ne fait pas un journal partagé.
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.