BlogueRabbitMQ

Dead letter queues no RabbitMQ: o guia empresarial

Scott Sternloff

Por Scott Sternloff, Arquiteto empresarial sénior

LinkedIn · Atualizado a · 19 min de leitura

Dead letter queues no RabbitMQ: o guia empresarial
On this page

O dead-lettering é a forma como o RabbitMQ move uma mensagem que já não consegue entregar para um sítio onde a possa tratar. Bem configurado, transforma um payload defeituoso num ticket. Mal configurado, é a forma mais comum de vermos mensagens de produção desaparecer sem deixar rasto. Este guia aborda o mecanismo tal como se comporta no RabbitMQ 3.13 e 4.x, os padrões de novas tentativas construídos sobre ele e os hábitos operacionais que mantêm uma dead letter queue fiável.

O que é exatamente o dead-lettering

Uma fila faz o dead-lettering de uma mensagem por exatamente quatro motivos:

  1. Um consumidor rejeitou-a com basic.reject ou basic.nack e requeue=false.
  2. O seu TTL por mensagem, ou o message-ttl da fila, expirou.
  3. A fila estava acima do limite de max-length ou max-length-bytes e descartou a mensagem da cabeça. Este é o comportamento de overflow predefinido, drop-head; com reject-publish, o broker recusa antes a nova publicação e nada vai para dead-letter.
  4. Numa fila de quórum, a mensagem foi devolvida à fila mais vezes do que o seu delivery-limit permite.

O broker regista estes motivos como rejected, expired, maxlen e delivery_limit. Mais nada conta. Uma fila que expira via x-expires é apagada com o seu conteúdo. Um purge descarta mensagens. Uma mensagem que o broker não consegue encaminhar no momento da publicação também não vai para dead-letter; isso é tarefa da flag mandatory ou de uma alternate exchange.

Uma dead letter exchange (DLX) é uma exchange normal. Não há nenhum tipo especial nem nenhuma flag na declaração. É simplesmente a exchange para a qual uma fila republica quando faz dead-lettering, usando a dead-letter-routing-key da fila, se estiver definida, ou caso contrário a routing key original da mensagem. Por ser normal, pode distribuir para uma fila de parking lot e uma fila de auditoria, encaminhar pela chave original através de uma topic exchange ou enviar as falhas de cada equipa para a sua própria fila. Uma “dead letter queue” é apenas a fila que ligou a ela por binding.

Há duas coisas que mudam na mensagem quando é republicada. A propriedade expiration é limpa, para que uma mensagem que expirou uma vez não volte a expirar de imediato; o valor original fica preservado em x-death como original-expiration. E o cabeçalho x-death é acrescentado ou atualizado. O corpo, o message id, o correlation id e todas as outras propriedades mantêm-se intactos.

Configurar a dead letter exchange: arguments versus políticas

Pode associar uma DLX a uma fila de duas formas. Os queue arguments são definidos pelo cliente no momento da declaração:

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

As políticas definem o mesmo comportamento do lado do broker com as chaves dead-letter-exchange e dead-letter-routing-key, associadas às filas através de um padrão de nome.

Prefira as políticas. Os queue arguments são imutáveis: para alterar uma DLX definida como argument, tem de apagar a fila e voltar a declará-la, o que obriga a esvaziá-la primeiro e a coordenar todos os clientes que a declaram. As políticas mudam em tempo de execução, aplicam-se a todas as filas correspondentes, ficam nas exportações de definitions e estão num único sítio que um operador consegue ler. Quando existem ambos, prevalece o argument, e esse é o segundo motivo para evitar arguments: uma aplicação que define x-dead-letter-exchange fixa um valor que a equipa de operações não consegue alterar sem um deploy. A exceção é x-queue-type, que tem de ser um argument, e não há problema nisso porque o tipo de uma fila nunca muda.

Uma armadilha: só se aplica uma política a cada fila, a correspondência de maior prioridade. Se definir uma política para o dead-lettering e outra para max-length ou delivery-limit nas mesmas filas, só uma entra em vigor. Coloque todas as chaves de que uma fila precisa na mesma definição de política.

