BlogRabbitMQ

Os 5 pontos que você deve monitorar para manter saudável o seu cluster RabbitMQ no Kubernetes

Scott Sternloff

Por Scott Sternloff, Arquiteto corporativo sênior

LinkedIn · Atualizado em · 17 min de leitura

Os 5 pontos que você deve monitorar para manter saudável o seu cluster RabbitMQ no Kubernetes
On this page

Rodar RabbitMQ no Kubernetes não é o mesmo que rodar RabbitMQ em bare metal. Os sinais de monitoramento que importam em um cluster estático de três VMs não são os mesmos que dizem se um StatefulSet do RabbitMQ está saudável dentro de um cluster Kubernetes que talvez você não controle por completo. E os modos de falha são diferentes — evictions de nós, reagendamento de pods, contenção de I/O entre tenants e a forma específica como o consenso Raft interage com a pilha de rede do Kubernetes podem causar indisponibilidades que quem opera em bare metal nunca vê.

Já resolvemos incidentes desse tipo em número suficiente para que fique claro o que realmente importa no meio do ruído. Se você for monitorar só cinco coisas em um cluster RabbitMQ no Kubernetes, monitore estas cinco. São as métricas que, na nossa experiência com o setor financeiro, plataformas SaaS e deployments corporativos de alto throughput, detectam falhas antes que elas virem indisponibilidades percebidas pelos clientes.

Por que monitorar RabbitMQ no Kubernetes é diferente

Um cluster RabbitMQ em bare metal ou em VMs dedicadas tem um adversário principal: a sua própria carga de trabalho. Um cluster RabbitMQ no Kubernetes tem vários:

  • Computação compartilhada. A menos que você tenha nós dedicados, os seus pods do RabbitMQ disputam CPU, memória e I/O de disco com tudo o mais que o Kubernetes agenda junto com eles.
  • Camadas de abstração de rede. A pilha de rede do Kubernetes acrescenta latência entre pods, overhead do CNI e uma camada de heartbeats com a qual o consenso Raft precisa dividir a banda.
  • Semântica de StatefulSet. O RabbitMQ no Kubernetes é implantado como StatefulSet pelo Cluster Operator, e os pods de um StatefulSet não são reagendados automaticamente quando um nó falha — um fato que surpreende os operadores no pior momento possível.
  • Acoplamento com os volumes persistentes. Com armazenamento local-path ou local do nó, um pod reagendado pode não conseguir recuperar o estado anterior. O armazenamento em rede traz a sua própria variabilidade de I/O.

Cada um desses pontos acrescenta uma classe de falha que seria impossível em infraestrutura dedicada. O seu monitoramento precisa levar todos em conta.

1. Saúde da replicação Raft nas filas de quórum

Se você roda filas de quórum (quorum queues) — e, em 2026, se você está no RabbitMQ 4.x, deveria —, a saúde da replicação Raft é a métrica mais importante do seu dashboard. Se ainda não migrou, veja o nosso guia sobre migração para filas de quórum. As filas de quórum funcionam com um líder e seguidores participando do consenso Raft, gravando cada mensagem na maioria dos nós antes de confirmar ao publisher. Quando o Raft se degrada, tudo o que depende dele se degrada junto.

No Kubernetes, a pressão sobre o Raft se agrava rápido. O protocolo de consenso exige comunicação confiável e de baixa latência entre os nós, desempenho de escrita em disco consistente e folga de CPU suficiente para processar as entradas do log. Quando qualquer uma dessas condições fica mais apertada — e, no Kubernetes, isso acontece com mais frequência do que em bare metal —, o Raft começa a ficar para trás e as filas começam a parar de responder.

