BlogRabbitMQ

RabbitMQ Dead Letter Queues: der Leitfaden für Unternehmen

Scott Sternloff

Von Scott Sternloff, Senior Enterprise Architect

LinkedIn · Aktualisiert am · 19 Min. Lesezeit

RabbitMQ Dead Letter Queues: der Leitfaden für Unternehmen
Auf dieser Seite

Mit Dead-Lettering verschiebt RabbitMQ eine Nachricht, die es nicht mehr zustellen kann, an einen Ort, an dem Sie sich darum kümmern können. Gut konfiguriert wird aus einem fehlerhaften Payload ein Ticket. Schlecht konfiguriert ist es der häufigste Weg, auf dem wir produktive Nachrichten spurlos verschwinden sehen. Dieser Leitfaden behandelt den Mechanismus, wie er sich in RabbitMQ 3.13 und 4.x verhält, die darauf aufbauenden Retry-Muster und die Betriebsgewohnheiten, die eine Dead-Letter-Queue verlässlich halten.

Was Dead-Lettering genau ist

Eine Queue sortiert eine Nachricht aus genau vier Gründen per Dead-Lettering aus:

  1. Ein Consumer hat sie mit basic.reject oder basic.nack und requeue=false abgelehnt.
  2. Ihre TTL pro Nachricht oder die message-ttl der Queue ist abgelaufen.
  3. Die Queue hat ihr Limit max-length oder max-length-bytes überschritten und die Nachricht am Kopf verworfen. Das ist das Standard-Overflow-Verhalten drop-head; mit reject-publish weist der Broker stattdessen den neuen Publish ab, und nichts wird aussortiert.
  4. Bei einer Quorum Queue wurde die Nachricht öfter an die Queue zurückgegeben, als ihr delivery-limit erlaubt.

Der Broker erfasst diese Fälle als rejected, expired, maxlen und delivery_limit. Sonst zählt nichts. Eine Queue, die über x-expires abläuft, wird samt Inhalt gelöscht. Ein Purge verwirft Nachrichten. Auch eine Nachricht, die der Broker beim Publish nicht routen kann, wird nicht aussortiert; dafür sind das mandatory-Flag oder ein Alternate Exchange zuständig.

Ein Dead-Letter-Exchange (DLX) ist ein gewöhnlicher Exchange. Es gibt keinen besonderen Typ und kein Flag in der Deklaration. Er ist schlicht der Exchange, an den eine Queue beim Dead-Lettering neu veröffentlicht – mit dem dead-letter-routing-key der Queue, falls gesetzt, andernfalls mit dem ursprünglichen Routing Key der Nachricht. Weil er gewöhnlich ist, können Sie per Fan-out eine Parking-Lot-Queue und eine Audit-Queue beliefern, über einen Topic Exchange nach dem ursprünglichen Key routen oder die Fehler jedes Teams in eine eigene Queue leiten. Eine „Dead-Letter-Queue“ ist einfach die Queue, die Sie daran gebunden haben.

Bei der Neuveröffentlichung ändern sich an der Nachricht zwei Dinge. Die Eigenschaft expiration wird gelöscht, damit eine einmal abgelaufene Nachricht nicht sofort wieder abläuft; der ursprüngliche Wert bleibt in x-death als original-expiration erhalten. Außerdem wird der Header x-death hinzugefügt oder aktualisiert. Body, Message ID, Correlation ID und alle übrigen Eigenschaften bleiben unverändert.

Den Dead-Letter-Exchange konfigurieren: Argumente oder Policies

Einen DLX können Sie auf zwei Wegen an eine Queue hängen. Queue-Argumente setzt der Client bei der Deklaration:

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

Policies legen dasselbe Verhalten auf Broker-Seite fest, mit den Keys dead-letter-exchange und dead-letter-routing-key, die über ein Namensmuster auf Queues angewendet werden.