Quando o broker faz o dead-lettering de uma mensagem, acrescenta uma entrada ao cabeçalho x-death, um array com uma entrada por par fila-motivo. Se a mesma fila voltar a fazer o dead-lettering da mesma mensagem pelo mesmo motivo, o count dessa entrada é incrementado e a entrada passa para o início do array. Cada entrada regista a fila, o motivo, a exchange e as routing keys que a mensagem transportava, um timestamp e, quando houve TTL envolvido, original-expiration. O broker também define x-first-death-reason, x-first-death-queue e x-first-death-exchange uma única vez e mantém atualizados os equivalentes x-last-death-*. Um cabeçalho ilustrativo após três voltas de um ciclo de novas tentativas:

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

O dead-lettering pode formar um ciclo, e o broker tem uma regra para isso: se uma mensagem chega duas vezes à mesma fila e nenhum salto do ciclo foi uma rejeição, a mensagem é descartada. Se algum salto foi uma rejeição de um consumidor, o ciclo continua. Assim, os ciclos de novas tentativas baseados em requeue=false funcionam, porque cada volta inclui uma rejeição, ao passo que um ciclo construído apenas com TTL, como um parking lot com um message-ttl que faz dead-lettering de volta para a fila de trabalho, descarta mensagens em silêncio na segunda volta.

As filas de quórum mudam as regras

As filas de quórum contam as reentregas no cabeçalho x-delivery-count, e a chave de política delivery-limit (ou o argument x-delivery-limit) impõe-lhe um limite. Ultrapassado o limite, a fila faz o dead-lettering da mensagem se houver uma DLX configurada e descarta-a se não houver. A partir do RabbitMQ 4.0, o delivery limit predefinido é 20; antes disso era ilimitado.

É esta predefinição que surpreende as equipas que migram de filas clássicas. Um consumidor que apanha uma exceção e chama basic.nack com requeue=true ficava a girar para sempre numa fila clássica, a desperdiçar CPU mas sem perder nada. Numa fila de quórum 4.x sem DLX, o mesmo código descarta a mensagem ao fim de 20 tentativas, e o único vestígio é um contador. Defina delivery-limit com um valor escolhido por si e associe-lhe sempre uma DLX.

As filas de quórum suportam também duas estratégias de dead-lettering através da chave de política dead-letter-strategy. A predefinida, at-most-once, republica sem confirmação. Se a DLX não existir, ou se a fila de destino estiver indisponível ou recusar a mensagem, esta perde-se. É a garantia que as filas clássicas sempre tiveram.

at-least-once mantém a mensagem em dead-letter na fila de origem até todas as filas ligadas à DLX a terem confirmado. Exige uma fila de quórum como origem, overflow definido como reject-publish e uma DLX. Internamente, o líder da fila executa um worker de dead-lettering, a que a documentação chama dead-letter consumer: lê as mensagens em dead-letter da fila de origem, publica-as na DLX com confirms e volta a tentar tudo o que não foi confirmado. Daqui resultam três consequências. Se a DLX não existir ou o destino estiver em baixo, as mensagens acumulam-se na fila de origem, contando para o seu comprimento e para o disco, por design. Como a entrega é at-least-once, a DLQ pode receber duplicados. E o dead-letter consumer interno é canalização, não a sua aplicação; continua a precisar de um consumidor real na dead letter queue.

ComportamentoFila clássicaFila de quórum
Limite de reentregasNenhum, os ciclos de requeue nunca terminamdelivery-limit, 20 por predefinição na 4.x, depois DLX ou descarte
Contagem de reentregasApenas a flag redeliveredCabeçalho x-delivery-count
Estratégia de dead-letteringApenas at-most-onceat-most-once ou at-least-once
ReplicaçãoMirroring removido na 4.0Replicação Raft por design
Overflow predefinidodrop-headdrop-head; reject-publish obrigatório para at-least-once

Padrões de novas tentativas que não perdem mensagens

O ciclo básico de novas tentativas usa uma fila de espera. A DLX da fila de trabalho é uma exchange de retry, que encaminha para uma fila de espera com um message-ttl ao nível da fila e sem consumidores. A DLX da fila de espera é a exchange de trabalho, sem dead-letter-routing-key, para que a mensagem volte a entrar com a sua routing key original. Um consumidor que encontra uma falha transitória rejeita com requeue=false; a mensagem aguarda o fim do TTL e regressa. O consumidor lê o número de tentativas a partir da entrada de x-death correspondente à fila de trabalho com o motivo rejected e, ao atingir o limite, move a mensagem para um parking lot em vez de voltar a rejeitá-la.

