BlogRabbitMQ

Dead letter queues RabbitMQ : le guide pour l'entreprise

Scott Sternloff

Par Scott Sternloff, Architecte d’entreprise senior

LinkedIn · Mis à jour le · Lecture : 19 min

Dead letter queues RabbitMQ : le guide pour l'entreprise
Sur cette page

Le dead-lettering est le mécanisme par lequel RabbitMQ déplace un message qu'il ne peut plus livrer vers un endroit où vous pourrez le traiter. Bien configuré, il transforme une charge utile défectueuse en ticket. Mal configuré, c'est, d'après ce que nous observons, la cause la plus fréquente de disparition sans trace de messages de production. Ce guide couvre le mécanisme tel qu'il se comporte sur RabbitMQ 3.13 et 4.x, les patterns de retry qui reposent dessus et les habitudes d'exploitation qui gardent une dead letter queue fiable.

Ce qu'est exactement le dead-lettering

Une file d'attente envoie un message en dead-letter pour quatre raisons exactement :

  1. Un consommateur l'a rejeté avec basic.reject ou basic.nack et requeue=false.
  2. Son TTL par message, ou le message-ttl de la file d'attente, a expiré.
  3. La file d'attente dépassait sa limite max-length ou max-length-bytes et a supprimé le message en tête. C'est le comportement de débordement par défaut, drop-head ; avec reject-publish, le broker refuse plutôt la nouvelle publication et rien n'est envoyé en dead-letter.
  4. Sur une quorum queue, le message a été remis dans la file plus de fois que ne l'autorise sa delivery-limit.

Le broker les enregistre sous les motifs rejected, expired, maxlen et delivery_limit. Rien d'autre ne compte. Une file d'attente qui expire via x-expires est supprimée avec son contenu. Une purge écarte les messages. Un message que le broker ne peut pas router au moment de la publication n'est pas non plus envoyé en dead-letter : c'est le rôle du flag mandatory ou d'un alternate exchange.

Un dead letter exchange (DLX) est un exchange ordinaire. Il n'a ni type particulier ni flag dans sa déclaration. C'est simplement l'exchange vers lequel une file d'attente republie lorsqu'elle envoie un message en dead-letter, avec la dead-letter-routing-key de la file si elle est définie, et sinon la clé de routage d'origine du message. Comme il est ordinaire, vous pouvez diffuser vers une file de quarantaine et une file d'audit, router selon la clé d'origine via un exchange topic, ou envoyer les échecs de chaque équipe vers sa propre file d'attente. Une « dead letter queue » n'est rien d'autre que la file d'attente que vous y avez liée.

Deux choses changent sur le message lors de sa republication. La propriété expiration est effacée, afin qu'un message ayant expiré une fois n'expire pas aussitôt à nouveau ; la valeur d'origine est conservée dans x-death sous original-expiration. Et l'en-tête x-death est ajouté ou mis à jour. Le corps, l'identifiant du message, l'identifiant de corrélation et toutes les autres propriétés restent intacts.

Configurer le dead letter exchange : arguments ou policies

Il existe deux façons de rattacher une DLX à une file d'attente. Les arguments de file d'attente sont définis par le client au moment de la déclaration :

{
  "x-queue-type": "quorum",
  "x-dead-letter-exchange": "orders.retry",
  "x-dead-letter-routing-key": "order.failed"
}

Les policies définissent le même comportement côté broker, avec les clés dead-letter-exchange et dead-letter-routing-key, appliquées aux files d'attente selon un motif de nom.

Préférez les policies. Les arguments de file d'attente sont immuables : pour modifier une DLX définie en argument, il faut supprimer la file d'attente et la redéclarer, ce qui oblige à la vider d'abord et à coordonner chaque client qui la déclare. Les policies se modifient à chaud, s'appliquent à toutes les files d'attente correspondantes, figurent dans les exports de définitions et se trouvent en un seul endroit lisible par un opérateur. Quand les deux sont présents, l'argument l'emporte, ce qui est la seconde raison d'éviter les arguments : une application qui définit x-dead-letter-exchange fige une valeur que l'exploitation ne peut pas remplacer sans déploiement. L'exception est x-queue-type, qui doit être un argument, ce qui ne pose pas de problème puisque le type d'une file d'attente ne change jamais.