Bevorzugen Sie Policies. Queue-Argumente sind unveränderlich: Um einen als Argument gesetzten DLX zu ändern, müssen Sie die Queue löschen und neu deklarieren – also vorher leeren und jeden Client abstimmen, der sie deklariert. Policies lassen sich zur Laufzeit ändern, gelten für jede passende Queue, sind Teil der Definitions-Exporte und liegen an einer Stelle, die ein Operator lesen kann. Sind beide vorhanden, gewinnt das Argument – der zweite Grund, Argumente zu meiden: Eine Anwendung, die x-dead-letter-exchange setzt, legt einen Wert fest, den der Betrieb ohne Deployment nicht überschreiben kann. Die Ausnahme ist x-queue-type, das ein Argument sein muss – was unproblematisch ist, weil sich der Typ einer Queue nie ändert.

Eine Falle: Auf eine Queue wird nur eine Policy angewendet, nämlich der Treffer mit der höchsten Priorität. Definieren Sie eine Policy für Dead-Lettering und eine andere für max-length oder delivery-limit auf denselben Queues, greift nur eine davon. Packen Sie jeden Key, den eine Queue braucht, in dieselbe Policy-Definition.

Wenn der Broker eine Nachricht aussortiert, ergänzt er den Header x-death, ein Array mit einem Eintrag pro Paar aus Queue und Grund. Sortiert dieselbe Queue dieselbe Nachricht erneut aus demselben Grund aus, erhöht sich der count dieses Eintrags, und er rückt an den Anfang des Arrays. Jeder Eintrag enthält die Queue, den Grund, den Exchange und die Routing Keys der Nachricht, einen Zeitstempel und – wenn eine TTL beteiligt war – original-expiration. Außerdem setzt der Broker einmalig x-first-death-reason, x-first-death-queue und x-first-death-exchange und hält die entsprechenden x-last-death-*-Header aktuell. Ein Beispiel-Header nach drei Runden einer Retry-Schleife:

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

Dead-Lettering kann einen Zyklus bilden, und der Broker hat dafür eine Regel: Erreicht eine Nachricht dieselbe Queue zweimal und war keiner der Schritte im Zyklus eine Ablehnung, wird die Nachricht verworfen. War irgendein Schritt eine Ablehnung durch einen Consumer, läuft der Zyklus weiter. Retry-Schleifen auf Basis von requeue=false funktionieren also, weil jede Runde eine Ablehnung enthält. Eine Schleife, die nur auf TTL beruht – etwa ein Parking Lot mit message-ttl, der per Dead-Lettering zurück an die Work Queue leitet –, verwirft Nachrichten in der zweiten Runde stillschweigend.

Quorum Queues ändern die Regeln

Quorum Queues zählen erneute Zustellungen im Header x-delivery-count, und der Policy-Key delivery-limit (oder das Argument x-delivery-limit) begrenzt diesen Wert. Wird die Grenze überschritten, sortiert die Queue die Nachricht per Dead-Lettering aus, sofern ein DLX konfiguriert ist – andernfalls verwirft sie sie. Ab RabbitMQ 4.0 liegt das Standard-Delivery-Limit bei 20; vorher war es unbegrenzt.

Genau dieser Standard überrascht Teams, die von Classic Queues migrieren. Ein Consumer, der eine Exception abfängt und basic.nack mit requeue=true aufruft, drehte sich auf einer Classic Queue früher endlos im Kreis – das verschwendete CPU, verlor aber nichts. Auf einer Quorum Queue unter 4.x ohne DLX verwirft derselbe Code die Nachricht nach 20 Versuchen, und die einzige Spur ist ein Zähler. Setzen Sie delivery-limit auf einen bewusst gewählten Wert und kombinieren Sie ihn immer mit einem DLX.

Quorum Queues unterstützen außerdem zwei Dead-Letter-Strategien über den Policy-Key dead-letter-strategy. Der Standard, at-most-once, veröffentlicht ohne Bestätigung neu. Existiert der DLX nicht oder ist die Ziel-Queue nicht verfügbar oder weist sie die Nachricht ab, ist diese verloren. Das ist die Garantie, die Classic Queues schon immer hatten.