Para backoff exponencial, use uma fila de espera por patamar de atraso: wait.10s, wait.1m, wait.10m. Não o faça com TTLs por mensagem numa única fila. As mensagens expiradas só são removidas da cabeça de uma fila, tanto nas filas clássicas como nas de quórum, pelo que uma mensagem de dez minutos na cabeça bloqueia uma mensagem de dez segundos que esteja atrás dela. Com filas por patamar, o consumidor escolhe o patamar a partir do número de tentativas, publica na exchange de retry com a routing key do patamar, aguarda o publisher confirm e só então faz ack da original. Fazer ack antes de o confirm chegar é onde as novas tentativas conduzidas pelo consumidor perdem mensagens. Mantenha mesmo assim a DLX na fila de trabalho, como rede de segurança para o delivery-limit.

O plugin delayed message exchange é a alternativa: publica com um cabeçalho x-delay e a exchange retém a mensagem até o atraso terminar. A contrapartida é a durabilidade. As mensagens atrasadas ficam num armazenamento local no nó que aloja a exchange e não são replicadas, pelo que perder esse nó significa perder todas as mensagens pendentes, e um grande backlog de mensagens pendentes degrada o plugin. Também não há nenhuma fila para inspecionar. Para meia dúzia de atrasos curtos é prático; para um backlog de novas tentativas que possa ter de examinar às 3 da manhã, as filas de espera são aborrecidas, visíveis e replicadas quando declaradas como filas de quórum.

As novas tentativas só ajudam em falhas transitórias. Uma mensagem que falha de forma determinística, porque o payload está mal formado ou referencia um registo que não existe, deve ir diretamente para o parking lot, por isso distinga no consumidor as exceções que justificam nova tentativa das que não justificam. E todos os mecanismos desta página podem entregar a mesma mensagem duas vezes: as novas tentativas, os replays e o dead-lettering at-least-once garantem a entrega, não a unicidade. Os consumidores têm de ser idempotentes, com base no message id ou numa chave de negócio, caso contrário uma nova tentativa transforma uma falha numa cobrança duplicada.

Exemplo prático: processamento de encomendas com uma fila de espera e um parking lot

A topologia:

  • Exchange orders (topic) com a fila de quórum orders.work ligada por binding a order.*.
  • Exchange orders.retry (fanout) com a fila de quórum orders.wait.30s, TTL de 30 segundos, com dead-lettering de volta para orders.
  • Exchange orders.dlx (fanout) com a fila de quórum orders.parking, sem TTL e sem automatismos.

Bastam duas políticas:

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

O consumidor impõe o limite de tentativas e envia explicitamente para o parking lot, publicando com confirm antes de fazer 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

Cada peça protege contra algo específico. Uma falha a meio do processamento devolve a mensagem à fila; cinco seguidas acionam o delivery-limit e a mensagem vai para a fila de espera em vez de ser descartada. Uma falha transitória aguarda 30 segundos e regressa, até três tentativas. Uma falha permanente vai para o parking lot logo à primeira. O dead-lettering at-least-once garante que o salto de retry não perde nenhuma mensagem se orders.wait.30s estiver brevemente indisponível.

Operar uma dead letter queue

Uma dead letter queue só é útil se alguém souber quando se enche. Quatro sinais cobrem quase tudo.

Profundidade: rabbitmq_queue_messages para o parking lot e cada fila de espera, a partir do plugin Prometheus com métricas por objeto ou da família queue_coarse_metrics do endpoint detalhado. Taxa, que deteta mudanças mais cedo do que a profundidade: os contadores rabbitmq_global_messages_dead_lettered_*_total decompõem o dead-lettering por motivo e, no caso de at-least-once, por confirmação. Número de consumidores, que indica se a topologia está intacta: rabbitmq_queue_consumers deve ser diferente de zero no parking lot e exatamente zero em todas as filas de espera, porque um consumidor numa fila de espera anula o atraso. Idade, que o RabbitMQ não expõe diretamente; calcule um valor aproximado a partir do cabeçalho x-parked-at ou do time em x-death quando fizer amostragem da fila.

