BlogRabbitMQ

Filas de quórum do RabbitMQ: como funcionam e quando a fila clássica ainda vence

Scott Sternloff

Por Scott Sternloff, Arquiteto corporativo sênior

LinkedIn · Atualizado em · 14 min de leitura

Filas de quórum do RabbitMQ: como funcionam e quando a fila clássica ainda vence
On this page

A resposta curta: use filas de quórum (quorum queues) por padrão e mantenha filas clássicas para trabalho realmente transitório e de alta rotatividade, em que perder uma mensagem na falha de um nó é aceitável. Essa tem sido a orientação certa há algum tempo, mas o raciocínio importa mais que a regra — porque são as duas exceções e o custo da migração que de fato complicam a vida das equipes.

Essa pergunta aparece o tempo todo em avaliações de RabbitMQ, normalmente de duas formas: um operador que herdou um cluster cheio de filas clássicas e quer saber se a conversão vale a interrupção, ou uma equipe desenhando algo novo que precisa de um padrão defensável.

Os três tipos de fila, comparados no que importa

O RabbitMQ tem três mecanismos de armazenamento que vale conhecer, e o terceiro nem é uma fila — exatamente por isso ele é mal utilizado.

Matriz comparativa entre fila clássica, fila de quórum e stream do RabbitMQ quanto a armazenamento, comportamento de leitura, replicação, sobrevivência a queda de energia e no que cada uma é melhor

A linha que decide a maioria dos designs é Sobrevive a queda de energia. Uma fila de quórum replica e grava cada mensagem em disco em um quórum de nós antes de confirmar ao publisher. Uma fila clássica persiste localmente, mas não tem replicação, então a falha de um nó leva a fila junto. Um stream replica, mas não faz fsync antes de confirmar, o que significa que ela tem a mesma exposição do Kafka — aceitável para telemetria, errado para pagamentos.

A linha que as pessoas interpretam mal é Leituras. Filas clássicas e de quórum são destrutivas: um consumer pega a mensagem e ela some. Streams são não destrutivos: a mensagem permanece, e muitos consumers podem ler o mesmo histórico de forma independente, cada um no seu próprio offset. Se você se pegar querendo reler mensagens de uma fila, o que você quer é um stream.

Por que uma fila de quórum pode se dar ao luxo de fazer fsync

A objeção habitual às filas de quórum é que gravar em disco a cada mensagem só pode ser lento. Não é, e o motivo é uma decisão de design que vale entender, porque é também a diferença técnica mais marcante entre RabbitMQ e Kafka.

Diagrama mostrando um publisher gravando na réplica líder de uma fila de quórum, que faz append em um write-ahead log compartilhado por várias filas, replicado para duas réplicas seguidoras, contrastando o fsync amortizado do RabbitMQ com o fsync por partição do Kafka

As filas de quórum compartilham um write-ahead log. Uma única gravação em disco cobre mensagens destinadas a muitas filas diferentes, então o custo é amortizado por todo o broker, em vez de ser pago separadamente por cada fila. É isso que torna viável ter muitas filas, replicação com fsync e throughput real ao mesmo tempo — três propriedades entre as quais normalmente você teria de escolher duas.

O Kafka funciona ao contrário: o fsync acontece por partição, o que o torna caro a ponto de o Kafka desencorajá-lo por padrão e depender só da replicação. Não é exatamente um defeito, e sim uma aposta diferente, mas significa que uma mensagem do Kafka com acknowledgement está no page cache de vários brokers, e não em disco.

Há um segundo benefício, mais sutil. O Raft em uma fila de quórum cobre o estado de entrega, e não só o conteúdo das mensagens — qual mensagem foi entregue a qual consumer e quantos créditos esse consumer tem. Depois de um failover do líder, o novo líder retoma com esse estado intacto, em vez de reentregar um lote inteiro. É esse mecanismo que torna possíveis o TTL por mensagem, as prioridades, os atrasos e o roteamento de dead-letter.

Como as filas de quórum garantem durabilidade e failover

O mecanismo de amortização do fsync descrito acima explica por que as filas de quórum são rápidas o bastante para serem usadas por padrão. Ele não explica como elas de fato sobrevivem à morte de um nó no meio do fluxo, que é a parte que vale entender antes de depender disso em produção.