at-least-once behält die aussortierte Nachricht in der Quell-Queue, bis jede am DLX gebundene Queue sie bestätigt hat. Voraussetzungen sind eine Quorum Queue als Quelle, overflow auf reject-publish und ein DLX. Intern betreibt der Leader der Queue einen Dead-Letter-Worker, den die Dokumentation Dead-Letter-Consumer nennt: Er liest aussortierte Nachrichten aus der Quell-Queue, veröffentlicht sie mit Confirms an den DLX und wiederholt alles, was nicht bestätigt wurde. Daraus folgt dreierlei. Fehlt der DLX oder ist das Ziel ausgefallen, sammeln sich die Nachrichten in der Quell-Queue und zählen gegen deren Länge und Plattenplatz – so ist es gewollt. Weil die Zustellung at-least-once erfolgt, kann die DLQ Duplikate erhalten. Und der interne Dead-Letter-Consumer ist Infrastruktur, nicht Ihre Anwendung; Sie brauchen trotzdem einen echten Consumer auf der Dead-Letter-Queue.

VerhaltenClassic QueueQuorum Queue
Obergrenze für erneute ZustellungenKeine, Requeue-Schleifen laufen endlosdelivery-limit, Standard 20 in 4.x, danach DLX oder Verwerfen
Zähler für erneute ZustellungenNur das Flag redeliveredHeader x-delivery-count
Dead-Letter-StrategieNur at-most-onceat-most-once oder at-least-once
ReplikationMirroring in 4.0 entferntVon Haus aus per Raft repliziert
Standard-Overflowdrop-headdrop-head; reject-publish erforderlich für at-least-once

Retry-Muster, die keine Nachrichten verlieren

Die einfache Retry-Schleife nutzt eine Wait Queue. Der DLX der Work Queue ist ein Retry-Exchange, der in eine Wait Queue mit message-ttl auf Queue-Ebene und ohne Consumer routet. Der DLX der Wait Queue ist der Work-Exchange – ohne dead-letter-routing-key, damit die Nachricht mit ihrem ursprünglichen Routing Key zurückkehrt. Ein Consumer, der auf einen vorübergehenden Fehler stößt, lehnt mit requeue=false ab; die Nachricht wartet die TTL ab und kommt zurück. Der Consumer liest die Zahl der Versuche aus dem x-death-Eintrag für die Work Queue mit dem Grund rejected und verschiebt die Nachricht bei Erreichen der Obergrenze in einen Parking Lot, statt sie erneut abzulehnen.

Für exponentielles Backoff verwenden Sie eine Wait Queue pro Verzögerungsstufe: wait.10s, wait.1m, wait.10m. Lösen Sie das nicht mit TTLs pro Nachricht in einer einzigen Queue. Abgelaufene Nachrichten werden nur am Kopf einer Queue entfernt – bei Classic wie bei Quorum Queues –, eine Zehn-Minuten-Nachricht am Kopf blockiert also eine Zehn-Sekunden-Nachricht dahinter. Mit gestuften Queues wählt der Consumer die Stufe anhand der Zahl der Versuche, veröffentlicht mit dem Routing Key der Stufe an den Retry-Exchange, wartet auf das Publisher Confirm und bestätigt erst dann das Original. Wer bestätigt, bevor das Confirm eintrifft, verliert bei Consumer-gesteuerten Retries Nachrichten. Behalten Sie den DLX an der Work Queue trotzdem als Sicherheitsnetz für delivery-limit.