Un piège : une seule policy s'applique à une file d'attente, celle de priorité la plus élevée parmi les correspondances. Si vous définissez une policy pour le dead-lettering et une autre pour max-length ou delivery-limit sur les mêmes files d'attente, une seule prend effet. Regroupez toutes les clés dont une file d'attente a besoin dans la même définition de policy.

Lorsque le broker envoie un message en dead-letter, il complète l'en-tête x-death, un tableau comportant une entrée par couple file d'attente et motif. Si la même file d'attente envoie à nouveau le même message en dead-letter pour le même motif, le count de cette entrée s'incrémente et l'entrée passe en tête du tableau. Chaque entrée enregistre la file d'attente, le motif, l'exchange et les clés de routage portés par le message, un horodatage et, si un TTL est en cause, original-expiration. Le broker définit aussi une seule fois x-first-death-reason, x-first-death-queue et x-first-death-exchange, et tient à jour les équivalents x-last-death-*. Voici, à titre d'illustration, un en-tête après trois tours d'une boucle de retry :

x-death:
  - queue: orders.work
    reason: rejected
    exchange: orders
    routing-keys: [order.created]
    count: 3
    time: 1788430492
  - queue: orders.wait.30s
    reason: expired
    exchange: orders.retry
    routing-keys: [order.created]
    count: 3
    time: 1788430462
    original-expiration: "30000"
x-first-death-reason: rejected
x-first-death-queue: orders.work
x-first-death-exchange: orders
x-last-death-reason: rejected
x-last-death-queue: orders.work
x-last-death-exchange: orders

Le dead-lettering peut former un cycle, et le broker applique une seule règle : si un message atteint deux fois la même file d'attente et qu'aucune étape du cycle n'était un rejet, le message est supprimé. Si l'une des étapes était un rejet par un consommateur, le cycle continue. Les boucles de retry pilotées par requeue=false fonctionnent donc, puisque chaque tour comporte un rejet, alors qu'une boucle construite uniquement sur le TTL, comme une file de quarantaine dotée d'un message-ttl qui renvoie en dead-letter vers la file de travail, supprime silencieusement les messages à leur second tour.

Les quorum queues changent les règles

Les quorum queues comptent les relivraisons dans l'en-tête x-delivery-count, et la clé de policy delivery-limit (ou l'argument x-delivery-limit) les plafonne. Au-delà du plafond, la file d'attente envoie le message en dead-letter si une DLX est configurée, et le supprime sinon. Depuis RabbitMQ 4.0, la limite de livraison par défaut est de 20 ; auparavant, elle était illimitée.

C'est cette valeur par défaut qui surprend les équipes qui migrent depuis des classic queues. Un consommateur qui intercepte une exception et appelle basic.nack avec requeue=true tournait auparavant indéfiniment sur une classic queue, en gaspillant du CPU mais sans rien perdre. Sur une quorum queue 4.x sans DLX, le même code supprime le message après 20 tentatives, et la seule trace qui reste est un compteur. Réglez delivery-limit sur une valeur que vous avez choisie et associez-la toujours à une DLX.

Les quorum queues prennent aussi en charge deux stratégies de dead-lettering via la clé de policy dead-letter-strategy. La stratégie par défaut, at-most-once, republie sans confirmation. Si la DLX n'existe pas, ou si la file cible est indisponible ou refuse le message, celui-ci est perdu. C'est la garantie qu'ont toujours offerte les classic queues.

