On this page
O dead-lettering é a forma como o RabbitMQ leva uma mensagem que ele não consegue mais entregar para um lugar onde você possa tratá-la. Bem configurado, ele transforma um payload ruim em um ticket. Mal configurado, é a forma mais comum que vemos de mensagens de produção desaparecerem sem deixar rastro. Este guia cobre o mecanismo como ele se comporta no RabbitMQ 3.13 e 4.x, os padrões de retry construídos sobre ele e os hábitos operacionais que mantêm uma dead letter queue confiável.
O que é dead-lettering, exatamente
Uma fila faz o dead-lettering de uma mensagem por exatamente quatro motivos:
- Um consumer a rejeitou com
basic.rejectoubasic.nackerequeue=false. - O TTL por mensagem, ou o
message-ttlda fila, expirou. - A fila passou do limite de
max-lengthoumax-length-bytese descartou a mensagem do início. Esse é o comportamento de overflow padrão,drop-head; comreject-publish, o broker recusa a nova publicação e nada vai para dead-letter. - Em uma fila de quórum, a mensagem voltou para a fila mais vezes do que o
delivery-limitpermite.
O broker registra esses casos como rejected, expired, maxlen e delivery_limit. Nada mais conta. Uma fila que expira via x-expires é apagada junto com o conteúdo. Um purge descarta as mensagens. Uma mensagem que o broker não consegue rotear 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 comum. Não existe tipo especial nem 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 houver uma definida, ou a routing key original da mensagem, caso contrário. Por ser comum, ela pode distribuir para uma fila parking lot e uma fila de auditoria, rotear pela chave original por meio de uma topic exchange ou enviar as falhas de cada equipe para a própria fila. Uma “dead letter queue” é apenas a fila que você vinculou a ela.
Duas coisas mudam na mensagem quando ela é republicada. A propriedade expiration é limpa, para que uma mensagem que expirou uma vez não expire de novo imediatamente; o valor original fica preservado em x-death como original-expiration. E o header x-death é adicionado ou atualizado. O corpo, o message id, o correlation id e todas as outras propriedades permanecem intactos.
Configurando a dead letter exchange: arguments ou policies
Há duas formas de associar uma DLX a uma fila. 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 policies definem o mesmo comportamento do lado do broker, com as chaves dead-letter-exchange e dead-letter-routing-key, associadas às filas por um padrão de nome.
Prefira policies. Os queue arguments são imutáveis: para mudar uma DLX definida como argument, é preciso apagar a fila e declará-la de novo, o que significa esvaziá-la antes e coordenar todos os clientes que a declaram. As policies mudam em tempo de execução, se aplicam a todas as filas correspondentes, ficam nos exports de definitions e estão em um único lugar que um operador consegue ler. Quando os dois existem, o argument prevalece, e esse é o segundo motivo para evitar arguments: uma aplicação que define x-dead-letter-exchange fixa um valor que a operação não consegue sobrescrever sem um deploy. A exceção é x-queue-type, que precisa ser um argument, e não há problema nisso, porque o tipo de uma fila nunca muda.
Uma armadilha: apenas uma policy se aplica a cada fila, a correspondência de maior prioridade. Se você definir uma policy para dead-lettering e outra para max-length ou delivery-limit nas mesmas filas, só uma vai valer. Coloque todas as chaves de que uma fila precisa na mesma definição de policy.
Quando o broker faz o dead-lettering de uma mensagem, ele acrescenta ao header x-death, um array com uma entrada por par fila-motivo. Se a mesma fila fizer o dead-lettering da mesma mensagem pelo mesmo motivo de novo, o count dessa entrada é incrementado e ela vai para o início do array. Cada entrada registra a fila, o motivo, a exchange e as routing keys que a mensagem carregava, um timestamp e, quando havia 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 exemplo ilustrativo de header depois de três voltas em um loop 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: ordersO dead-lettering pode formar um ciclo, e o broker tem uma regra para isso: se uma mensagem chega à mesma fila duas vezes e nenhum salto do ciclo foi uma rejeição, a mensagem é descartada. Se algum salto foi uma rejeição de consumer, o ciclo continua. Por isso, loops de retry baseados em requeue=false funcionam, porque toda volta inclui uma rejeição, enquanto um loop construído só com TTL, como um parking lot com message-ttl que faz dead-lettering de volta para a fila de trabalho, descarta mensagens silenciosamente na segunda volta.
As filas de quórum mudam as regras
As filas de quórum contam as reentregas no header x-delivery-count, e a chave de policy delivery-limit (ou o argument x-delivery-limit) define o limite. Acima dele, a fila faz o dead-lettering da mensagem se houver uma DLX configurada e a descarta se não houver. A partir do RabbitMQ 4.0, o delivery limit padrão é 20; antes disso, era ilimitado.
É esse padrão que surpreende as equipes que migram de filas clássicas. Um consumer que captura uma exceção e chama basic.nack com requeue=true ficava girando para sempre em uma fila clássica, desperdiçando CPU, mas sem perder nada. Em uma fila de quórum 4.x sem DLX, o mesmo código descarta a mensagem depois de 20 tentativas, e o único rastro é um contador. Defina delivery-limit com um valor escolhido por você e sempre combine-o com uma DLX.
As filas de quórum também suportam duas estratégias de dead-letter, pela chave de policy dead-letter-strategy. A padrão, 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, ela se perde. Essa é a garantia que as filas clássicas sempre tiveram.
at-least-once mantém a mensagem em dead-letter na fila de origem até que todas as filas vinculadas à DLX a tenham 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-letter, que a documentação chama de dead-letter consumer: ele lê as mensagens em dead-letter da fila de origem, publica-as na DLX com confirms e tenta de novo tudo o que não for confirmado. Isso tem três consequências. Se a DLX não existir ou o destino estiver fora do ar, as mensagens se acumulam na fila de origem, contando para o tamanho e o disco dela, por design. Como a entrega é at-least-once, a DLQ pode receber duplicatas. E o dead-letter consumer interno é encanamento, não a sua aplicação; você continua precisando de um consumer de verdade na dead letter queue.
| Comportamento | Fila clássica | Fila de quórum |
|---|---|---|
| Limite de reentregas | Nenhum, loops de requeue rodam para sempre | delivery-limit, padrão 20 no 4.x, depois DLX ou descarte |
| Contagem de reentregas | Apenas a flag redelivered | Header x-delivery-count |
| Estratégia de dead-letter | Apenas at-most-once | at-most-once ou at-least-once |
| Replicação | Mirroring removido no 4.0 | Replicada via Raft por design |
| Overflow padrão | drop-head | drop-head; reject-publish obrigatório para at-least-once |
Padrões de retry que não perdem mensagens
O loop de retry básico usa uma fila de espera. A DLX da fila de trabalho é uma exchange de retry, que roteia para uma fila de espera com message-ttl no nível da fila e sem consumers. A DLX da fila de espera é a exchange de trabalho, sem dead-letter-routing-key, para que a mensagem volte com a routing key original. Um consumer que encontra uma falha transitória rejeita com requeue=false; a mensagem espera o TTL vencer e volta. O consumer lê o número de tentativas na entrada de x-death da fila de trabalho com motivo rejected e, ao atingir o limite, move a mensagem para um parking lot em vez de rejeitá-la de novo.
Para backoff exponencial, use uma fila de espera por faixa de atraso: wait.10s, wait.1m, wait.10m. Não faça isso com TTLs por mensagem em uma única fila. Mensagens expiradas só são removidas do início da fila, tanto em filas clássicas quanto em filas de quórum, então uma mensagem de dez minutos no início bloqueia uma mensagem de dez segundos logo atrás. Com filas por faixa, o consumer escolhe a faixa pelo número de tentativas, publica na exchange de retry com a routing key da faixa, espera o publisher confirm e só então faz o ack da original. Fazer o ack antes de o confirm chegar é onde os retries conduzidos pelo consumer 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: publique com um header x-delay e a exchange segura a mensagem até o atraso passar. O custo é a durabilidade. As mensagens atrasadas ficam em um armazenamento local no nó que hospeda a exchange e não são replicadas; assim, perder esse nó significa perder todas as mensagens pendentes, e um backlog grande de mensagens pendentes degrada o plugin. Também não há fila para inspecionar. Para alguns poucos atrasos curtos ele é prático; para um backlog de retries que você talvez precise examinar às 3 da manhã, filas de espera são sem graça, visíveis e replicadas quando declaradas como filas de quórum.
Retries só ajudam em falhas transitórias. Uma mensagem que falha de forma determinística, porque o payload está malformado ou faz referência a um registro que não existe, deve ir direto para o parking lot; por isso, diferencie no consumer as exceções que admitem retry das que não admitem. E todos os mecanismos desta página podem entregar a mesma mensagem duas vezes: retries, replays e dead-lettering at-least-once garantem a entrega, não a unicidade. Os consumers precisam ser idempotentes, com base no message id ou em uma chave de negócio, ou um retry transforma uma falha em uma cobrança duplicada.
Exemplo prático: processamento de pedidos com fila de espera e parking lot
A topologia:
- Exchange
orders(topic) com a fila de quórumorders.workvinculada emorder.*. - Exchange
orders.retry(fanout) com a fila de quórumorders.wait.30s, TTL de 30 segundos, fazendo dead-lettering de volta paraorders. - Exchange
orders.dlx(fanout) com a fila de quórumorders.parking, sem TTL e sem automação.
Duas policies resolvem tudo:
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 10O consumer aplica o limite de tentativas e envia explicitamente para o parking lot, publicando com confirm antes de fazer o 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 parkCada peça protege contra algo específico. Um crash no meio do processamento devolve a mensagem para a fila; cinco seguidos acionam o delivery-limit e a mensagem vai para a fila de espera em vez de ser descartada. Uma falha transitória espera 30 segundos e volta, até três tentativas. Uma falha permanente vai para o parking lot logo na primeira vez. O dead-lettering at-least-once garante que o salto de retry não perca nenhuma mensagem se orders.wait.30s ficar indisponível por alguns instantes.
Operando uma dead letter queue
Uma dead letter queue só é útil se alguém souber quando ela enche. Quatro sinais cobrem a maior parte.
Profundidade: rabbitmq_queue_messages do parking lot e de 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 detecta mudanças mais cedo do que a profundidade: os contadores rabbitmq_global_messages_dead_lettered_*_total detalham o dead-lettering por motivo e, no caso de at-least-once, por confirmação. Número de consumers, que diz 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 consumer em uma fila de espera anula o atraso. Idade, que o RabbitMQ não expõe diretamente; estime-a pelo header x-parked-at ou pelo time em x-death ao amostrar a fila.
Limites iniciais, a ajustar para cada serviço:
- Qualquer dead-lettering em uma 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 ao longo de cinco minutos: acionar o plantão.
- Contador
delivery_limitaumentando, por menos que seja: investigar, isso indica consumers caindo ou loops de requeue, e não falhas de negócio. - Profundidade do parking lot acima de um número dimensionado pela sua capacidade de revisar as mensagens, ou subindo continuamente por 30 minutos: acionar o plantão.
- Zero consumers no parking lot por dez minutos, ou qualquer consumer em uma fila de espera: alerta.
- Profundidade da fila de origem subindo enquanto a DLQ está estável, com
at-least-onceconfigurado: a DLX ou o destino dela está com problema.
No momento de enviar para o parking lot, registre em log o que o broker não registra: a classe e a mensagem da exceção, o host e o build do consumer, o message id e o correlation id, a exchange e a routing key originais vindas de x-death e o número de tentativas. O broker sabe por que uma mensagem foi para dead-letter; só o consumer sabe o que deu errado. Anexe também o motivo como header, como o exemplo faz com x-parked-reason, para que quem abrir a fila depois consiga lê-lo sem cruzar informações com os logs. Não registre o corpo inteiro, a não ser que ele seja pequeno e não contenha nada sensível. O corpo está na fila.
Fazendo replay de mensagens com segurança
Replay significa publicar as mensagens do parking lot de volta na exchange de trabalho. Corrija a causa primeiro. Fazer replay para um consumer que não foi corrigido cria um loop entre o parking lot e a fila de trabalho com um ser humano no meio.
A ferramenta mais simples é um shovel dinâmico do parking lot para a exchange de trabalho, criado com rabbitmqctl set_parameter shovel. Use ack-mode como on-confirm, para que uma mensagem só saia do parking lot depois que a fila de trabalho a confirmar; defina dest-exchange como a exchange de trabalho e deixe dest-exchange-key sem valor, para que a routing key original seja usada; e defina src-delete-after como queue-length, para que o shovel drene o que havia quando começou e depois se remova. A ação de mover mensagens da interface de gerenciamento é, por baixo, um shovel. Um shovel faz replay de tudo, em ordem e sem filtro, e o x-death continua acumulando, que é exatamente o que você quer: uma mensagem que falhar de novo volta para o parking lot com um histórico mais longo.
Quando você precisa selecionar, use um consumer de replay: uma pequena ferramenta que consome do parking lot com um prefetch modesto, filtra por header, horário ou id, publica com confirms e faz o ack depois de cada confirm. Limite a taxa dele, porque um parking lot que encheu durante o fim de semana pode atropelar um banco de dados downstream na segunda de manhã. Se você quiser que a contagem de tentativas recomece do zero, ele pode remover o x-death, mas deve registrar um header x-replay-count no lugar.
Não republique a partir de um script improvisado sem confirms, não faça replay no horário de pico e não faça replay de um lote cuja causa raiz você ainda não identificou.
Retenção e disco
Um parking lot é estado durável. Em uma fila de quórum, cada mensagem é gravada no log do Raft e nos arquivos de segmento de todos os membros, então uma fila com três membros guarda três cópias enquanto a mensagem estiver lá. As mensagens que vão para dead-letter costumam ser as grandes e costumam ficar paradas por dias. Planeje o disco.
Limite o parking lot com max-length-bytes e overflow definido como reject-publish, e não drop-head. O drop-head descarta silenciosamente as evidências mais antigas quando a fila enche. O reject-publish faz um parking lot cheio chamar atenção: o dead-lettering para ele falha, a fila de origem at-least-once segura o backlog e os seus alertas disparam. Chamar atenção é o comportamento correto.
Não defina message-ttl no parking lot. A retenção cabe a um consumer de arquivamento que move as mensagens mais antigas do que a sua janela de revisão para um object storage ou uma tabela de banco de dados e faz o ack delas, mantendo a fila como uma caixa de entrada, e não como um arquivo morto. A falha que você está evitando é real: um parking lot que ninguém drena cresce até o nó ultrapassar o limite do alarme de disco livre, e o alarme de disco bloqueia todos os publishers do nó, transformando um acúmulo lento de falhas em uma indisponibilidade do cluster inteiro.
Antipadrões que vemos em produção
Uma DLQ sem consumer e sem alerta. As mensagens se acumulam até o alarme de disco disparar ou até alguém encontrar a fila durante um incidente sem relação, meses depois. Se você não perceberia a fila crescendo, configurou um vazamento com etapas extras.
Fazer dead-lettering para a mesma exchange à qual a fila já está vinculada, sem trocar a routing key. A mensagem volta para a mesma fila. Se ela expirou ou foi descartada por tamanho, a detecção de ciclos a descarta. Se foi rejeitada, ela entra em um loop quente pelo consumer a toda velocidade, saturando a CPU e enchendo os logs.
Retries sem limite. Sem um teto de tentativas, uma mensagem que nunca vai ter sucesso circula para sempre, consumindo capacidade dos consumers a cada volta, e com at-least-once e reject-publish ela pode represar a fila de origem.
Filas clássicas espelhadas carregando a DLX no 4.x. O mirroring de filas clássicas foi removido no RabbitMQ 4.0 e as chaves de policy ha-* deixaram de ser respeitadas. Uma dead letter queue que era replicada no 3.x vira uma fila clássica de nó único depois do upgrade, e, se esse nó falhar, as evidências vão junto. Converta as dead letter queues em filas de quórum antes do upgrade.
TTL na própria DLQ. Um message-ttl de uma semana no parking lot “para manter tudo organizado” apaga justamente 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 monta um ciclo só de expiração que a detecção de ciclos descarta silenciosamente.
Dois menores: registrar o corpo em log e fazer o ack em vez de mandar para o parking lot, o que trata uma linha de log como se fosse uma fila; e rodar o consumer do parking lot no mesmo processo que o consumer de trabalho, de modo que a falha que enche o parking lot também derruba aquilo que deveria drená-lo.
Próximos passos
O dead-lettering fica em cima do roteamento, e uma DLX só faz sentido na medida em que o design das exchanges em volta dela faz. Nosso guia de exchanges, filas e bindings para microsserviços trata desse assunto. Se você ainda não decidiu a questão do tipo de fila, filas clássicas versus filas de quórum cobre essa decisão; tudo aqui pressupõe filas de quórum para o que for importante. Para os modos de falha mais amplos que enchem um parking lot, para começo de conversa, veja os dez problemas mais comuns de troubleshooting no RabbitMQ.
Se as suas dead letter queues estão enchendo e você não sabe bem por quê, ou se você está planejando o upgrade para o 4.x e quer revisar a topologia de DLX antes que as filas espelhadas deixem de ser uma opção, é isso que fazemos. A AceMQ é a única parceira MSP de RabbitMQ nomeada pela Broadcom, dá suporte ao RabbitMQ do 3.8.x ao 4.x e responde a incidentes P1 com metas de resposta a partir de 15 minutos, conforme o plano. Conheça nossos planos de suporte para RabbitMQ ou saiba mais sobre como trabalhamos com RabbitMQ.
Perguntas frequentes
Qual a diferença entre dead letter exchange e dead letter queue?
A dead letter exchange é a exchange para a qual uma fila republica uma mensagem quando faz o dead-lettering dela. É uma exchange comum, sem nenhum tipo especial. A dead letter queue é qualquer fila vinculada 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 você declarou. Essa 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 equipe para a própria fila de acordo com a routing key original.
O RabbitMQ faz dead-lettering de mensagens que não podem ser roteadas?
Não. O dead-lettering só se aplica a mensagens que já estavam em uma fila e foram rejeitadas, expiraram, foram descartadas por limite de tamanho ou excederam o delivery limit de uma fila de quórum. Uma mensagem publicada em uma exchange sem binding correspondente é descartada no momento da publicação, a menos que o publisher tenha definido a flag mandatory, caso em que ela volta para o publisher, ou que a exchange tenha uma alternate exchange configurada, caso em que ela é roteada para lá. Se mensagens não roteáveis são importantes para você, configure uma alternate exchange com fila própria e monitore-a do mesmo jeito que monitora uma dead letter queue.
Como contar as retentativas no RabbitMQ?
Leia o header x-death. Cada entrada representa um par fila-motivo, e o campo count dela é incrementado toda vez que aquela fila faz o dead-lettering da mensagem por aquele motivo. Em um loop de retry com fila de espera, encontre a entrada cujo queue é a sua fila de trabalho e cujo reason é rejected; o count dela é o número de tentativas até agora. Nas filas de quórum, o header separado x-delivery-count conta as reentregas dentro de uma mesma fila, o que captura crashes e requeues, e não rejeições explícitas. Aplique o limite no consumer e mande a mensagem para o parking lot com uma publicação explícita e confirmada quando o limite for atingido.
Dá para usar dead letter exchange com filas de quórum?
Sim, e as filas de quórum trazem duas coisas que as filas clássicas nunca tiveram. A policy delivery-limit limita as reentregas e faz o dead-lettering da mensagem quando o limite é ultrapassado, com padrão de 20 a partir do RabbitMQ 4.0; por isso, configure uma DLX ou essas mensagens serão descartadas. A chave de policy dead-letter-strategy pode ser definida como at-least-once, o que mantém as mensagens em dead-letter na fila de origem até que a fila de destino as confirme. Isso exige overflow como reject-publish. Tanto a fila de origem quanto, de preferência, a própria dead letter queue devem ser filas de quórum, para que as evidências 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 policy é aplicada, então a configuração é aceita sem nenhum aviso. Com a estratégia padrão at-most-once, toda mensagem enviada para dead-letter é descartada, sem erro e sem nenhuma linha de log, o que é uma das formas mais silenciosas de perder dados no RabbitMQ. Com at-least-once em uma fila de quórum, as mensagens em dead-letter ficam retidas na fila de origem até a exchange aparecer e a fila de destino confirmá-las, então quem cresce é a fila de origem. Declare a DLX e a fila dela nas definitions e crie 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 justamente as mensagens que você guardou para que alguém pudesse inspecioná-las e fazer replay, e apaga com base em um timer que não tem nada a ver com a correção do problema de fundo. 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 silenciosamente. Gerencie a retenção com um consumer de arquivamento que move as mensagens antigas para um armazenamento durável e faz o ack delas, limite a fila com max-length-bytes e reject-publish e crie alertas de profundidade e de idade.
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.
Guias, comparativos e pesquisas