Die Alternative ist das Plugin Delayed Message Exchange: Sie veröffentlichen mit einem Header x-delay, und der Exchange hält die Nachricht zurück, bis die Verzögerung abgelaufen ist. Der Preis ist die Durability. Verzögerte Nachrichten liegen in einem lokalen Speicher auf dem Node, der den Exchange hostet, und werden nicht repliziert. Fällt dieser Node aus, sind alle ausstehenden Nachrichten verloren, und ein großer Rückstau ausstehender Nachrichten verschlechtert das Plugin. Außerdem gibt es keine Queue, die sich inspizieren ließe. Für eine Handvoll kurzer Verzögerungen ist das bequem; für einen Retry-Rückstau, den Sie um 3 Uhr morgens untersuchen müssen, sind Wait Queues langweilig, sichtbar und – als Quorum Queues deklariert – repliziert.

Retries helfen nur bei vorübergehenden Fehlern. Eine Nachricht, die deterministisch scheitert – weil der Payload fehlerhaft ist oder auf einen nicht existierenden Datensatz verweist –, sollte direkt in den Parking Lot. Unterscheiden Sie im Consumer also zwischen wiederholbaren und nicht wiederholbaren Exceptions. Und jeder Mechanismus auf dieser Seite kann dieselbe Nachricht zweimal zustellen: Retries, Replays und At-least-once-Dead-Lettering garantieren die Zustellung, nicht die Eindeutigkeit. Consumer müssen idempotent sein, mit der Message ID oder einem fachlichen Schlüssel als Kennung – sonst wird aus einem Fehler per Retry eine doppelte Abbuchung.

Praxisbeispiel: Auftragsverarbeitung mit Wait Queue und Parking Lot

Die Topologie:

  • Exchange orders (Topic) mit der Quorum Queue orders.work, gebunden auf order.*.
  • Exchange orders.retry (Fanout) mit der Quorum Queue orders.wait.30s, 30 Sekunden TTL, Dead-Lettering zurück an orders.
  • Exchange orders.dlx (Fanout) mit der Quorum Queue orders.parking, ohne TTL, ohne Automatisierung.

Zwei Policies decken das ab:

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

Der Consumer setzt die Obergrenze für Versuche durch und parkt explizit – mit einem bestätigten Publish vor dem Ack:

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

Jedes Element schützt vor etwas Bestimmtem. Ein Absturz mitten in der Verarbeitung führt zum Requeue der Nachricht; fünf in Folge lösen delivery-limit aus, und die Nachricht geht in die Wait Queue, statt verworfen zu werden. Ein vorübergehender Fehler wartet 30 Sekunden und kehrt zurück, bis zu drei Versuche lang. Ein dauerhafter Fehler wird sofort geparkt. Dank At-least-once-Dead-Lettering kann der Retry-Schritt keine Nachricht verlieren, wenn orders.wait.30s kurzzeitig nicht verfügbar ist.

Eine Dead-Letter-Queue betreiben

Eine Dead-Letter-Queue nützt nur, wenn jemand merkt, dass sie sich füllt. Vier Signale decken das Wesentliche ab.

Tiefe: rabbitmq_queue_messages für den Parking Lot und jede Wait Queue, aus dem Prometheus-Plugin mit Metriken pro Objekt oder aus der Familie queue_coarse_metrics des Detailed Endpoints. Rate, die Veränderungen früher erkennt als die Tiefe: Die Counter rabbitmq_global_messages_dead_lettered_*_total schlüsseln Dead-Lettering nach Grund auf und bei at-least-once auch nach Bestätigung. Anzahl der Consumer, die zeigt, ob die Topologie intakt ist: rabbitmq_queue_consumers sollte auf dem Parking Lot größer als null und auf jeder Wait Queue genau null sein, denn ein Consumer auf einer Wait Queue hebelt die Verzögerung aus. Alter, das RabbitMQ nicht direkt bereitstellt; schätzen Sie es beim Sampling der Queue über den Header x-parked-at oder das Feld time in x-death.