Limiares de partida, a ajustar a cada serviço:

  • Qualquer dead-lettering numa fila que normalmente não tem nenhum: aviso imediato, o primeiro é o mais barato de investigar.
  • Taxa de dead-lettering acima de um por cento da taxa de publicação durante cinco minutos: acionar o piquete.
  • Contador delivery_limit a aumentar, por pouco que seja: investigar, isto significa consumidores a falhar ou ciclos de requeue, não falhas de negócio.
  • Profundidade do parking lot acima de um valor dimensionado para a sua capacidade de revisão, ou a subir continuamente durante 30 minutos: acionar o piquete.
  • Zero consumidores no parking lot durante dez minutos, ou qualquer consumidor numa fila de espera: alerta.
  • Profundidade da fila de origem a subir enquanto a DLQ se mantém estável, com at-least-once configurado: a DLX ou o seu destino está avariado.

Registe no log, no momento em que envia para o parking lot, aquilo que o broker não regista: a classe e a mensagem da exceção, o host e a build do consumidor, o message id e o correlation id, a exchange e a routing key originais a partir de x-death e o número de tentativas. O broker sabe porque é que uma mensagem foi para dead-letter; só o consumidor sabe o que correu mal. Acrescente também o motivo como cabeçalho, como o exemplo faz com x-parked-reason, para que quem abrir a fila mais tarde o possa ler sem cruzar informação com os logs. Não registe corpos completos, a não ser que sejam pequenos e não contenham nada sensível. O corpo está na fila.

Fazer replay de mensagens em segurança

Fazer replay significa voltar a publicar as mensagens do parking lot na exchange de trabalho. Corrija primeiro a causa. Fazer replay para um consumidor que não foi corrigido cria um ciclo entre o parking lot e a fila de trabalho, com uma pessoa a meio.

A ferramenta mais simples é um dynamic shovel do parking lot para a exchange de trabalho, criado com rabbitmqctl set_parameter shovel. Use ack-mode com o valor on-confirm, para que uma mensagem só saia do parking lot depois de a fila de trabalho a ter confirmado, defina dest-exchange como a exchange de trabalho e deixe dest-exchange-key por definir, para que seja usada a routing key original, e defina src-delete-after como queue-length, para que o shovel esvazie o que existia quando arrancou e depois se remova a si próprio. A ação de mover mensagens da interface de gestão é, por baixo, um shovel. Um shovel faz replay de tudo por ordem, sem qualquer filtragem, e o x-death continua a acumular, que é o que se pretende: uma mensagem que volte a falhar regressa ao parking lot com um histórico mais longo.

Quando precisa de seleção, use um consumidor de replay: uma pequena ferramenta que consome do parking lot com um prefetch moderado, filtra por cabeçalho, data ou id, publica com confirms e faz ack após cada confirm. Limite-lhe a taxa, porque um parking lot que se encheu durante um fim de semana pode atropelar uma base de dados a jusante na segunda-feira de manhã. Se quiser que a contagem de tentativas recomece do zero, pode remover o x-death, mas deve registar em seu lugar um cabeçalho x-replay-count.

Não volte a publicar a partir de um script improvisado sem confirms, não faça replay em horas de ponta e não faça replay de um lote cuja causa de fundo ainda não identificou.

Retenção e disco

Um parking lot é estado durável. Numa fila de quórum, cada mensagem é escrita no log Raft e nos ficheiros de segmento de todos os membros, pelo que uma fila de três membros guarda três cópias durante todo o tempo em que a mensagem lá estiver. As mensagens em dead-letter tendem a ser as maiores e tendem a ficar lá durante dias. Planeie o disco.

Limite o parking lot com max-length-bytes e overflow definido como reject-publish, não drop-head. drop-head descarta em silêncio as provas mais antigas quando a fila se enche. reject-publish torna ruidoso um parking lot cheio: o dead-lettering para ele falha, a fila de origem at-least-once retém o seu backlog e os seus alertas disparam. Ruidoso é o correto.