Uma fila de quórum é um grupo Raft: um número ímpar de membros, um por nó, com um membro eleito líder a cada momento. O líder aceita todas as publicações e entregas a consumers; os seguidores replicam o log do líder e votam nas eleições. Quando o líder silencia, seja porque o nó caiu ou porque a rede o isolou, os seguidores percebem pela falta de heartbeat, esperam um timeout de eleição aleatório para que dois seguidores não convoquem uma eleição no mesmo instante, e o primeiro a obter a maioria dos votos se torna o novo líder em um novo termo. Sem ação do operador e sem indisponibilidade visível para o cliente além da reconexão.

O que um publisher confirm realmente significa: o RabbitMQ só devolve o confirm depois que a mensagem foi gravada na maioria dos membros do grupo, e não apenas no líder. Em uma fila com três membros, são dois de três. A escrita é durável nesse ponto, mesmo que o nó com a terceira réplica nunca volte; perdê-lo custa uma réplica, não a mensagem.

Esse requisito de maioria também define a disponibilidade em cada quantidade de falhas. Com três membros: perca um, e os dois restantes ainda formam maioria, então a fila continua aceitando escritas e simplesmente opera com uma réplica a menos até o nó ausente voltar e se atualizar a partir do log Raft. Perca dois, e o único nó sobrevivente não consegue formar maioria sozinho, então a fila para totalmente de aceitar escritas, por design, em vez de arriscar que um membro com log incompleto se torne a fonte de verdade sem contestação. É a mesma lógica por trás de pause_minority no nível do cluster, aplicada por fila.

É também por isso que um número par de membros é pior do que parece, e não apenas desnecessário. Uma fila com quatro membros continua tolerando apenas a perda de um membro antes de ficar com dois sobreviventes de quatro, o que não é maioria: você acrescentou uma réplica inteira, com o overhead do Raft e o custo de memória, para exatamente a mesma tolerância a falhas de três. Por isso, a quantidade de membros deve sempre ser ímpar. O posicionamento das réplicas segue a mesma lógica do posicionamento dos nós do cluster: um membro por nó, distribuídos em hosts ou zonas de disponibilidade separados, para que uma única falha de infraestrutura não derrube dois membros da mesma fila ao mesmo tempo.

Um exemplo prático: filas de quórum para processamento de pagamentos

Processamento de pagamentos é a carga de trabalho para a qual o modelo de durabilidade acima foi feito: cada mensagem importa, a ordem importa dentro de uma conta, e duplicação silenciosa é pior que um retry lento. Veja como as peças se encaixam nesse caso específico.

  • Topologia. Uma fila de quórum com três membros, um nó por zona de disponibilidade, atende tanto ao requisito de durabilidade quanto à falha de uma zona inteira, sem nenhum tratamento especial. É o mesmo padrão de três AZs descrito no nosso guia de HA, disaster recovery e dimensionamento de clusters; uma carga de pagamentos é exatamente o caso que justifica não reduzir para uma única AZ só para economizar um nó.
  • Publisher confirms, e não fire-and-forget. O serviço que inicia um pagamento espera o publish confirm do broker antes de informar ao chamador que o pagamento foi aceito. Dada a garantia de escrita em maioria descrita acima, esse confirm significa que a instrução de pagamento está durável em pelo menos dois de três nós antes que qualquer sistema downstream seja informado.
  • Retries limitados com dead letter. Defina x-delivery-limit na fila para que uma mensagem que continua falhando no processamento do consumer não fique em loop para sempre. Depois que ela esgotar as tentativas de entrega, encaminhe-a para uma dead-letter queue dedicada em vez de descartá-la. Uma DLQ de pagamentos deve ser tratada como condição de alerta, não como lixeira: tudo o que cai nela precisa ser analisado por uma pessoa ou por um job automático de conciliação, porque representa um pagamento que não foi concluído corretamente nas primeiras tentativas.
  • Consumers idempotentes com chave no ID do pagamento. As filas de quórum, assim como as clássicas, oferecem entrega at-least-once. Combinado com o delivery limit e a DLX acima, um consumer pode ver a mesma mensagem de pagamento mais de uma vez. Projete o consumer para verificar (ou fazer upsert contra) um ID de pagamento já registrado como processado antes de aplicar a transação de novo, para que uma reentrega não tenha efeito, em vez de gerar uma cobrança ou um lançamento contábil duplicado.
  • Single active consumer para liquidação ordenada. Quando a ordem de liquidação importa dentro de uma conta, por exemplo ao aplicar débitos e créditos em sequência, defina x-single-active-consumer na fila para que apenas uma instância de consumer a processe por vez, com failover automático para um consumer de reserva se o ativo morrer. Isso troca um pouco de throughput por ordenação estrita por fila, o que normalmente é a troca certa quando há dinheiro em movimento.
  • O que monitorar. A profundidade da fila e o lag dos consumers na própria fila de pagamentos, a profundidade da DLQ (que deve ficar perto de zero; qualquer crescimento sustentado é um incidente), a contagem de reentregas por consumer (uma tendência de alta indica bug no consumer, não problema de saúde do broker) e o status de sincronização das réplicas nos três membros, para que uma réplica atrasada seja detectada antes de ser a única restante. Para padrões além dessa fila, veja como as mesmas garantias de durabilidade se combinam em um design orientado a eventos mais amplo em exchanges, filas e bindings para microsserviços e, para o panorama completo de como a AceMQ define o escopo de um design de mensageria com nível de pagamentos, veja resiliência e otimização de pagamentos.