Ausgangswerte für Schwellen, die Sie an den Service anpassen:

  • Jedes Dead-Lettering auf einer Queue, auf der normalerweise keines vorkommt: sofort warnen – der erste Fall ist am günstigsten zu untersuchen.
  • Dead-Letter-Rate über ein Prozent der Publish-Rate über fünf Minuten: Bereitschaft alarmieren.
  • Der Counter delivery_limit steigt überhaupt: untersuchen – das deutet auf abstürzende Consumer oder Requeue-Schleifen hin, nicht auf fachliche Fehler.
  • Tiefe des Parking Lots über einer Anzahl, die sich an Ihrer Kapazität zur Prüfung bemisst, oder kontinuierlicher Anstieg über 30 Minuten: Bereitschaft alarmieren.
  • Zehn Minuten lang kein Consumer auf dem Parking Lot oder irgendein Consumer auf einer Wait Queue: Alarm.
  • Die Tiefe der Quell-Queue steigt, während die DLQ konstant bleibt, und at-least-once ist konfiguriert: Der DLX oder sein Ziel ist defekt.

Protokollieren Sie beim Parken, was der Broker nicht erfasst: Exception-Klasse und -Meldung, Host und Build des Consumers, Message ID und Correlation ID, den ursprünglichen Exchange und Routing Key aus x-death sowie die Zahl der Versuche. Der Broker weiß, warum eine Nachricht aussortiert wurde; nur der Consumer weiß, was schiefgelaufen ist. Hängen Sie den Grund zusätzlich als Header an, wie im Beispiel mit x-parked-reason, damit jeder, der die Queue später öffnet, ihn ohne Abgleich mit den Logs lesen kann. Protokollieren Sie den vollständigen Body nur, wenn er klein ist und nichts Sensibles enthält. Der Body liegt ja in der Queue.

Nachrichten sicher erneut einspielen

Replay heißt: geparkte Nachrichten zurück an den Work-Exchange veröffentlichen. Beheben Sie zuerst die Ursache. Ein Replay in einen nicht korrigierten Consumer erzeugt eine Schleife zwischen Parking Lot und Work Queue – mit einem Menschen in der Mitte.

Das einfachste Werkzeug ist eine dynamische Shovel vom Parking Lot zum Work-Exchange, angelegt mit rabbitmqctl set_parameter shovel. Verwenden Sie für ack-mode den Wert on-confirm, damit eine Nachricht den Parking Lot erst verlässt, wenn die Work Queue sie bestätigt hat. Setzen Sie dest-exchange auf den Work-Exchange und lassen Sie dest-exchange-key leer, damit der ursprüngliche Routing Key verwendet wird. Setzen Sie src-delete-after auf queue-length, damit die Shovel abarbeitet, was beim Start vorhanden war, und sich dann selbst entfernt. Die Aktion „Move messages“ in der Management UI ist unter der Haube eine Shovel. Eine Shovel spielt alles in der ursprünglichen Reihenfolge ohne Filterung erneut ein, und x-death wächst weiter – genau das wollen Sie: Eine Nachricht, die erneut scheitert, kehrt mit einer längeren Historie in den Parking Lot zurück.

Wenn Sie auswählen müssen, nutzen Sie einen Replay-Consumer: ein kleines Tool, das mit moderatem Prefetch aus dem Parking Lot konsumiert, nach Header, Zeit oder ID filtert, mit Confirms veröffentlicht und nach jedem Confirm bestätigt. Begrenzen Sie seine Rate, denn ein Parking Lot, der sich über ein Wochenende gefüllt hat, kann am Montagmorgen eine nachgelagerte Datenbank überrennen. Sollen die Zähler für Versuche neu beginnen, kann das Tool x-death entfernen, sollte dann aber stattdessen einen Header x-replay-count setzen.

Veröffentlichen Sie nicht aus einem spontan geschriebenen Skript ohne Confirms neu, spielen Sie nicht zu Spitzenzeiten ein, und spielen Sie keinen Batch ein, dessen Ursache Sie nicht ermittelt haben.

Aufbewahrung und Plattenplatz