O que monitorar de fato

  • rabbitmq_queue_messages separado por estado de líder vs seguidor.
  • rabbitmq_raft_log_commit_index e rabbitmq_raft_log_last_applied — a diferença entre os dois é o seu lag do Raft.
  • Frequência de eleições de líder. Um cluster saudável tem líderes estáveis; se os líderes ficam alternando, algo antes deles (rede, disco, CPU) não está saudável.
  • Estado do Raft por fila via API de gerenciamento: status dos seguidores, índice de snapshot, uso de disco.

Limites de alerta

Gere um alerta se o log Raft de um seguidor ficar mais de alguns milhares de entradas atrás do líder por mais de 30 segundos. Gere um alerta se houver mais de uma eleição de líder por hora em um cluster estável. E alerte imediatamente se qualquer fila de quórum perder o quórum — o broker informa isso pelas métricas, e você quer saber em segundos, não em minutos.

Por que isso importa mais no Kubernetes

No Kubernetes, é perfeitamente possível o Raft entrar em um estado em que a fila fica inutilizável e os procedimentos de recuperação padrão não funcionam direito. Um padrão que já vimos em produção: uma fila de quórum trava, o rabbitmqctl delete_queue falha porque o broker não consegue estabelecer consenso para excluí-la, e restaurar o serviço exige derrubar pods em uma ordem específica para forçar uma nova eleição de líder. Você não quer descobrir essa situação por reclamação de cliente. Você quer ver o lag do Raft subindo 10 minutos antes.

2. Watermark de memória e estado do flow control

O RabbitMQ tem um mecanismo de proteção nativo chamado memory high watermark. Quando o uso de memória de um broker ultrapassa o limite do watermark, o RabbitMQ bloqueia os publishers para evitar que o nó fique totalmente sem memória. Isso é intencional — é um mecanismo de segurança —, mas no Kubernetes os valores padrão do watermark muitas vezes estão errados.

Visão do especialista: ajuste do watermark específico para Kubernetes

"No Kubernetes, vocês devem fazer o teste com um watermark de 40% e net tick time de 60. Estamos deixando mais espaço para o Raft trabalhar, mais um espaço para a rede. A rede no RabbitMQ não é só entre os nós; é também a rede do Kubernetes e os heartbeats dos pods. Vocês estão disputando recursos."— Felipe Gutierrez, engenheiro sênior, AceMQ

O watermark de memória padrão do RabbitMQ, de 0.4 (40%), existe porque, no Kubernetes, o broker não é o único a usar memória no pod ou no nó. O kubelet, o plugin de CNI, o container runtime e eventuais sidecars consomem memória, e o Raft e o broker precisam de folga em relação a isso. Um watermark que faz sentido em uma VM dedicada muitas vezes precisa ser reduzido no Kubernetes para preservar folga suficiente para as operações do Raft e para a rede entre pods.

O que monitorar de fato

  • rabbitmq_resident_memory_limit_bytes e rabbitmq_process_resident_memory_bytes — a relação entre os dois é a sua utilização atual do watermark.
  • rabbitmq_connections_blocked_total — quantas conexões de publishers o RabbitMQ está bloqueando no momento.
  • Estado do flow control por conexão. Se você vê producers entrando em flow control, há um problema de pressão em algum ponto do pipeline — comece verificando o ajuste do prefetch dos consumers.
  • Uso de memória do pod vs limite de memória do pod no Kubernetes — atingir o limite do pod resulta em OOMKilled, uma falha muito pior do que atingir o watermark do RabbitMQ.

Limites de alerta

Gere um alerta em 80% do watermark configurado — nesse ponto você está perto de bloquear os publishers. Alerte imediatamente se qualquer conexão for bloqueada. E alerte em 90% do limite de memória do pod no Kubernetes — esse é o seu último aviso antes de o kubelet matar o pod.

3. Contenção de I/O de disco e latência de escrita

Esta é a métrica em que o Kubernetes morde mais forte. As filas de quórum do RabbitMQ são, por design, intensivas em disco — toda escrita passa pelo log do Raft antes de ser confirmada. Se o armazenamento subjacente for lento, instável ou disputado, todos os producers do seu sistema sentem.

