On this page
Il dead-lettering è il meccanismo con cui RabbitMQ sposta un messaggio che non riesce più a consegnare in un punto dove potete gestirlo. Configurato bene, trasforma un payload difettoso in un ticket. Configurato male, è il modo più comune in cui vediamo sparire senza lasciare traccia i messaggi di produzione. Questa guida tratta il meccanismo così come si comporta su RabbitMQ 3.13 e 4.x, i pattern di retry costruiti su di esso e le abitudini operative che mantengono affidabile una dead letter queue.
Che cos'è esattamente il dead-lettering
Una coda manda un messaggio in dead-letter per esattamente quattro motivi:
- Un consumer lo ha rifiutato con
basic.rejectobasic.nackerequeue=false. - È scaduto il suo TTL per messaggio, o il
message-ttldella coda. - La coda aveva superato il limite
max-lengthomax-length-bytese ha scartato il messaggio in testa. È il comportamento di overflow predefinitodrop-head; conreject-publishil broker rifiuta invece la nuova pubblicazione e nulla finisce in dead-letter. - Su una coda quorum, il messaggio è stato restituito alla coda più volte di quanto consenta il suo
delivery-limit.
Il broker li registra come rejected, expired, maxlen e delivery_limit. Nient'altro conta. Una coda che scade tramite x-expires viene eliminata insieme al suo contenuto. Un purge scarta i messaggi. Nemmeno un messaggio che il broker non riesce a instradare al momento della pubblicazione finisce in dead-letter: quello è compito del flag mandatory o di un alternate exchange.
Un dead letter exchange (DLX) è un exchange ordinario. Non esiste un tipo speciale né un flag nella dichiarazione. È semplicemente l'exchange su cui una coda ripubblica quando manda in dead-letter, usando la dead-letter-routing-key della coda se impostata e, in caso contrario, la routing key originale del messaggio. Proprio perché è ordinario, potete smistare in fan-out verso una coda di parcheggio e una coda di audit, instradare per chiave originale tramite un topic exchange o inviare i fallimenti di ciascun team alla sua coda. Una "dead letter queue" è semplicemente la coda che avete collegato a quell'exchange.
Durante la ripubblicazione, sul messaggio cambiano due cose. La proprietà expiration viene azzerata, così un messaggio già scaduto una volta non scade di nuovo immediatamente; il valore originale viene conservato in x-death come original-expiration. E l'header x-death viene aggiunto o aggiornato. Body, message id, correlation id e tutte le altre proprietà restano intatti.
Configurare il dead letter exchange: argomenti o policy
Un DLX si può associare a una coda in due modi. Gli argomenti della coda vengono impostati dal client al momento della dichiarazione:
{
"x-queue-type": "quorum",
"x-dead-letter-exchange": "orders.retry",
"x-dead-letter-routing-key": "order.failed"
}Le policy impostano lo stesso comportamento lato broker con le chiavi dead-letter-exchange e dead-letter-routing-key, associate alle code tramite un pattern sul nome.
Meglio le policy. Gli argomenti della coda sono immutabili: per cambiare un DLX impostato come argomento bisogna eliminare la coda e dichiararla di nuovo, il che significa svuotarla prima e coordinare tutti i client che la dichiarano. Le policy si modificano a runtime, si applicano a tutte le code corrispondenti, finiscono negli export delle definitions e stanno in un unico punto leggibile da chi gestisce il broker. Quando sono presenti entrambi, vince l'argomento, ed è il secondo motivo per evitare gli argomenti: un'applicazione che imposta x-dead-letter-exchange fissa un valore che il team operativo non può sovrascrivere senza un deploy. L'eccezione è x-queue-type, che deve essere un argomento, e va bene così perché il tipo di una coda non cambia mai.
Una trappola: a una coda si applica una sola policy, quella corrispondente con la priorità più alta. Se definite una policy per il dead-lettering e un'altra per max-length o delivery-limit sulle stesse code, ne avrà effetto solo una. Inserite tutte le chiavi di cui una coda ha bisogno nella stessa definizione di policy.
Quando il broker manda un messaggio in dead-letter, aggiunge una voce all'header x-death, un array con una voce per ogni coppia coda-motivo. Se la stessa coda manda di nuovo in dead-letter lo stesso messaggio per lo stesso motivo, il count di quella voce si incrementa e la voce si sposta in testa all'array. Ogni voce registra la coda, il motivo, l'exchange e le routing key del messaggio, un timestamp e, quando è coinvolto il TTL, original-expiration. Il broker imposta inoltre una sola volta x-first-death-reason, x-first-death-queue e x-first-death-exchange, e mantiene aggiornati gli equivalenti x-last-death-*. Un esempio di header dopo tre giri di un ciclo di 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: ordersIl dead-lettering può formare un ciclo, e il broker applica una sola regola: se un messaggio raggiunge due volte la stessa coda e nessun passaggio del ciclo è stato un rifiuto, il messaggio viene scartato. Se almeno un passaggio è stato un rifiuto da parte di un consumer, il ciclo continua. Per questo i cicli di retry basati su requeue=false funzionano, perché ogni giro include un rifiuto, mentre un ciclo costruito solo sul TTL, come una coda di parcheggio con un message-ttl che rimanda in dead-letter verso la coda di lavoro, scarta silenziosamente i messaggi al secondo giro.
Le code quorum cambiano le regole
Le code quorum contano le riconsegne nell'header x-delivery-count, e la chiave di policy delivery-limit (o l'argomento x-delivery-limit) ne fissa il limite. Oltre il limite, la coda manda il messaggio in dead-letter se è configurato un DLX e lo scarta in caso contrario. A partire da RabbitMQ 4.0 il delivery limit predefinito è 20; prima era illimitato.
È proprio questo valore predefinito a sorprendere i team che migrano dalle code classiche. Un consumer che intercetta un'eccezione e chiama basic.nack con requeue=true, su una coda classica, girava all'infinito, sprecando CPU ma senza perdere nulla. Su una coda quorum 4.x senza DLX, lo stesso codice scarta il messaggio dopo 20 tentativi, e l'unica traccia è un contatore. Impostate delivery-limit su un valore scelto da voi e abbinatelo sempre a un DLX.
Le code quorum supportano inoltre due strategie di dead-lettering tramite la chiave di policy dead-letter-strategy. Quella predefinita, at-most-once, ripubblica senza conferma. Se il DLX non esiste, o la coda di destinazione non è disponibile o rifiuta il messaggio, il messaggio è perso. È la garanzia che le code classiche hanno sempre avuto.
at-least-once trattiene il messaggio in dead-letter nella coda di origine finché tutte le code collegate al DLX non lo hanno confermato. Richiede una coda di origine quorum, overflow impostato su reject-publish e un DLX. Internamente il leader della coda esegue un worker di dead-letter, che la documentazione chiama dead-letter consumer: legge i messaggi in dead-letter dalla coda di origine, li pubblica sul DLX con conferma e ritenta tutto ciò che non è stato confermato. Ne derivano tre conseguenze. Se il DLX manca o la destinazione non è raggiungibile, i messaggi si accumulano nella coda di origine, pesando sulla sua lunghezza e sul disco, e questo è voluto. Poiché la consegna è at-least-once, la DLQ può ricevere duplicati. E il dead-letter consumer interno è un meccanismo del broker, non la vostra applicazione: sulla dead letter queue serve comunque un consumer vero.
| Comportamento | Coda classica | Coda quorum |
|---|---|---|
| Limite di riconsegna | Nessuno, i cicli di requeue girano all'infinito | delivery-limit, predefinito 20 in 4.x, poi DLX o scarto |
| Conteggio delle riconsegne | Solo il flag redelivered | Header x-delivery-count |
| Strategia di dead-lettering | Solo at-most-once | at-most-once o at-least-once |
| Replica | Mirroring rimosso in 4.0 | Replica Raft per progettazione |
| Overflow predefinito | drop-head | drop-head; reject-publish obbligatorio per at-least-once |
Pattern di retry che non perdono messaggi
Il ciclo di retry di base usa una coda di attesa. Il DLX della coda di lavoro è un exchange di retry, che instrada verso una coda di attesa con un message-ttl a livello di coda e nessun consumer. Il DLX della coda di attesa è l'exchange di lavoro, senza dead-letter-routing-key, così il messaggio rientra con la sua routing key originale. Un consumer che incontra un errore transitorio rifiuta con requeue=false; il messaggio attende la scadenza del TTL e torna indietro. Il consumer legge il numero di tentativi dalla voce di x-death relativa alla coda di lavoro con motivo rejected e, al raggiungimento del limite, sposta il messaggio in una coda di parcheggio invece di rifiutarlo di nuovo.
Per il backoff esponenziale, usate una coda di attesa per ogni livello di ritardo: wait.10s, wait.1m, wait.10m. Non fatelo con TTL per messaggio in un'unica coda. I messaggi scaduti vengono rimossi solo dalla testa della coda, sia nelle code classiche sia nelle quorum, quindi un messaggio da dieci minuti in testa blocca un messaggio da dieci secondi che gli sta dietro. Con code a livelli, il consumer sceglie il livello in base al numero di tentativi, pubblica sull'exchange di retry con la routing key di quel livello, attende il publisher confirm e solo allora invia l'ack del messaggio originale. Inviare l'ack prima che arrivi la conferma è il punto in cui i retry gestiti dal consumer perdono messaggi. Mantenete comunque il DLX sulla coda di lavoro come rete di sicurezza per delivery-limit.
L'alternativa è il plugin delayed message exchange: si pubblica con un header x-delay e l'exchange trattiene il messaggio fino allo scadere del ritardo. Il compromesso riguarda la durabilità. I messaggi ritardati risiedono in uno store locale sul nodo che ospita l'exchange e non vengono replicati, quindi perdere quel nodo significa perdere tutti i messaggi in sospeso, e un grande backlog di messaggi in sospeso degrada le prestazioni del plugin. Inoltre non c'è nessuna coda da ispezionare. Per pochi ritardi brevi è comodo; per un backlog di retry che potreste dover esaminare alle 3 di notte, le code di attesa sono noiose, visibili e replicate se dichiarate come code quorum.
I retry servono solo per gli errori transitori. Un messaggio che fallisce in modo deterministico, perché il payload è malformato o fa riferimento a un record inesistente, deve andare direttamente nella coda di parcheggio, quindi nel consumer distinguete le eccezioni ritentabili da quelle non ritentabili. E ogni meccanismo descritto in questa pagina può consegnare due volte lo stesso messaggio: retry, replay e dead-lettering at-least-once garantiscono la consegna, non l'unicità. I consumer devono essere idempotenti, con chiave sul message id o su una chiave di business, altrimenti un retry trasforma un fallimento in un doppio addebito.
Esempio pratico: elaborazione degli ordini con una coda di attesa e una coda di parcheggio
La topologia:
- Exchange
orders(topic) con la coda quorumorders.workcollegata suorder.*. - Exchange
orders.retry(fanout) con la coda quorumorders.wait.30s, TTL di 30 secondi, con dead-lettering di ritorno versoorders. - Exchange
orders.dlx(fanout) con la coda quorumorders.parking, senza TTL e senza automazioni.
Bastano due policy:
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 10Il consumer applica il limite di tentativi e parcheggia esplicitamente, pubblicando con conferma prima di inviare l'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 parkOgni elemento protegge da qualcosa di specifico. Un crash durante l'elaborazione rimette il messaggio in coda; cinque di fila fanno scattare delivery-limit e il messaggio va nella coda di attesa invece di essere scartato. Un errore transitorio attende 30 secondi e torna, fino a tre tentativi. Un errore permanente viene parcheggiato al primo riscontro. Il dead-lettering at-least-once fa sì che il passaggio di retry non possa perdere un messaggio se orders.wait.30s è temporaneamente non disponibile.
Gestire una dead letter queue in esercizio
Una dead letter queue è utile solo se qualcuno sa quando si riempie. Quattro segnali coprono quasi tutto.
Profondità: rabbitmq_queue_messages per la coda di parcheggio e per ogni coda di attesa, dal plugin Prometheus con metriche per oggetto o dalla famiglia queue_coarse_metrics dell'endpoint dettagliato. Tasso, che rileva i cambiamenti prima della profondità: i contatori rabbitmq_global_messages_dead_lettered_*_total suddividono il dead-lettering per motivo e, per at-least-once, per conferma. Numero di consumer, che indica se la topologia è integra: rabbitmq_queue_consumers deve essere diverso da zero sulla coda di parcheggio ed esattamente zero su ogni coda di attesa, perché un consumer su una coda di attesa annulla il ritardo. Età, che RabbitMQ non espone direttamente; si può approssimare dall'header x-parked-at o dal campo time in x-death quando si campiona la coda.
Soglie di partenza, da adattare al servizio:
- Qualsiasi dead-lettering su una coda che di norma non ne ha: warning immediato, il primo caso è il più economico da analizzare.
- Tasso di dead-lettering superiore all'uno per cento del tasso di pubblicazione su cinque minuti: chiamata al reperibile.
- Contatore
delivery_limitin aumento, anche di poco: da indagare, significa consumer che vanno in crash o cicli di requeue, non fallimenti di business. - Profondità della coda di parcheggio oltre una soglia commisurata alla vostra capacità di esaminare i messaggi, o in crescita continua per 30 minuti: chiamata al reperibile.
- Zero consumer sulla coda di parcheggio per dieci minuti, o qualsiasi consumer su una coda di attesa: alert.
- Profondità della coda di origine in aumento mentre la DLQ resta piatta, con
at-least-onceconfigurato: il DLX o la sua destinazione non funzionano.
Al momento del parcheggio registrate nei log ciò che il broker non registra: classe e messaggio dell'eccezione, host e build del consumer, message id e correlation id, exchange e routing key originali da x-death e numero di tentativi. Il broker sa perché un messaggio è finito in dead-letter; solo il consumer sa che cosa è andato storto. Allegate il motivo anche come header, come fa l'esempio con x-parked-reason, così chi aprirà la coda in seguito potrà leggerlo senza incrociare i log. Non registrate i body completi, a meno che non siano piccoli e privi di dati sensibili. Il body è già nella coda.
Rielaborare i messaggi in sicurezza
Il replay consiste nel ripubblicare i messaggi parcheggiati sull'exchange di lavoro. Prima si corregge la causa. Fare il replay verso un consumer non ancora corretto crea un ciclo tra la coda di parcheggio e la coda di lavoro, con una persona nel mezzo.
Lo strumento più semplice è uno shovel dinamico dalla coda di parcheggio all'exchange di lavoro, creato con rabbitmqctl set_parameter shovel. Usate ack-mode con valore on-confirm, così un messaggio lascia la coda di parcheggio solo dopo che la coda di lavoro lo ha confermato; impostate dest-exchange sull'exchange di lavoro e lasciate dest-exchange-key non impostato, così viene usata la routing key originale; e impostate src-delete-after su queue-length, così lo shovel svuota ciò che era presente al suo avvio e poi si rimuove da solo. L'azione di spostamento dei messaggi della management UI è, dietro le quinte, uno shovel. Uno shovel rielabora tutto in ordine senza filtri, e x-death continua ad accumularsi, ed è proprio ciò che serve: un messaggio che fallisce di nuovo torna nella coda di parcheggio con una cronologia più lunga.
Quando serve una selezione, usate un consumer di replay: un piccolo strumento che consuma dalla coda di parcheggio con un prefetch contenuto, filtra per header, orario o id, pubblica con conferma e invia l'ack dopo ogni conferma. Limitatene la velocità, perché una coda di parcheggio riempita nel fine settimana può travolgere un database a valle il lunedì mattina. Se volete che il conteggio dei tentativi riparta da zero, lo strumento può rimuovere x-death, ma al suo posto dovrebbe registrare un header x-replay-count.
Non ripubblicate da uno script improvvisato senza conferme, non fate replay nelle ore di punta e non rielaborate un lotto di messaggi di cui non avete individuato la causa principale.
Retention e disco
Una coda di parcheggio è uno stato durevole. Su una coda quorum ogni messaggio viene scritto nel log Raft e nei file di segmento di ogni membro, quindi una coda con tre membri conserva tre copie per tutto il tempo in cui il messaggio vi resta. I messaggi in dead-letter tendono a essere quelli più grandi, e tendono a restare lì per giorni. Pianificate il disco.
Limitate la coda di parcheggio con max-length-bytes e overflow impostato su reject-publish, non su drop-head. drop-head scarta silenziosamente le evidenze più vecchie quando la coda si riempie. reject-publish rende rumorosa una coda di parcheggio piena: il dead-lettering verso di essa fallisce, la coda di origine at-least-once trattiene il suo backlog e gli alert scattano. Rumoroso è il comportamento corretto.
Non impostate message-ttl sulla coda di parcheggio. La retention spetta a un consumer di archiviazione che sposta i messaggi più vecchi della vostra finestra di revisione su object storage o in una tabella di database e ne invia l'ack, in modo che la coda resti una casella di arrivo e non un archivio. Il guasto che si evita così è reale: una coda di parcheggio che nessuno svuota cresce finché il nodo non supera la soglia dell'allarme di spazio libero su disco, e l'allarme disco blocca tutti i publisher del nodo, trasformando un lento accumulo di fallimenti in un disservizio dell'intero cluster.
Anti-pattern che vediamo in produzione
Una DLQ senza consumer e senza alert. I messaggi si accumulano finché non scatta l'allarme disco o finché qualcuno non trova la coda durante un incidente non correlato, mesi dopo. Se non vi accorgereste della crescita della coda, avete configurato una perdita con qualche passaggio in più.
Il dead-lettering verso l'exchange a cui la coda è già collegata, senza cambiare routing key. Il messaggio torna nella stessa coda. Se era scaduto o era stato scartato per lunghezza, il rilevamento dei cicli lo elimina. Se era stato rifiutato, gira in un ciclo serrato attraverso il consumer alla massima velocità, saturando la CPU e riempiendo i log.
Retry illimitati. Senza un limite di tentativi, un messaggio che non andrà mai a buon fine circola all'infinito, consumando capacità dei consumer a ogni giro, e con at-least-once e reject-publish può rifluire nella coda di origine.
Code classiche con mirroring che trasportano il DLX in 4.x. Il mirroring delle code classiche è stato rimosso in RabbitMQ 4.0 e le chiavi di policy ha-* non vengono più rispettate. Una dead letter queue replicata su 3.x diventa, dopo l'aggiornamento, una coda classica su un solo nodo, e se quel nodo si guasta le evidenze se ne vanno con lui. Convertite le dead letter queue in code quorum prima dell'aggiornamento.
Un TTL sulla DLQ stessa. Un message-ttl di una settimana sulla coda di parcheggio "per tenerla in ordine" elimina esattamente i messaggi che servono a un'indagine e, se la coda di parcheggio rimanda a sua volta in dead-letter verso la coda di lavoro, il TTL crea un ciclo di sole scadenze che il rilevamento dei cicli scarta silenziosamente.
Due più piccoli: registrare il body nei log e inviare l'ack invece di parcheggiare, il che tratta una riga di log come se fosse una coda; ed eseguire il consumer della coda di parcheggio nello stesso processo del consumer di lavoro, così il guasto che riempie la coda di parcheggio mette fuori uso anche ciò che dovrebbe svuotarla.
Dove proseguire
Il dead-lettering poggia sul routing, e un DLX è sensato solo quanto la progettazione degli exchange che lo circonda. La nostra guida a exchange, code e binding per i microservizi tratta questo argomento. Se non avete ancora risolto la questione del tipo di coda, code classiche e code quorum a confronto affronta la decisione; tutto ciò che è scritto qui presuppone code quorum per qualsiasi cosa sia importante. Per le modalità di guasto più ampie che riempiono una coda di parcheggio, consultate i dieci problemi più comuni di troubleshooting di RabbitMQ.
Se le vostre dead letter queue si stanno riempiendo e non sapete bene perché, o se state pianificando l'aggiornamento a 4.x e volete far rivedere la topologia dei DLX prima che le code con mirroring smettano di essere un'opzione, è esattamente il nostro lavoro. AceMQ è l'unico partner MSP RabbitMQ nominato da Broadcom, supporta RabbitMQ dalla 3.8.x alla 4.x e risponde agli incidenti P1 con obiettivi di risposta da 15 minuti, in base al piano. Consultate i nostri piani di supporto RabbitMQ o scoprite di più su come lavoriamo con RabbitMQ.
Domande frequenti
Che differenza c'è tra un dead letter exchange e una dead letter queue?
Un dead letter exchange è l'exchange su cui una coda ripubblica un messaggio quando lo manda in dead-letter. È un exchange ordinario, senza un tipo speciale. Una dead letter queue è qualsiasi coda collegata a quell'exchange, e il nome è una convenzione, non un concetto del broker. RabbitMQ conosce soltanto l'exchange; dove finisce il messaggio dipende dai binding che avete dichiarato. Questa separazione è utile: un solo DLX può smistare in fan-out verso una coda di parcheggio per il replay e una coda di audit per l'analisi, oppure instradare i fallimenti di ciascun team verso la sua coda in base alla routing key originale.
RabbitMQ manda in dead-letter i messaggi che non possono essere instradati?
No. Il dead-lettering si applica solo ai messaggi che erano già in una coda e che sono stati rifiutati, sono scaduti, sono stati scartati per superamento della lunghezza massima o hanno superato il delivery limit di una coda quorum. Un messaggio pubblicato su un exchange senza binding corrispondenti viene scartato al momento della pubblicazione, a meno che il publisher non abbia impostato il flag mandatory, nel qual caso viene restituito al publisher, o che l'exchange non abbia un alternate exchange configurato, nel qual caso viene instradato lì. Se i messaggi non instradabili sono importanti per voi, configurate un alternate exchange con una coda dedicata e monitoratelo come una dead letter queue.
Come si contano i retry in RabbitMQ?
Leggendo l'header x-death. Ogni voce rappresenta una coppia coda-motivo, e il suo campo count si incrementa ogni volta che quella coda manda il messaggio in dead-letter per quel motivo. In un ciclo di retry con coda di attesa, cercate la voce il cui queue è la vostra coda di lavoro e il cui reason è rejected: il suo count è il numero di tentativi effettuati finora. Sulle code quorum, l'header separato x-delivery-count conta le riconsegne all'interno di una singola coda, quindi registra crash e requeue anziché rifiuti espliciti. Applicate il limite nel consumer e, quando viene raggiunto, parcheggiate il messaggio con una pubblicazione esplicita e confermata.
Si può usare un dead letter exchange con le code quorum?
Sì, e le code quorum aggiungono due cose che le code classiche non hanno mai avuto. La policy delivery-limit limita le riconsegne e manda il messaggio in dead-letter quando il limite viene superato, con un valore predefinito di 20 a partire da RabbitMQ 4.0: configurate quindi un DLX, altrimenti quei messaggi vengono scartati. La chiave di policy dead-letter-strategy può essere impostata su at-least-once, che trattiene i messaggi in dead-letter nella coda di origine finché la coda di destinazione non li conferma. Questo richiede che overflow sia reject-publish. Sia la coda di origine sia, idealmente, la dead letter queue stessa dovrebbero essere code quorum, così le evidenze dei fallimenti vengono replicate.
Che cosa succede se il dead letter exchange non esiste?
Il broker non convalida il nome dell'exchange quando la coda viene dichiarata o la policy viene applicata, quindi la configurazione viene accettata senza segnalazioni. Con la strategia predefinita at-most-once, ogni messaggio mandato in dead-letter viene scartato, senza errori e senza una riga di log: è uno dei modi più silenziosi di perdere dati in RabbitMQ. Con at-least-once su una coda quorum, i messaggi in dead-letter vengono trattenuti nella coda di origine finché l'exchange non compare e la coda di destinazione non li conferma, quindi a crescere è la coda di origine. Dichiarate il DLX e la sua coda nelle definitions e impostate un alert su qualsiasi tasso di dead-lettering che non corrisponda a una crescita della DLQ.
Conviene impostare un TTL sulla dead letter queue?
No. Un message-ttl sulla coda di parcheggio elimina proprio i messaggi che avete conservato perché qualcuno potesse esaminarli e rielaborarli, e li elimina in base a un timer che non ha nulla a che fare con la risoluzione del problema di fondo. Se la coda di parcheggio rimanda a sua volta in dead-letter verso la coda di lavoro, la scadenza crea un ciclo senza alcun rifiuto, che il broker scarta silenziosamente. Gestite la retention con un consumer di archiviazione che sposta i messaggi vecchi su uno storage durevole e ne invia l'ack, limitate la coda con max-length-bytes e reject-publish e impostate alert su profondità ed età.
Talk to an engineer
Need a hand with RabbitMQ?
Senior engineers who run it in production. Get a quote or a free consultation, no sales pitch.
Guide, confronti e ricerche