Ein Parking Lot ist dauerhafter Zustand. In einer Quorum Queue wird jede Nachricht auf jedem Mitglied in das Raft-Log und die Segmentdateien geschrieben; eine Queue mit drei Mitgliedern hält also drei Kopien, solange die Nachricht dort liegt. Aussortierte Nachrichten sind tendenziell die großen, und sie liegen tendenziell tagelang. Planen Sie den Plattenplatz ein.

Begrenzen Sie den Parking Lot mit max-length-bytes und setzen Sie overflow auf reject-publish, nicht auf drop-head. drop-head verwirft stillschweigend die ältesten Belege, wenn die Queue voll ist. reject-publish macht einen vollen Parking Lot laut: Das Dead-Lettering dorthin schlägt fehl, die At-least-once-Quell-Queue hält ihren Rückstau, und Ihre Alarme lösen aus. Laut ist richtig.

Setzen Sie keine message-ttl auf dem Parking Lot. Die Aufbewahrung gehört in einen Archivierungs-Consumer, der Nachrichten, die älter als Ihr Prüfzeitraum sind, in einen Object Storage oder eine Datenbanktabelle verschiebt und sie bestätigt – so bleibt die Queue ein Posteingang und wird kein Archiv. Der Fehler, den Sie damit vermeiden, ist real: Ein Parking Lot, den niemand leert, wächst, bis der Node die Schwelle des Free-Disk-Alarms überschreitet. Der Disk-Alarm blockiert jeden Publisher auf dem Node und macht aus einer langsamen Anhäufung von Fehlern einen clusterweiten Ausfall.

Anti-Patterns, die wir in der Produktion sehen

Eine DLQ ohne Consumer und ohne Alarm. Nachrichten sammeln sich an, bis der Disk-Alarm auslöst oder jemand die Queue Monate später bei einem ganz anderen Incident entdeckt. Wenn Sie nicht bemerken würden, dass die Queue wächst, haben Sie ein Leck mit Zusatzschritten konfiguriert.

Dead-Lettering in den Exchange, an den die Queue bereits gebunden ist, ohne geänderten Routing Key. Die Nachricht landet wieder in derselben Queue. War sie abgelaufen oder wegen der Länge verworfen worden, entfernt die Zykluserkennung sie. Wurde sie abgelehnt, rast sie in einer Endlosschleife mit voller Geschwindigkeit durch den Consumer, lastet die CPU aus und füllt die Logs.

Unbegrenzte Retries. Ohne Obergrenze für Versuche kreist eine Nachricht, die nie erfolgreich sein wird, endlos und kostet in jeder Runde Consumer-Kapazität. Mit at-least-once und reject-publish kann sie sich zudem in die Quell-Queue zurückstauen.

Gespiegelte Classic Queues als Träger des DLX unter 4.x. Das Mirroring von Classic Queues wurde in RabbitMQ 4.0 entfernt, und ha-*-Policy-Keys werden nicht mehr berücksichtigt. Eine Dead-Letter-Queue, die unter 3.x repliziert war, wird nach dem Upgrade zu einer Classic Queue auf einem einzigen Node – fällt dieser Node aus, sind die Belege mit ihm verloren. Stellen Sie Dead-Letter-Queues vor dem Upgrade auf Quorum Queues um.

TTL auf der DLQ selbst. Eine message-ttl von einer Woche auf dem Parking Lot, „damit es ordentlich bleibt“, löscht genau die Nachrichten, die eine Untersuchung braucht. Leitet der Parking Lot zudem per Dead-Lettering zurück an die Work Queue, baut die TTL einen reinen Ablaufzyklus, den die Zykluserkennung stillschweigend verwirft.

Zwei kleinere: den Body protokollieren und bestätigen statt parken – damit wird eine Logzeile wie eine Queue behandelt; und den Parking-Lot-Consumer im selben Prozess wie den Work-Consumer betreiben, sodass der Fehler, der den Parking Lot füllt, auch das lahmlegt, was ihn leeren soll.