at-least-once conserve le message envoyé en dead-letter dans la file d'origine jusqu'à ce que chaque file d'attente liée à la DLX l'ait confirmé. Cette stratégie exige une quorum queue comme source, overflow réglé sur reject-publish et une DLX. En interne, le leader de la file d'attente fait tourner un worker de dead-lettering, que la documentation appelle le consommateur de dead-letter : il lit les messages envoyés en dead-letter dans la file d'origine, les publie vers la DLX avec confirmations et retente tout ce qui n'est pas confirmé. Trois conséquences en découlent. Si la DLX est absente ou si la cible est hors service, les messages s'accumulent dans la file d'origine et pèsent sur sa longueur et sur le disque, et c'est voulu. Comme la livraison est at-least-once, la DLQ peut recevoir des doublons. Et le consommateur de dead-letter interne n'est que de la tuyauterie, pas votre application : il vous faut toujours un vrai consommateur sur la dead letter queue.

ComportementClassic queueQuorum queue
Plafond de relivraisonAucun, les boucles de remise en file tournent indéfinimentdelivery-limit, 20 par défaut en 4.x, puis DLX ou suppression
Compteur de relivraisonsFlag redelivered uniquementEn-tête x-delivery-count
Stratégie de dead-letteringat-most-once uniquementat-most-once ou at-least-once
RéplicationMirroring supprimé en 4.0Répliquée par Raft dès la conception
Débordement par défautdrop-headdrop-head ; reject-publish requis pour at-least-once

Des patterns de retry qui ne perdent pas de messages

La boucle de retry de base utilise une file de temporisation. La DLX de la file de travail est un exchange de retry, qui route vers une file de temporisation dotée d'un message-ttl au niveau de la file et dépourvue de consommateurs. La DLX de la file de temporisation est l'exchange de travail, sans dead-letter-routing-key, afin que le message revienne avec sa clé de routage d'origine. Un consommateur confronté à un échec transitoire rejette avec requeue=false ; le message attend l'expiration du TTL puis revient. Le consommateur lit le nombre de tentatives dans l'entrée x-death correspondant à la file de travail avec le motif rejected et, une fois le plafond atteint, déplace le message vers une file de quarantaine au lieu de le rejeter à nouveau.

Pour un backoff exponentiel, utilisez une file de temporisation par palier de délai : wait.10s, wait.1m, wait.10m. Ne le faites pas avec des TTL par message dans une seule file d'attente. Les messages expirés ne sont retirés qu'en tête de file, dans les classic queues comme dans les quorum queues : un message de dix minutes en tête bloque donc un message de dix secondes placé derrière lui. Avec des files par palier, le consommateur choisit le palier selon le nombre de tentatives, publie vers l'exchange de retry avec la clé de routage du palier, attend la confirmation d'éditeur, et seulement ensuite acquitte l'original. Acquitter avant l'arrivée de la confirmation, c'est là que les retries pilotés par le consommateur perdent des messages. Conservez malgré tout la DLX sur la file de travail comme filet de sécurité pour delivery-limit.

Le plugin delayed message exchange est l'alternative : on publie avec un en-tête x-delay et l'exchange retient le message jusqu'à l'expiration du délai. La contrepartie porte sur la durabilité. Les messages différés résident dans un stockage local sur le nœud qui héberge l'exchange et ne sont pas répliqués : perdre ce nœud, c'est perdre tous les messages en attente, et un backlog important de messages en attente dégrade le plugin. Il n'y a pas non plus de file d'attente à inspecter. Pour quelques délais courts, c'est pratique ; pour un backlog de retries que vous pourriez devoir examiner à 3 h du matin, les files de temporisation sont ennuyeuses, visibles et répliquées lorsqu'elles sont déclarées en quorum queues.

Les retries ne sont utiles que face aux échecs transitoires. Un message qui échoue de manière déterministe, parce que sa charge utile est malformée ou qu'il référence un enregistrement inexistant, doit aller directement en quarantaine : distinguez donc dans le consommateur les exceptions qui justifient un retry de celles qui ne le justifient pas. Et chaque mécanisme décrit sur cette page peut livrer deux fois le même message : retries, rejeux et dead-lettering at-least-once garantissent la livraison, pas l'unicité. Les consommateurs doivent être idempotents, en s'appuyant sur l'identifiant du message ou sur une clé métier, faute de quoi un retry transforme un échec en double facturation.

Exemple concret : traitement de commandes avec une file de temporisation et une file de quarantaine