No Kubernetes, a história do desempenho de disco se complica por um modo de falha específico que vemos repetidas vezes: o RabbitMQ dividindo um nó com outra carga de trabalho pesada em I/O, normalmente PostgreSQL, Kafka ou Elasticsearch. Quando a carga vizinha dá um pico, as escritas no log Raft do RabbitMQ ficam mais lentas, o lag dos seguidores cresce, os líderes são reeleitos e o cluster parece se degradar misteriosamente, por motivos que o operador não consegue rastrear de imediato.

Visão do especialista: o padrão de contenção de I/O

"Se vocês continuam disputando o mesmo nó com o Postgres, lembrem que o Raft não é só memória e quórum — ele também precisa de disco. Se o Postgres estiver com uso pesado ao mesmo tempo, isso vai provocar a mesma situação que estou discutindo com vocês. Vocês deveriam separar os dois ou, no mínimo, reduzir o número de nós do RabbitMQ para não ficarem disputando recursos."— Felipe Gutierrez, engenheiro sênior, AceMQ

O que monitorar de fato

  • rabbitmq_io_write_time_seconds_total e rabbitmq_io_write_bytes_total — a tendência da latência de escrita é o seu aviso antecipado.
  • Histogramas de latência de escrita em disco no nível do nó (o node_exporter do Kubernetes fornece esses dados).
  • IOPS consumidos pelos pods do RabbitMQ vs IOPS consumidos por todo o resto no mesmo nó.
  • Profundidade da fila de disco — se ela se mantém consistentemente acima de 1–2, você está esperando pelo disco.
  • Taxa de ocupação dos volumes persistentes — o uso de disco das filas de quórum cresce com o volume de mensagens e com a retenção do log.

Limites de alerta

Gere um alerta se a latência de escrita em disco no p99 passar de 50ms em qualquer nó RabbitMQ. Gere um alerta para utilização de volume persistente acima de 75%. E alerte se a profundidade da fila de disco ficar persistentemente acima de 2 por mais de um minuto.

Recomendação de arquitetura

Sempre que possível, dedique nós do Kubernetes ao RabbitMQ usando taints e tolerations. Rode as cargas de trabalho stateful pesadas em I/O no seu próprio node pool. Se isso não for viável, use volumes persistentes separados, em discos físicos separados, para o RabbitMQ e para os vizinhos — o custo de um disco adicional é irrisório perto do custo de uma indisponibilidade em produção causada por contenção de I/O.

4. Agendamento de pods, número de reinicializações e comportamento do StatefulSet

Esta é a pegadinha específica do Kubernetes que pega os operadores desprevenidos: o RabbitMQ é implantado como StatefulSet pelo Cluster Operator oficial, e os pods de um StatefulSet não são reagendados automaticamente em outro nó quando o nó atual falha. Isso é intencional — o StatefulSet oferece identidade e armazenamento estáveis —, mas a consequência operacional é que a falha de um nó pode deixar um pod do RabbitMQ fora do ar por todo o tempo em que o nó estiver indisponível.

Essa não é uma preocupação teórica. Já acompanhamos clientes em incidentes em que um nó do Kubernetes caiu, o pod do StatefulSet do RabbitMQ ficou preso e a aplicação teve uma indisponibilidade prolongada porque o operador esperava um reagendamento automático que o Kubernetes simplesmente não oferece para StatefulSets.

O que monitorar de fato

  • Número de reinicializações por pod do RabbitMQ, acompanhado ao longo do tempo. Um pod com mais de 10 reinicializações em um dia está tentando dizer alguma coisa.
  • Estado de agendamento dos pods — em especial, qualquer pod do RabbitMQ em Pending, Unschedulable ou ContainerCreating por mais de 60 segundos.
  • Status dos nós que hospedam pods do RabbitMQ. Um nó NotReady é uma contagem regressiva para a queda de um pod.
  • Prontidão do StatefulSet — quantas das réplicas desejadas estão Ready no momento.
  • Taxas de falha das liveness e readiness probes. Falhas de probe sob carga geralmente indicam que o broker está sobrecarregado antes de falhar por completo.