Wie es weitergeht

Dead-Lettering baut auf dem Routing auf, und ein DLX ist nur so sinnvoll wie das Exchange-Design drumherum. Unser Leitfaden zu Exchanges, Queues und Bindings für Microservices behandelt dieses Thema. Wenn die Frage nach dem Queue-Typ noch offen ist, hilft Classic Queues vs. Quorum Queues bei der Entscheidung; alles hier setzt für alles Wichtige Quorum Queues voraus. Zu den grundlegenden Fehlerbildern, die einen Parking Lot überhaupt erst füllen, lesen Sie die zehn häufigsten Probleme bei der RabbitMQ-Fehlerbehebung.

Wenn sich Ihre Dead-Letter-Queues füllen und Sie nicht sicher sind, warum – oder wenn Sie das Upgrade auf 4.x planen und die DLX-Topologie prüfen lassen möchten, bevor gespiegelte Queues keine Option mehr sind –, dann ist das genau unsere Arbeit. AceMQ ist der einzige von Broadcom ernannte RabbitMQ-MSP-Partner, unterstützt RabbitMQ 3.8.x bis 4.x und reagiert auf P1-Incidents mit Reaktionszeitzielen ab 15 Minuten, je nach Plan. Sehen Sie sich unsere RabbitMQ-Supportpläne an oder lesen Sie mehr darüber, wie wir mit RabbitMQ arbeiten.

FAQ

Was ist der Unterschied zwischen einem Dead-Letter-Exchange und einer Dead-Letter-Queue?

Ein Dead-Letter-Exchange ist der Exchange, an den eine Queue eine Nachricht neu veröffentlicht, wenn sie sie per Dead-Lettering aussortiert. Er ist ein gewöhnlicher Exchange ohne besonderen Typ. Eine Dead-Letter-Queue ist jede Queue, die an diesen Exchange gebunden ist; der Name ist eine Konvention, kein Konzept des Brokers. RabbitMQ kennt nur den Exchange – wo die Nachricht landet, hängt von den Bindings ab, die Sie deklariert haben. Diese Trennung ist nützlich: Ein DLX kann per Fan-out sowohl einen Parking Lot für das Replay als auch eine Audit-Queue für die Analyse beliefern oder die Fehler jedes Teams anhand des ursprünglichen Routing Keys in eine eigene Queue leiten.

Werden in RabbitMQ nicht routbare Nachrichten per Dead-Lettering aussortiert?

Nein. Dead-Lettering betrifft nur Nachrichten, die bereits in einer Queue lagen und abgelehnt wurden, abgelaufen sind, wegen der Längenbegrenzung verworfen wurden oder das Delivery Limit einer Quorum Queue überschritten haben. Eine Nachricht, die an einen Exchange ohne passendes Binding veröffentlicht wird, wird beim Publish verworfen – es sei denn, der Publisher hat das mandatory-Flag gesetzt; dann geht sie an den Publisher zurück. Oder für den Exchange ist ein Alternate Exchange konfiguriert; dann wird sie dorthin geroutet. Wenn Ihnen nicht routbare Nachrichten wichtig sind, konfigurieren Sie einen Alternate Exchange mit eigener Queue und überwachen Sie ihn genauso wie eine Dead-Letter-Queue.

Wie zähle ich Wiederholungsversuche in RabbitMQ?

Lesen Sie den Header x-death aus. Jeder Eintrag steht für ein Paar aus Queue und Grund, und sein Feld count erhöht sich jedes Mal, wenn diese Queue die Nachricht aus diesem Grund per Dead-Lettering aussortiert. Bei einer Retry-Schleife mit Wait Queue suchen Sie den Eintrag, dessen queue Ihre Work Queue und dessen reason rejected ist; sein Count ist die Zahl der bisherigen Versuche. Bei Quorum Queues zählt der separate Header x-delivery-count erneute Zustellungen innerhalb einer Queue und erfasst damit Abstürze und Requeues statt expliziter Ablehnungen. Setzen Sie die Obergrenze im Consumer durch und parken Sie die Nachricht bei Erreichen der Grenze mit einem expliziten, bestätigten Publish.