La topologie :

  • Exchange orders (topic) avec la quorum queue orders.work liée sur order.*.
  • Exchange orders.retry (fanout) avec la quorum queue orders.wait.30s, TTL de 30 secondes, renvoyant en dead-letter vers orders.
  • Exchange orders.dlx (fanout) avec la quorum queue orders.parking, sans TTL ni automatisation.

Deux policies suffisent :

rabbitmqctl set_policy --vhost orders orders-work '^orders\.work$' \
  '{"dead-letter-exchange":"orders.retry","dead-letter-strategy":"at-least-once","overflow":"reject-publish","delivery-limit":5}' \
  --apply-to queues --priority 10

rabbitmqctl set_policy --vhost orders orders-wait '^orders\.wait\.' \
  '{"message-ttl":30000,"dead-letter-exchange":"orders","dead-letter-strategy":"at-least-once","overflow":"reject-publish"}' \
  --apply-to queues --priority 10

Le consommateur fait respecter le plafond de tentatives et place explicitement le message en quarantaine, en publiant avec confirmation avant d'acquitter :

MAX_ATTEMPTS = 3

def on_message(msg):
    attempts = death_count(msg.headers, queue="orders.work", reason="rejected")
    try:
        process_order(msg)                 # idempotent on msg.message_id
        msg.ack()
    except RetryableError as err:
        if attempts + 1 >= MAX_ATTEMPTS:
            park(msg, reason=str(err))
        else:
            log.warning("retry", id=msg.message_id, attempt=attempts + 1, err=err)
            msg.reject(requeue=False)      # -> orders.retry -> orders.wait.30s -> orders
    except NonRetryableError as err:
        park(msg, reason=str(err))

def park(msg, reason):
    headers = dict(msg.headers, **{"x-parked-reason": reason, "x-parked-at": now_iso()})
    publish_with_confirm("orders.dlx", msg.routing_key, msg.body, msg.properties, headers)
    msg.ack()                              # ack only after the broker confirmed the park

Chaque élément protège contre un risque précis. Un plantage en cours de traitement remet le message en file ; cinq d'affilée déclenchent delivery-limit et le message part vers la file de temporisation au lieu d'être supprimé. Un échec transitoire attend 30 secondes puis revient, dans la limite de trois tentatives. Un échec permanent est mis en quarantaine dès sa première occurrence. Le dead-lettering at-least-once garantit que l'étape de retry ne peut pas perdre de message si orders.wait.30s est brièvement indisponible.

Exploiter une dead letter queue

Une dead letter queue n'est utile que si quelqu'un sait quand elle se remplit. Quatre signaux couvrent l'essentiel.

La profondeur : rabbitmq_queue_messages pour la file de quarantaine et chaque file de temporisation, via le plugin Prometheus avec les métriques par objet ou la famille queue_coarse_metrics de l'endpoint détaillé. Le taux, qui détecte un changement plus tôt que la profondeur : les compteurs rabbitmq_global_messages_dead_lettered_*_total ventilent le dead-lettering par motif et, en at-least-once, par confirmation. Le nombre de consommateurs, qui vous indique que la topologie est intacte : rabbitmq_queue_consumers doit être non nul sur la file de quarantaine et égal à zéro sur chaque file de temporisation, car un consommateur sur une file de temporisation annule le délai. L'ancienneté, que RabbitMQ n'expose pas directement : estimez-la à partir de l'en-tête x-parked-at ou du champ time de x-death lorsque vous échantillonnez la file d'attente.

Seuils de départ, à ajuster selon le service :

  • Tout dead-lettering sur une file d'attente qui n'en voit normalement jamais : avertissement immédiat, le premier cas est le moins coûteux à analyser.
  • Taux de dead-lettering supérieur à 1 % du taux de publication sur cinq minutes : astreinte.
  • Compteur delivery_limit en hausse, même légère : à analyser, cela signale des consommateurs qui plantent ou des boucles de remise en file, pas des échecs métier.
  • Profondeur de la file de quarantaine supérieure à un volume calibré sur votre capacité à examiner les messages, ou en hausse continue pendant 30 minutes : astreinte.
  • Aucun consommateur sur la file de quarantaine pendant dix minutes, ou un consommateur quel qu'il soit sur une file de temporisation : alerte.
  • Profondeur de la file d'origine en hausse alors que la DLQ reste stable, avec at-least-once configuré : la DLX ou sa cible est défaillante.