Limites de alerta

Alerte imediatamente se o número de réplicas do StatefulSet do RabbitMQ cair abaixo do desejado. Alerte a cada reinicialização de pod. Alerte se qualquer nó que hospeda um pod do RabbitMQ ficar NotReady. Todas essas são condições que exigem ação — você quer uma pessoa olhando para elas, e não um mecanismo de autocorreção que pode ou não funcionar com StatefulSets.

Observação de arquitetura

Se você precisa de uma recuperação automática de falhas de nó mais rápida do que o comportamento padrão do StatefulSet oferece, há algumas opções: usar pod disruption budgets combinados com automação de drain dos nós, implantar o RabbitMQ em várias zonas de disponibilidade do Kubernetes para que a falha de uma zona não derrube o cluster ou — em alguns casos — rodar o broker em VMs dedicadas, totalmente fora do Kubernetes. A escolha certa depende do seu objetivo de tempo de recuperação e da maturidade operacional da sua equipe com Kubernetes.

5. Heartbeats de rede e latência entre nós

Os nós do RabbitMQ mantêm entre si comunicação Erlang distribuída, e a saúde dessa comunicação determina se o cluster continua sendo um cluster. No Kubernetes, a camada de rede introduz uma variabilidade de latência adicional que pode causar falsos positivos de falha de nó — o broker acha que um par caiu porque um heartbeat perdeu a janela, quando na verdade o CNI do Kubernetes só ficou lento por um instante.

O net_ticktime padrão do Erlang, de 60 segundos, costuma ser agressivo demais para ambientes Kubernetes, principalmente os que usam redes overlay ou tráfego entre zonas. Ajustar esse valor é uma das primeiras coisas que fazemos ao preparar um cluster RabbitMQ no Kubernetes para produção.

O que monitorar de fato

  • Eventos de partição de rede — o RabbitMQ registra esses eventos nos logs, e eles devem gerar alerta imediatamente.
  • Latência entre os pods do RabbitMQ (mensurável com um sidecar simples de ping ou com métricas de service mesh).
  • Utilização do buffer de distribuição do Erlang — rabbitmq_erlang_distribution_buffer_busy indica quando a comunicação entre nós está acumulando.
  • Distribuição dos estados das conexões TCP no nível do nó. Um número crescente de conexões em TIME_WAIT ou CLOSE_WAIT pode indicar problemas de rede se formando.
  • Métricas no nível do CNI, se disponíveis (Calico, Cilium etc.) — perda de pacotes entre pods do RabbitMQ é um sinal de alerta precoce.

Limites de alerta

Gere um alerta para qualquer evento de partição de rede. Gere um alerta se a latência p99 entre pods do RabbitMQ passar de 10ms. Gere um alerta para utilização do buffer de distribuição do Erlang acima de 50%.

Recomendação de ajuste

No Kubernetes, aumente o net_ticktime do padrão de 60 segundos para 120 segundos como linha de base. Isso dá mais folga à camada de CNI e reduz drasticamente os falsos positivos de partição do cluster sob o jitter normal da rede. Tick times maiores significam uma detecção um pouco mais lenta de nós que realmente falharam, mas, em ambientes Kubernetes, o trade-off pende fortemente a favor da estabilidade.

Juntando tudo: a sua filosofia de alertas

Monitorar essas cinco áreas não significa criar mais alertas — significa criar os alertas certos. Na nossa experiência, os operadores menos acionados não são os que monitoram menos; são os que monitoram as coisas certas, com os limites certos.