Kann ich einen Dead-Letter-Exchange mit Quorum Queues verwenden?

Ja, und Quorum Queues bringen zwei Dinge mit, die Classic Queues nie hatten. Die Policy delivery-limit begrenzt erneute Zustellungen und sortiert die Nachricht bei Überschreitung per Dead-Lettering aus; ab RabbitMQ 4.0 liegt der Standard bei 20. Konfigurieren Sie also einen DLX, sonst werden diese Nachrichten verworfen. Der Policy-Key dead-letter-strategy lässt sich auf at-least-once setzen. Dann bleiben aussortierte Nachrichten in der Quell-Queue, bis die Ziel-Queue sie bestätigt hat. Voraussetzung ist, dass overflow auf reject-publish steht. Sowohl die Quell-Queue als auch idealerweise die Dead-Letter-Queue selbst sollten Quorum Queues sein, damit die Belege für den Fehler repliziert werden.

Was passiert, wenn der Dead-Letter-Exchange nicht existiert?

Der Broker prüft den Namen des Exchanges weder bei der Deklaration der Queue noch beim Anwenden der Policy, die Konfiguration wird also stillschweigend akzeptiert. Mit der Standardstrategie at-most-once wird jede aussortierte Nachricht verworfen – ohne Fehler und ohne Logzeile. Das ist eine der unauffälligsten Arten, in RabbitMQ Daten zu verlieren. Mit at-least-once auf einer Quorum Queue bleiben aussortierte Nachrichten in der Quell-Queue, bis der Exchange existiert und die Ziel-Queue sie bestätigt; stattdessen wächst also die Quell-Queue. Deklarieren Sie den DLX und seine Queue in den Definitions und alarmieren Sie bei jeder Dead-Letter-Rate, der kein entsprechendes Wachstum der DLQ gegenübersteht.

Sollte ich eine TTL für meine Dead-Letter-Queue setzen?

Nein. Eine message-ttl auf dem Parking Lot löscht genau die Nachrichten, die Sie aufbewahrt haben, damit jemand sie prüfen und erneut einspielen kann – und zwar nach einem Timer, der nichts damit zu tun hat, ob das eigentliche Problem behoben wurde. Leitet der Parking Lot zudem per Dead-Lettering zurück an die Work Queue, entsteht durch den Ablauf ein Zyklus ohne Ablehnung, den der Broker stillschweigend verwirft. Regeln Sie die Aufbewahrung mit einem Archivierungs-Consumer, der alte Nachrichten in dauerhaften Speicher verschiebt und sie bestätigt, begrenzen Sie die Queue mit max-length-bytes und reject-publish und alarmieren Sie bei Tiefe und Alter.

Scott Sternloff

Autor

Scott SternloffSenior Enterprise Architect

Senior Enterprise Architect bei AceMQ. Verantwortet hier die technischen Beiträge: Architektur, Clustering und Migrationen von RabbitMQ, Kafka und Redis.

Mit einem Engineer sprechen

Brauchen Sie Unterstützung bei RabbitMQ?

Senior Engineers, die es selbst in Produktion betreiben. Fordern Sie ein Angebot oder ein kostenloses Erstgespräch an – ganz ohne Verkaufsgespräch.

Leitfäden, Vergleiche und Studien

Mehr zum Thema RabbitMQ

Kostenlose Beratung

Lassen Sie Experten auf Ihre RabbitMQ-Cluster-Umgebung schauen

Ob Sie einen Produktionsvorfall beheben, eine Migration planen oder eine zweite Meinung zu Ihrer Architektur wünschen – unser Team steht bereit. Kein Verkaufsgespräch, nur Antworten.

E-Mail schreiben