Au moment de la mise en quarantaine, journalisez ce que le broker n'enregistre pas : la classe et le message de l'exception, l'hôte et le build du consommateur, l'identifiant du message et l'identifiant de corrélation, l'exchange et la clé de routage d'origine tirés de x-death, et le nombre de tentatives. Le broker sait pourquoi un message a été envoyé en dead-letter ; seul le consommateur sait ce qui a mal tourné. Ajoutez aussi le motif en en-tête, comme le fait l'exemple avec x-parked-reason, afin que la personne qui ouvrira la file d'attente plus tard puisse le lire sans croiser les logs. Ne journalisez pas les corps complets, sauf s'ils sont petits et ne contiennent rien de sensible. Le corps est dans la file d'attente.

Rejouer les messages en toute sécurité

Rejouer consiste à republier les messages en quarantaine vers l'exchange de travail. Corrigez d'abord la cause. Rejouer vers un consommateur non corrigé crée une boucle entre la file de quarantaine et la file de travail, avec un humain au milieu.

L'outil le plus simple est un shovel dynamique de la file de quarantaine vers l'exchange de travail, créé avec rabbitmqctl set_parameter shovel. Utilisez on-confirm comme ack-mode, afin qu'un message ne quitte la file de quarantaine qu'une fois confirmé par la file de travail, réglez dest-exchange sur l'exchange de travail et laissez dest-exchange-key non défini pour que la clé de routage d'origine soit utilisée, et réglez src-delete-after sur queue-length afin que le shovel vide ce qui était présent à son démarrage puis se supprime. L'action de déplacement de messages de l'interface de gestion repose en réalité sur un shovel. Un shovel rejoue tout dans l'ordre, sans filtrage, et x-death continue de s'accumuler, ce qui est souhaitable : un message qui échoue de nouveau revient dans la file de quarantaine avec un historique plus long.

Lorsqu'il faut sélectionner, utilisez un consommateur de rejeu : un petit outil qui consomme la file de quarantaine avec un prefetch modeste, filtre selon un en-tête, une date ou un identifiant, publie avec confirmations et acquitte après chaque confirmation. Limitez son débit, car une file de quarantaine remplie pendant un week-end peut submerger une base de données en aval le lundi matin. Si vous voulez que le comptage des tentatives reparte de zéro, il peut supprimer x-death, mais il doit alors enregistrer à la place un en-tête x-replay-count.

Ne republiez pas depuis un script improvisé sans confirmations, ne rejouez pas en période de pointe et ne rejouez pas un lot dont vous n'avez pas identifié la cause profonde.

Rétention et disque

Une file de quarantaine est un état durable. Sur une quorum queue, chaque message est écrit dans le journal Raft et dans les fichiers de segments de chaque membre : une file d'attente à trois membres conserve donc trois copies tant que le message y séjourne. Les messages envoyés en dead-letter sont souvent les plus volumineux, et ils restent souvent là plusieurs jours. Prévoyez le disque.

Bornez la file de quarantaine avec max-length-bytes et overflow réglé sur reject-publish, et non sur drop-head. drop-head écarte silencieusement les preuves les plus anciennes lorsque la file d'attente est pleine. reject-publish rend une file de quarantaine pleine bien visible : le dead-lettering vers elle échoue, la file d'origine en at-least-once conserve son backlog et vos alertes se déclenchent. C'est bien qu'elle se voie.

Ne définissez pas de message-ttl sur la file de quarantaine. La rétention relève d'un consommateur d'archivage qui déplace les messages plus anciens que votre fenêtre d'examen vers un stockage objet ou une table de base de données puis les acquitte, pour que la file d'attente reste une boîte de réception et non une archive. Le risque que vous évitez est bien réel : une file de quarantaine que personne ne vide grossit jusqu'à ce que le nœud franchisse le seuil d'alarme d'espace disque libre, et l'alarme disque bloque tous les éditeurs du nœud, transformant une lente accumulation d'échecs en panne à l'échelle du cluster.