Não defina message-ttl no parking lot. A retenção cabe a um consumidor de arquivo que move as mensagens mais antigas do que a sua janela de revisão para armazenamento de objetos ou para uma tabela de base de dados e lhes faz ack, mantendo a fila como uma caixa de entrada e não como um arquivo. A falha que está a evitar é real: um parking lot que ninguém esvazia cresce até o nó ultrapassar o limiar do alarme de espaço livre em disco, e o alarme de disco bloqueia todos os publishers do nó, transformando uma lenta acumulação de falhas numa indisponibilidade de todo o cluster.

Antipadrões que vemos em produção

Uma DLQ sem consumidor e sem alerta. As mensagens acumulam-se até disparar o alarme de disco ou até alguém encontrar a fila, meses depois, durante um incidente sem relação. Se não daria pela fila a crescer, configurou uma fuga com passos extra.

Fazer dead-lettering para a exchange à qual a fila já está ligada, sem mudar a routing key. A mensagem volta a cair na mesma fila. Se tiver expirado ou sido descartada por comprimento, a deteção de ciclos descarta-a. Se tiver sido rejeitada, entra num ciclo a alta velocidade através do consumidor, saturando a CPU e enchendo os logs.

Novas tentativas ilimitadas. Sem limite de tentativas, uma mensagem que nunca vai ter sucesso circula para sempre, consumindo capacidade dos consumidores a cada volta, e com at-least-once e reject-publish pode acumular-se na fila de origem.

Filas clássicas espelhadas a transportar a DLX na 4.x. O mirroring de filas clássicas foi removido no RabbitMQ 4.0 e as chaves de política ha-* deixaram de ser respeitadas. Uma dead letter queue que estava replicada na 3.x passa a ser uma fila clássica de um único nó após a atualização e, se esse nó falhar, as provas vão com ele. Converta as dead letter queues em filas de quórum antes da atualização.

TTL na própria DLQ. Um message-ttl de uma semana no parking lot “para o manter arrumado” apaga exatamente as mensagens de que uma investigação precisa e, se o parking lot também fizer dead-lettering de volta para a fila de trabalho, o TTL cria um ciclo de expiração pura que a deteção de ciclos descarta em silêncio.

Dois mais pequenos: registar o corpo no log e fazer ack em vez de enviar para o parking lot, o que trata uma linha de log como se fosse uma fila; e executar o consumidor do parking lot no mesmo processo que o consumidor de trabalho, de modo que a falha que enche o parking lot também derruba aquilo que devia esvaziá-lo.

Próximos passos

O dead-lettering assenta no encaminhamento, e uma DLX só é tão sensata quanto o desenho de exchanges à sua volta. O nosso guia de exchanges, filas e bindings para microsserviços trata desse tema. Se ainda não resolveu a questão do tipo de fila, filas clássicas versus filas de quórum aborda essa decisão; tudo o que aqui se diz pressupõe filas de quórum para tudo o que é importante. Para os modos de falha mais gerais que enchem um parking lot à partida, consulte os dez problemas mais comuns do RabbitMQ.

Se as suas dead letter queues se estão a encher e não sabe bem porquê, ou se está a planear a atualização para a 4.x e quer rever a topologia de DLX antes de as filas espelhadas deixarem de ser uma opção, é isso que fazemos. A AceMQ é o único parceiro MSP de RabbitMQ designado pela Broadcom, suporta o RabbitMQ da 3.8.x à 4.x e responde a incidentes P1 com objetivos de resposta a partir de 15 minutos, consoante o plano. Consulte os nossos planos de suporte RabbitMQ ou saiba mais sobre como trabalhamos com o RabbitMQ.

Perguntas frequentes

Qual é a diferença entre uma dead letter exchange e uma dead letter queue?

Uma dead letter exchange é a exchange para a qual uma fila republica uma mensagem quando faz o dead-lettering dessa mensagem. É uma exchange normal, sem nenhum tipo especial. Uma dead letter queue é qualquer fila ligada por binding a essa exchange, e o nome é uma convenção, não um conceito do broker. O RabbitMQ só conhece a exchange; o destino da mensagem depende dos bindings que declarou. Esta separação é útil: uma única DLX pode distribuir para um parking lot destinado a replay e para uma fila de auditoria destinada a análise, ou encaminhar as falhas de cada equipa para a sua própria fila de acordo com a routing key original.