O que você perde ao converter

A maioria das orientações para em "use filas de quórum". A parte útil são as duas coisas que de fato pegam as pessoas de surpresa.

  • A memória por fila é maior. Uma fila de quórum carrega estado Raft e ocupa mais memória que uma fila clássica. Se o seu design tem milhares de filas pequenas e de vida curta — um padrão comum por sessão ou por requisição —, converter todas de uma vez pode levar o cluster a uma pressão de memória que não existia antes. Essa é a forma mais comum de uma migração bem-intencionada causar um incidente.
  • A prioridade não funciona da mesma forma. As filas clássicas implementam prioridade por meio de x-max-priority. As filas de quórum tratam prioridade de outro jeito e não oferecem um mecanismo idêntico, então uma fila cujo comportamento depende da semântica de prioridade das clássicas precisa ter o design revisto, e não simplesmente ser declarada de novo. Encontre essas filas antes de planejar a migração, e não durante.

Também existe um teto rígido que vale conhecer: uma fila de quórum não tem sharding. Ela chega a cerca de 80.000 mensagens por segundo com replicação e fsync, e você não consegue dividir uma fila entre nós para ir mais rápido. O throughput agregado de muitas filas escala bem, mas um único fluxo muito intenso precisa de sharding na aplicação — publicar em N filas com uma routing key que distribua a carga. Tratamos dessa limitação e de como ela se compara ao particionamento do Kafka em RabbitMQ vs. Kafka.

Como escolher, e quanto uma conversão realmente custa

Quatro perguntas resolvem a questão para uma determinada fila.

Fluxograma de decisão com quatro perguntas sobre tolerância à perda de mensagens, recursos por mensagem, taxa de rotatividade e necessidade de replay, levando a fila de quórum, fila clássica ou stream, com o aviso de que a conversão não é feita in-place

O aviso desse fluxograma é a realidade operacional: o tipo da fila é definido na declaração. Não existe conversão in-place. Migrar significa declarar uma nova fila de quórum, apontar publishers e consumers para ela, drenar a fila clássica e removê-la quando estiver vazia. Em um sistema em produção, isso é uma mudança coordenada com janela de drenagem, não uma edição de configuração.

A sequência que funciona: converta primeiro as filas que carregam trabalho que você não pode perder, em pequenos lotes, acompanhando a memória pelo caminho. Deixe como clássicas as filas realmente transitórias. Resista à tentação de converter tudo de uma vez — é exatamente essa mudança que transforma uma melhoria de segurança em uma indisponibilidade.

Se você está avaliando uma conversão em um ambiente grande e quer que as armadilhas de memória e prioridade sejam encontradas antes de começar, e não durante, isso faz parte normal de um health check de RabbitMQ — ou fale com a AceMQ para definir o escopo.

Várias das crenças por trás dessas escolhas já não se sustentam — mitos e realidade do RabbitMQ.