Les anti-patterns que nous voyons en production

Une DLQ sans consommateur ni alerte. Les messages s'accumulent jusqu'à ce que l'alarme disque se déclenche ou que quelqu'un découvre la file d'attente des mois plus tard, à l'occasion d'un incident sans rapport. Si vous ne remarqueriez pas que la file grossit, vous avez simplement configuré une fuite, en plus compliqué.

Le dead-lettering vers l'exchange auquel la file d'attente est déjà liée, sans changement de clé de routage. Le message retombe dans la même file d'attente. S'il avait expiré ou été supprimé pour cause de longueur, la détection de cycle l'écarte. S'il avait été rejeté, il boucle à pleine vitesse dans le consommateur, saturant le CPU et remplissant les logs.

Les retries illimités. Sans plafond de tentatives, un message qui ne réussira jamais circule indéfiniment, consomme de la capacité à chaque tour et, avec at-least-once et reject-publish, peut refluer jusque dans la file d'origine.

Des classic queues mirrorées portant la DLX en 4.x. Le mirroring des classic queues a été supprimé dans RabbitMQ 4.0 et les clés de policy ha-* ne sont plus prises en compte. Une dead letter queue répliquée en 3.x devient après la mise à niveau une classic queue sur un seul nœud, et si ce nœud tombe, les preuves disparaissent avec lui. Convertissez les dead letter queues en quorum queues avant la mise à niveau.

Un TTL sur la DLQ elle-même. Un message-ttl d'une semaine sur la file de quarantaine « pour garder les choses propres » supprime exactement les messages dont une investigation a besoin, et si la file de quarantaine renvoie aussi en dead-letter vers la file de travail, le TTL construit un cycle d'expiration pure que la détection de cycle supprime silencieusement.

Deux erreurs moins graves : journaliser le corps et acquitter au lieu de mettre en quarantaine, ce qui revient à traiter une ligne de log comme une file d'attente ; et faire tourner le consommateur de la file de quarantaine dans le même processus que le consommateur de travail, si bien que la panne qui remplit la file de quarantaine met aussi hors service ce qui devait la vider.

Pour aller plus loin

Le dead-lettering repose sur le routage, et une DLX ne vaut que par la conception des exchanges qui l'entoure. Notre guide des exchanges, files d'attente et bindings pour les microservices traite ce sujet. Si la question du type de file d'attente n'est pas tranchée, classic queues ou quorum queues couvre cette décision ; tout ce qui précède suppose des quorum queues pour tout ce qui compte. Pour les modes de défaillance plus généraux qui remplissent une file de quarantaine en premier lieu, consultez les dix problèmes RabbitMQ les plus fréquents.

Si vos dead letter queues se remplissent sans que vous sachiez pourquoi, ou si vous préparez la mise à niveau vers la 4.x et voulez faire revoir votre topologie de DLX avant que les files mirrorées ne soient plus une option, c'est notre métier. AceMQ est le seul partenaire MSP RabbitMQ désigné par Broadcom, assure le support de RabbitMQ de la 3.8.x à la 4.x et répond aux incidents P1 avec des objectifs de réponse à partir de 15 minutes, selon le plan. Consultez nos offres de support RabbitMQ ou découvrez comment nous travaillons avec RabbitMQ.

FAQ

Quelle différence entre un dead letter exchange et une dead letter queue ?

Un dead letter exchange est l'exchange vers lequel une file d'attente republie un message qu'elle envoie en dead-letter. C'est un exchange ordinaire, sans type particulier. Une dead letter queue est n'importe quelle file d'attente liée à cet exchange, et ce nom est une convention, pas un concept du broker. RabbitMQ ne connaît que l'exchange ; la destination finale du message dépend des bindings que vous avez déclarés. Cette séparation est utile : une même DLX peut diffuser à la fois vers une file de quarantaine pour le rejeu et vers une file d'audit pour l'analyse, ou router les échecs de chaque équipe vers sa propre file d'attente selon la clé de routage d'origine.