Uma divisão em níveis sensata para um cluster RabbitMQ no Kubernetes:

  • P1 (acionar imediatamente): Perda de quórum em qualquer fila. Nó NotReady. Réplicas do StatefulSet abaixo do desejado. Qualquer conexão de publisher bloqueada. Partição de rede detectada.
  • P2 (acionar em horário comercial): Lag dos seguidores do Raft crescendo de forma persistente. Watermark de memória acima de 80%. Latência de disco p99 acima de 50ms. Reinicialização de pod. Alternância de líderes.
  • P3 (só dashboard, revisão semanal): Tendências de capacidade. Taxa de ocupação do disco. Crescimento do número de conexões. Crescimento da profundidade das filas.

Todo o resto é ruído. Se a sua escala de plantão está sendo acionada por coisas que não se encaixam em P1 ou P2, os seus alertas não estão alinhados com o que realmente importa.

Conclusão prática

O Kubernetes é uma ótima plataforma para o RabbitMQ — desde que você monitore aquilo que o Kubernetes torna diferente. Os modelos mentais de monitoramento de bare metal não se transferem sem ajustes. As cinco categorias de métricas acima são o que monitoramos em todo projeto de RabbitMQ no Kubernetes que atendemos, e são o que recomendamos que toda equipe que roda RabbitMQ no Kubernetes instrumente desde o primeiro dia.

Se você herdou um cluster RabbitMQ no Kubernetes e quer avaliar rapidamente a qualidade do monitoramento, verifique estes cinco pontos, nesta ordem:

  • A saúde da replicação Raft está visível por fila? Se não, você está voando às cegas em relação ao quórum.
  • O watermark de memória está configurado para Kubernetes (mais perto de 0.4 do que de 0.8)? Se não, basta um pico de tráfego para os publishers serem bloqueados.
  • A latência de disco de cada nó RabbitMQ é monitorada e tem alerta? Se não, você não vai conseguir diagnosticar a contenção de I/O quando ela aparecer.
  • O número de réplicas do StatefulSet e o estado de agendamento dos pods têm alerta? Se não, a falha de um nó vai pegar você de surpresa.
  • O net_ticktime está ajustado para o seu ambiente Kubernetes? Se ainda está no padrão, você está tendo partições falso-positivas.

Qualquer cluster que responda "não" a duas ou mais dessas perguntas está a um incidente operacional de descobrir exatamente por que a resposta precisava ser "sim".

Checklist de monitoramento do RabbitMQ para SREs

Se você só for ler uma seção deste post, leia esta. Tudo o que está acima explica por que cada sinal importa; esta é a lista que vai para o runbook. Habilite o plugin rabbitmq_prometheus (nativo desde a 3.8), faça o scrape de todos os nós e importe os dashboards oficiais do Grafana. Depois, acompanhe quatro grupos de métricas.

Cluster. Todos os nós reportando (up em cada alvo de scrape), nenhuma partição (o health check da API de gerenciamento ou rabbitmqctl cluster_status; veja a seção sobre partições de rede acima), estabilidade dos líderes Raft nas filas de quórum (rabbitmq_raft_term_total deve ficar estável; um term subindo significa que há eleições acontecendo) e os dois alarmes de recursos desligados (rabbitmq_alarms_memory_used_watermark e rabbitmq_alarms_free_disk_space_watermark devem ficar em 0). Acompanhe também a folga bruta: rabbitmq_disk_space_available_bytes e rabbitmq_process_resident_memory_bytes em relação a rabbitmq_resident_memory_limit_bytes.

Filas. Profundidade (rabbitmq_queue_messages_ready), mensagens sem acknowledgement (rabbitmq_queue_messages_unacked), número de consumers (rabbitmq_queue_consumers) e utilização dos consumers (rabbitmq_queue_consumer_utilisation, em que um valor baixo significa consumers ociosos esperando pelo broker e um valor perto de 1 significa que o broker está esperando pelos consumers), taxa de reentrega (rabbitmq_queue_messages_redelivered_total) e taxa de dead-letter. Profundidade, por si só, não é problema; profundidade que continua subindo enquanto o número de consumers fica estável, sim.