O tipo de fila é a segunda de sete decisões do guia de clustering e dimensionamento do RabbitMQ; a escolha errada também é o padrão quatro de dez no guia de confiabilidade.

Perguntas frequentes

Qual é a diferença entre uma fila clássica e uma fila de quórum?

Uma fila clássica fica em um único nó, com persistência por mensagem; se esse nó falhar, a fila e seu conteúdo ficam indisponíveis até ele voltar. Uma fila de quórum é replicada em um número ímpar de nós usando consenso Raft e grava cada mensagem em disco em um quórum de réplicas antes de confirmar ao publisher. A clássica é local e rápida para alta rotatividade; a de quórum é replicada e segura, e é o padrão recomendado para tudo o que você não pode perder.

As filas de quórum são mais lentas que as filas clássicas?

Um pouco, e menos do que a maioria imagina. Uma única fila de quórum chega a cerca de 80.000 mensagens por segundo com replicação e fsync; uma fila clássica vai um pouco além porque não faz nenhum dos dois. As filas de quórum continuam rápidas porque compartilham um write-ahead log, então um único fsync cobre muitas filas e o custo é amortizado, em vez de ser pago por fila.

Quando ainda devo usar uma fila clássica?

Quando o trabalho é de fato transitório e de alta rotatividade e perder uma mensagem na falha de um nó é aceitável — broadcasts de invalidação de cache, notificações efêmeras, trabalho temporário que será regenerado de qualquer forma. As filas clássicas também ocupam menos memória por fila, o que importa se você roda um número muito grande de filas pequenas e de vida curta.

Dá para converter uma fila clássica em fila de quórum sem recriá-la?

Não. O tipo da fila é definido na declaração, então converter significa declarar uma nova fila de quórum, mover publishers e consumers para ela, drenar a fila clássica e depois removê-la. Planeje isso como uma migração com janela de drenagem. Converter milhares de filas de uma só vez é a migração que mais costuma dar errado.

As filas de quórum suportam prioridade de mensagens?

Não da mesma forma. As filas clássicas suportam prioridade pelo argumento x-max-priority; as filas de quórum tratam prioridade de outro jeito e não oferecem um mecanismo idêntico, então uma fila que depende da semântica de prioridade das clássicas precisa ter o design revisto, e não simplesmente convertido. Isso e o maior uso de memória por fila são as duas armadilhas que pegam as equipes no meio da migração.

Quantos nós as filas de quórum precisam?

Um número ímpar, com três como base prática — isso tolera a falha de um nó mantendo a maioria. Cinco é comum em implantações maiores e tolera duas falhas. Acima de cinco, o overhead de consenso cresce sem muito ganho de segurança, então clusters maiores geralmente têm outra motivação que não os requisitos de quórum.

Os streams substituem as filas de quórum?

Não — eles resolvem outro problema. Um stream é um log append-only com leituras não destrutivas: consumir não remove a mensagem, e muitos consumers podem ler o mesmo histórico de forma independente. Uma fila de quórum é uma fila de trabalho com leituras destrutivas e acknowledgement por mensagem. Os streams também não fazem fsync antes de confirmar, então oferecem uma garantia de durabilidade mais fraca.

As filas de quórum sobrevivem a falhas de nós?

Sim, esse é o principal objetivo delas. Uma fila de quórum replica cada mensagem para a maioria dos seus membros usando consenso Raft antes de confirmar a publicação; assim, uma fila com três membros continua operando depois de perder um nó e só para de aceitar escritas se perder um segundo, já que dois de três não podem mais ser alcançados. Os membros devem ficar um por nó, em hosts ou zonas de disponibilidade separados, para que uma única falha de infraestrutura não remova mais de uma réplica por vez.

As filas de quórum aguentam o throughput de processamento de pagamentos?

Uma única fila de quórum chega a cerca de 80.000 mensagens por segundo com replicação e fsync, bem acima do que a maioria das cargas de pagamento precisa por fila. Se um fluxo específico precisar de mais do que isso, faça o sharding em várias filas de quórum com uma routing key, em vez de esperar que uma única fila escale mais, já que as filas de quórum não têm sharding interno. Combinado com publisher confirms, `x-delivery-limit`, dead-lettering e consumers idempotentes, o throughput raramente é o fator limitante em pagamentos; a correção sob retry é.

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.

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