RabbitMQ envoie-t-il en dead-letter les messages impossibles à router ?

Non. Le dead-lettering ne concerne que les messages qui se trouvaient déjà dans une file d'attente et qui ont été rejetés, ont expiré, ont été supprimés pour cause de longueur ou ont dépassé la limite de livraison d'une quorum queue. Un message publié sur un exchange sans binding correspondant est écarté dès la publication, sauf si l'éditeur a positionné le flag mandatory, auquel cas il lui est renvoyé, ou si l'exchange dispose d'un alternate exchange, auquel cas il y est routé. Si les messages non routables comptent pour vous, configurez un alternate exchange doté de sa propre file d'attente et supervisez-la comme une dead letter queue.

Comment compter les retries dans RabbitMQ ?

Lisez l'en-tête x-death. Chaque entrée correspond à un couple file d'attente et motif, et son champ count s'incrémente chaque fois que cette file d'attente envoie le message en dead-letter pour ce motif. Dans une boucle de retry avec file de temporisation, cherchez l'entrée dont la queue est votre file de travail et dont la reason vaut rejected : son compteur donne le nombre de tentatives effectuées. Sur les quorum queues, l'en-tête distinct x-delivery-count compte les relivraisons au sein d'une même file d'attente, ce qui capture les plantages et les remises en file plutôt que les rejets explicites. Faites respecter le plafond dans le consommateur et, une fois le plafond atteint, placez le message en quarantaine par une publication explicite avec confirmation.

Peut-on utiliser un dead letter exchange avec des quorum queues ?

Oui, et les quorum queues apportent deux choses que les classic queues n'ont jamais eues. La policy delivery-limit plafonne les relivraisons et envoie le message en dead-letter lorsque ce plafond est dépassé, avec une valeur par défaut de 20 à partir de RabbitMQ 4.0 : configurez donc une DLX, sinon ces messages sont supprimés. La clé de policy dead-letter-strategy peut prendre la valeur at-least-once, qui conserve les messages envoyés en dead-letter dans la file d'origine jusqu'à ce que la file cible les confirme. Cela exige que overflow vaille reject-publish. La file d'origine et, idéalement, la dead letter queue elle-même devraient être des quorum queues, afin que les preuves de l'échec soient répliquées.

Que se passe-t-il si le dead letter exchange n'existe pas ?

Le broker ne vérifie pas le nom de l'exchange lorsque la file d'attente est déclarée ou que la policy est appliquée : la configuration est donc acceptée sans broncher. Avec la stratégie par défaut at-most-once, chaque message envoyé en dead-letter est supprimé, sans erreur ni ligne de log, ce qui en fait l'une des manières les plus silencieuses de perdre des données dans RabbitMQ. Avec at-least-once sur une quorum queue, les messages envoyés en dead-letter restent dans la file d'origine jusqu'à ce que l'exchange apparaisse et que la file cible les confirme : c'est alors la file d'origine qui grossit. Déclarez la DLX et sa file d'attente dans les définitions, et alertez sur tout taux de dead-lettering qui ne s'accompagne pas d'une croissance de la DLQ.

Faut-il définir un TTL sur la dead letter queue ?

Non. Un message-ttl sur la file de quarantaine supprime les messages que vous avez conservés précisément pour que quelqu'un puisse les examiner et les rejouer, et il les supprime selon un minuteur qui n'a rien à voir avec la résolution du problème de fond. Si la file de quarantaine renvoie aussi en dead-letter vers la file de travail, l'expiration crée un cycle sans aucun rejet, que le broker supprime silencieusement. Gérez la rétention avec un consommateur d'archivage qui déplace les anciens messages vers un stockage durable puis les acquitte, bornez la file d'attente avec max-length-bytes et reject-publish, et alertez sur la profondeur et l'ancienneté.

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 RabbitMQ ?

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 RabbitMQ

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