Throughput e latência. Taxas de publicação e de entrega (rabbitmq_queue_messages_published_total e rabbitmq_queue_messages_delivered_total, calculadas como taxa em uma janela de tempo) e latência dos publisher confirms. O broker não exporta a latência de confirm diretamente, então meça-a na aplicação que publica ou com um publisher canário. Uma diferença entre a taxa de publicação e a de entrega que não se fecha é o sinal de capacidade mais antecipado que você vai ter.

Plataforma. Reinicializações de pods (kube_pod_container_status_restarts_total para o StatefulSet do RabbitMQ), latência dos volumes persistentes a partir da sua storage class ou do node exporter e throttling de CPU (container_cpu_cfs_throttled_periods_total em relação a container_cpu_cfs_periods_total). Um throttling acima de alguns pontos percentuais em um pod de broker aparece como latência de confirm muito antes de qualquer coisa no próprio RabbitMQ parecer errada. As seções sobre agendamento de pods e I/O de disco acima explicam a mecânica.

Os oito alertas que consideramos obrigatórios, com limites iniciais. Ajuste-os à sua carga de trabalho; o objetivo é ter um aviso antes do acionamento.

MétricaAvisoAcionamento
Nó fora do ar (up == 0)1 nó por 2 min2 ou mais nós, ou 1 nó por 10 min
Partição de rede detectadaqualquer uma, imediatamentequalquer uma que dure 5 min
Taxa de rabbitmq_raft_term_totalmais de 1 eleição em 10 minmais de 3 em 10 min
rabbitmq_alarms_memory_used_watermarkmemória acima de 70% do limitealarme ativo (publishers bloqueados)
rabbitmq_disk_space_available_bytesmenos de 20% livreabaixo de 2 × o limite de disco livre
rabbitmq_queue_messages_readycrescendo por 15 minacima da profundidade máxima acordada por 5 min
rabbitmq_queue_consumer_utilisationabaixo de 0,6 por 10 minabaixo de 0,3 com a profundidade crescendo
Reinicializações de pods1 em 1 hora3 em 1 hora, ou CrashLoopBackOff

Há duas coisas que esta tabela não cobre. Primeiro, mensagens unacked subindo com número de consumers estável geralmente significa que um consumer travou ou que o prefetch está alto demais; crie esse alerta por fila crítica, e não de forma global. Segundo, a taxa de dead-letter depende da carga de trabalho, então alerte sobre mudanças em relação à linha de base, e não sobre um número fixo.

Ligue o nível de aviso a um canal que alguém lê durante o dia e o nível de acionamento ao plantão. Se você está construindo o cluster do zero, o nosso playbook de deployment no Kubernetes cobre os resource requests, as storage classes e as regras de anti-affinity que mantêm a maioria desses alertas em silêncio. Quando um deles dispara mesmo assim, o guia de troubleshooting associa cada sintoma a uma correção.

Precisa de ajuda para fortalecer o seu cluster RabbitMQ no Kubernetes?

A AceMQ opera RabbitMQ em produção no Kubernetes para clientes corporativos do setor financeiro, de SaaS, da saúde e de operações da Fortune 1000. Montamos a pilha de monitoramento, ajustamos o broker para os modos de falha específicos do Kubernetes, validamos os seus procedimentos de failover e seguimos com você em produção, sob contrato, para cuidar dos incidentes que você espera nunca ver.

Se a sua equipe está enfrentando problemas de estabilidade do RabbitMQ no Kubernetes — ou está planejando um deployment greenfield no Kubernetes e quer acertar o monitoramento desde o início —, fale com a nossa equipe sobre uma avaliação de saúde do RabbitMQ. Vamos auditar a postura atual do seu monitoramento, identificar as lacunas e montar um plano para fechá-las. Se você precisa de suporte comercial para RabbitMQ ou de consultoria RabbitMQ, é exatamente isso que fazemos.