O RabbitMQ faz dead-lettering de mensagens que não podem ser encaminhadas?

Não. O dead-lettering aplica-se apenas a mensagens que já estavam numa fila e foram rejeitadas, expiraram, foram descartadas por limite de comprimento ou excederam o delivery limit de uma fila de quórum. Uma mensagem publicada numa exchange sem binding correspondente é descartada no momento da publicação, a não ser que o publisher tenha definido a flag mandatory, caso em que é devolvida ao publisher, ou que a exchange tenha uma alternate exchange configurada, caso em que é encaminhada para lá. Se as mensagens não encaminháveis são importantes para si, configure uma alternate exchange com a sua própria fila e monitorize-a da mesma forma que monitoriza uma dead letter queue.

Como contar as novas tentativas no RabbitMQ?

Leia o cabeçalho x-death. Cada entrada representa um par fila-motivo, e o seu campo count é incrementado sempre que essa fila faz o dead-lettering da mensagem por esse motivo. Num ciclo de novas tentativas com fila de espera, procure a entrada cujo queue é a sua fila de trabalho e cujo reason é rejected; o respetivo count é o número de tentativas feitas até agora. Nas filas de quórum, o cabeçalho separado x-delivery-count conta as reentregas dentro de uma fila, o que capta falhas do consumidor e requeues, e não rejeições explícitas. Imponha o limite no consumidor e envie a mensagem para o parking lot com uma publicação explícita e confirmada quando o limite for atingido.

É possível usar uma dead letter exchange com filas de quórum?

Sim, e as filas de quórum acrescentam duas coisas que as filas clássicas nunca tiveram. A política delivery-limit limita as reentregas e faz o dead-lettering da mensagem quando o limite é excedido, com uma predefinição de 20 a partir do RabbitMQ 4.0, por isso configure uma DLX ou essas mensagens serão descartadas. A chave de política dead-letter-strategy pode ser definida como at-least-once, o que mantém as mensagens em dead-letter na fila de origem até a fila de destino as confirmar. Isso exige que overflow seja reject-publish. Tanto a fila de origem como, idealmente, a própria dead letter queue devem ser filas de quórum, para que as provas da falha fiquem replicadas.

O que acontece se a dead letter exchange não existir?

O broker não valida o nome da exchange quando a fila é declarada ou a política é aplicada, pelo que a configuração é aceite em silêncio. Com a estratégia predefinida at-most-once, todas as mensagens em dead-letter são descartadas, sem erro e sem qualquer linha de log, o que é uma das formas mais silenciosas de perder dados no RabbitMQ. Com at-least-once numa fila de quórum, as mensagens em dead-letter ficam retidas na fila de origem até a exchange aparecer e a fila de destino as confirmar, pelo que é a fila de origem que cresce. Declare a DLX e a respetiva fila nas definitions e configure alertas para qualquer taxa de dead-lettering que não corresponda a um crescimento da DLQ.

Devo definir um TTL na minha dead letter queue?

Não. Um message-ttl no parking lot apaga as mensagens que guardou precisamente para que alguém as pudesse inspecionar e reprocessar, e apaga-as segundo um temporizador que nada tem a ver com o problema de fundo ter sido ou não corrigido. Se o parking lot também fizer dead-lettering de volta para a fila de trabalho, a expiração cria um ciclo sem nenhuma rejeição, que o broker descarta em silêncio. Faça a gestão da retenção com um consumidor de arquivo que move as mensagens antigas para armazenamento durável e lhes faz ack, limite a fila com max-length-bytes e reject-publish e configure alertas para a profundidade e a idade.

Scott Sternloff

Autor

Scott SternloffArquiteto empresarial sénior

Arquiteto empresarial sénior na AceMQ. Escreve aqui os conteúdos técnicos: arquitetura, clustering e migrações de RabbitMQ, Kafka e Redis.

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.

Consulta gratuita

Obtenha uma análise especializada de cluster RabbitMQ

Quer esteja a resolver um incidente em produção, a planear uma migração ou queira uma segunda opinião sobre a sua arquitetura, a nossa equipa está pronta. Sem discursos de vendas, apenas respostas.

Enviar e-mail