Perguntas frequentes

Como as equipes de SRE devem monitorar clusters RabbitMQ?

Habilite o plugin rabbitmq_prometheus em todos os nós, faça o scrape dele junto com o kube-state-metrics e o cAdvisor e importe os dashboards oficiais do Grafana. Crie alertas para quatro grupos: saúde do cluster (nós no ar, partições, mudanças de term do Raft, alarmes de memória e disco), saúde das filas (ready, unacked, número e utilização de consumers, reentregas), throughput (taxa de publicação versus taxa de entrega, latência de confirm medida no publisher) e saúde da plataforma (reinicializações de pods, latência dos PVs, throttling de CPU). Use um nível de aviso que vai para um canal e um nível de acionamento que vai para o plantão. A tabela acima traz limites iniciais para os oito alertas que consideramos obrigatórios.

Quais métricas do RabbitMQ indicam problemas de capacidade?

O primeiro sinal é a taxa de publicação superar de forma consistente a taxa de entrega. Em seguida vem rabbitmq_queue_messages_ready crescendo enquanto rabbitmq_queue_consumers fica estável, o que significa que você precisa de mais consumers ou de consumers mais rápidos. rabbitmq_queue_consumer_utilisation perto de 1 significa que os consumers são o gargalo; perto de 0, que o gargalo é o broker. Do lado do broker, memória residente subindo em direção a rabbitmq_resident_memory_limit_bytes, rabbitmq_disk_space_available_bytes caindo e throttling de CPU no pod apontam para um nó subdimensionado. Alarmes de memória ou de disco disparando significam que você já está sem capacidade e que os publishers estão sendo bloqueados.

O que causa instabilidade em um cluster RabbitMQ?

Na nossa experiência, as causas são, mais ou menos nesta ordem: partições de rede por pressão nos nós ou por pod disruption budgets mal configurados; alarmes de memória provocados por filas muito profundas ou por número ilimitado de conexões; contenção de disco em volumes persistentes compartilhados, que deixa as escritas do Raft lentas o suficiente para disparar eleições de líder; pods do StatefulSet reagendados em nós para onde o volume não pode ir junto; e divergência de versões entre os nós durante um upgrade rolling. Quase todas aparecem primeiro como um aumento de rabbitmq_raft_term_total ou como uma reinicialização de pod, e é por isso que esses dois alertas estão no topo da tabela. Cada causa tem a sua própria seção acima.

Precisamos de uma ferramenta comercial para monitorar o RabbitMQ?

Não. O plugin rabbitmq_prometheus, o Prometheus e os dashboards oficiais do Grafana são gratuitos, bem mantidos e suficientes para a maioria dos ambientes, inclusive os grandes. O que eles não oferecem é uma pessoa que os leia às 3 da manhã, saiba qual dos oito alertas é o que importa quando três disparam juntos e já tenha resolvido aquilo antes na sua versão. É isso que um contrato de suporte acrescenta. Atendemos da 3.8.x à 4.x com metas de resposta a partir de 15 minutos, conforme o plano; o valor está na resposta, e não nos dashboards. Mantenha o seu próprio monitoramento e conte conosco para a interpretação e a correção.

O monitoramento é a etapa seis de oito do guia de RabbitMQ no Kubernetes, que trata em ordem o Operator, o armazenamento, a rede, requests e limits e os rolling updates.

Scott Sternloff

Autor

Scott SternloffArquiteto corporativo sênior

Arquiteto corporativo sênior na AceMQ. Escreve a cobertura técnica deste blog: 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

Um olhar especializado sobre seu cluster RabbitMQ

Seja para resolver um incidente em produção, planejar uma migração ou ter uma segunda opinião sobre sua arquitetura, nossa equipe está pronta. Sem discurso de vendas, só respostas.

Envie um e-mail