RabbitMQ

RabbitMQ: alta disponibilità, disaster recovery e sizing del cluster. Una guida pratica

Scott Sternloff

Di Scott Sternloff, Enterprise Architect senior

LinkedIn · Aggiornato il

LEADERnode-1REPLICAnode-2REPLICAnode-3QUORUM: 2/3
In questa pagina
Impostare correttamente l'alta disponibilità in RabbitMQ è una delle decisioni architetturali con più conseguenze che prenderete. Troppo pochi nodi e perdete il quorum durante un guasto. Troppi e pagate capacità che non vi serve. Un design di failover sbagliato e la vostra configurazione di DR non vi protegge davvero nel momento in cui ne avete bisogno.
Questa guida copre i fondamentali: come dimensionare il cluster, come funziona davvero l'HA delle code quorum, come progettare il disaster recovery tra siti o availability zone e le insidie che colgono i team alla sprovvista.
This guide covers the fundamentals: how to size your cluster, how quorum queue HA actually works, how to design for disaster recovery across sites or availability zones, and the gotchas that catch teams off guard.

Quanti nodi dovrebbe avere un cluster RabbitMQ?

La raccomandazione standard per i cluster RabbitMQ di produzione è di tre nodi. Non è una scelta arbitraria: deriva dai requisiti di quorum del meccanismo di consenso Raft di RabbitMQ, alla base delle code quorum e della gestione dei metadati del cluster.
Con tre nodi: se un nodo si ferma, ne restano due su tre, che costituiscono ancora una maggioranza di quorum. Se si fermano due nodi, quello rimasto non opererà come fonte di verità (il comportamento "pause minority" di RabbitMQ impedisce correttamente la perdita di dati).

"Il dimensionamento minimo è di tre nodi in un cluster, e tre è di fatto la configurazione normale raccomandata finché non si arriva a esigenze di throughput davvero elevate."

— Scott Sternloff, Principal Architect di AceMQ, discovery call con una società di servizi finanziari, giugno 2026

Perché non due nodi? Un cluster a due nodi sembra funzionare finché uno dei due non si ferma: a quel punto nessuno dei due nodi è in grado di stabilire se sia la maggioranza o la minoranza, ed entrambi si mettono in pausa. I cluster con un numero pari di nodi (due, quattro) creano ambiguità; quelli con un numero dispari (tre, cinque, sette) no.
L'anti-affinity è obbligatoria: tutti e tre i nodi dovrebbero girare su host fisici separati (o in availability zone separate, se si opera nel cloud). Eseguire due nodi del cluster sulla stessa VM o sullo stesso host fisico vanifica l'HA: se quell'host si guasta, perdete subito la maggioranza.

Come funziona davvero l'HA delle code quorum?

Le code quorum usano il consenso Raft per replicare i messaggi su una maggioranza dei nodi del cluster prima di confermarli al publisher. Questo significa che:
  • I messaggi vengono scritti su N/2+1 nodi prima di essere confermati (dove N è la dimensione del cluster)
  • In un cluster a tre nodi, i messaggi devono essere scritti su almeno due nodi prima della conferma
  • Se un nodo si guasta, i messaggi restano disponibili sui due nodi rimanenti: nessuna perdita di dati
  • L'elezione del leader è automatica: se il nodo primario di una coda si guasta, viene promossa una delle repliche
È un miglioramento sostanziale rispetto al vecchio approccio delle classic mirrored queue, che soffriva di rischi di split-brain, di un comportamento di failover incoerente e richiedeva una sincronizzazione manuale dopo il recupero dei nodi.
L'insidia che i team non vedono: la protezione del quorum significa che RabbitMQ limita deliberatamente l'accesso quando il quorum viene perso. Se una partizione di rete isola un singolo nodo dagli altri due, quel nodo si mette in pausa invece di rischiare di diventare una fonte di verità divergente. Progettate la topologia di rete e il monitoraggio aspettandovi questo comportamento, non per aggirarlo.

Come si dimensiona un cluster in base al throughput?

Il sizing del cluster dipende da tre fattori: tasso di messaggi, dimensione del payload e capacità dei consumer.
Per un deployment che gestisce circa 1.000–2.000 messaggi al secondo con payload tipici nell'ordine dei 100–200 KB, un cluster a tre nodi con 4–8 vCPU per nodo è una base ragionevole.

"Non si vuole sovradimensionare inutilmente, ma nemmeno tornare subito a dire che siamo al limite e cercare di ottenere di nuovo il budget. Si tratta di capire cosa è critico, con equilibrio."

— Scott Sternloff, Principal Architect di AceMQ, discovery call con una società di servizi finanziari, giugno 2026

Il vincolo è più spesso la memoria che la CPU. RabbitMQ fa un uso intensivo della memoria quando le code crescono o quando i messaggi attendono i consumer. La memoria dei nodi va dimensionata per contenere comodamente la profondità delle code prevista nei picchi di carico, con un margine.
L'I/O su disco conta per le code quorum. Poiché le code quorum scrivono sul WAL e sui file di segmento prima di confermare, il throughput del disco incide direttamente sulla latenza di conferma dei messaggi. È fortemente consigliato uno storage SSD veloce (NVMe o equivalente).

Distribuire un cluster su tre availability zone

Un cluster esteso tra regioni con una latenza di rete reale si scontra con il ritardo del consenso Raft descritto sopra, ed è un limite concreto. Tre availability zone all'interno di una singola regione sono una situazione diversa. I round trip tra AZ all'interno di una regione richiedono tipicamente uno o due millisecondi, ampiamente entro quanto il consenso Raft tollera senza scambiare la normale latenza per un segnale di guasto. Per questo un nodo per AZ è lo schema di produzione standard e non un compromesso.

Tre è il minimo per la stessa ragione per cui lo è ovunque in questa guida, applicata nello spazio: un nodo in ciascuna di tre AZ vi offre tolleranza ai guasti a livello di nodo e a livello di zona con la stessa topologia a tre nodi, senza nodi aggiuntivi per ottenere entrambe. Un cluster con tutti e tre i nodi in una sola AZ ha la tolleranza a livello di nodo ma non quella a livello di zona, il che vanifica lo scopo stesso di trovarsi in una regione multi-AZ.

In un cluster a tre nodi su tre AZ, il posizionamento dei membri del quorum segue automaticamente quello dei nodi: per impostazione predefinita le tre repliche di ogni coda finiscono una per zona, poiché RabbitMQ colloca un membro per nodo fino alla dimensione del gruppo configurata. Nei cluster più grandi che coprono più di tre AZ o con più di tre nodi per AZ, non date per scontato che valga ancora: impostate la policy queue-leader-locator su balanced e verificate con rabbitmqctl list_queues name leader members che le repliche delle code critiche non si accumulino in un'unica zona.

È pause_minority a proteggervi davvero quando una zona si spegne, non solo quando si guasta un singolo nodo. Questo vale fino alla 4.2 inclusa. Da RabbitMQ 4.3 in poi non è più così: la 4.3.0 ha rimosso Mnesia e, con essa, le strategie di gestione delle partizioni; cluster_partition_handling è ancora accettato in rabbitmq.conf ma non ha alcun effetto, e metadata store, code quorum e stream sono tutti basati su Raft, quindi è la sola regola della maggioranza Raft a decidere quale lato continua a servire. Rimuovete la chiave quando fate l'upgrade. Se un'AZ diventa irraggiungibile dalle altre due, il nodo isolato si mette in pausa invece di rischiare di diventare una fonte di verità divergente, e le due AZ che continuano a vedersi mantengono in funzione il cluster come maggioranza. Progettate l'alerting in modo che quella pausa sia attesa come il comportamento corretto durante l'interruzione di una zona, non come un ulteriore incidente che si aggiunge al primo.

Tenete d'occhio il budget di latenza come segnale continuo, non come controllo una tantum. Se i round trip tra AZ superano costantemente i cinque millisecondi circa, non fate tuning per aggirarli come se si trattasse di una partizione casuale: consideratelo un segnale che la disposizione delle AZ nella regione o il percorso di rete del vostro cloud provider non si sta comportando come una latenza intra-regione, e indagate sulla topologia prima di indagare su RabbitMQ.

Quando una zona va davvero giù, aspettatevi tre cose in quest'ordine: il nodo di quella zona sparisce da rabbitmqctl cluster_status sui nodi superstiti, ogni coda che aveva il leader in quella zona avvia una nuova elezione tra le repliche superstiti e ogni connessione client vincolata al nodo della zona persa cade e deve riconnettersi altrove. Mettete un load balancer o una voce DNS davanti a tutti e tre i nodi invece di scrivere nella configurazione dei client l'indirizzo di un singolo nodo, eseguite l'health check di ogni nodo singolarmente così che una zona caduta venga tolta dalla rotazione senza un intervento manuale, e assicuratevi che le librerie client abbiano il recupero automatico delle connessioni abilitato, così una connessione caduta si riconnette da sola a un nodo superstite invece di richiedere il riavvio dell'applicazione.

Dimostrare l'alta disponibilità prima del go-live: checklist delle esercitazioni di guasto

Un cluster che non è mai stato rotto di proposito è un cluster le cui promesse di HA restano teoriche. Eseguite ciascuno di questi test prima del go-live, e di nuovo dopo ogni modifica significativa della topologia, con qualcuno che verifica l'osservazione attesa, non che si limita a confermare che il cluster prima o poi è tornato su.

  • Terminate un nodo di colpo (kill -9 sul processo beam). Atteso: gli altri due nodi lo segnalano come fermo entro un intervallo di heartbeat, i leader delle code quorum su quel nodo vengono rieletti e i client con recupero delle connessioni si riconnettono senza errori applicativi.
  • Eseguite un drain controllato di un nodo con rabbitmqctl stop_app. Atteso: la leadership viene ceduta prima che il processo si fermi davvero e nel log non compaiono eventi di elezione non pianificati.
  • Isolate una zona dalle altre due a livello di rete. Atteso: il nodo isolato si mette in pausa con pause_minority, la maggioranza superstite continua a funzionare e le scritture non vengono mai accettate su entrambi i lati contemporaneamente.
  • Riempite il disco di un nodo. Atteso: scatta localmente un allarme disco, quel nodo blocca le nuove connessioni e il resto del cluster non ne risente.
  • Esaurite la memoria di un nodo. Atteso: scatta un allarme di memoria, i publisher verso quel nodo vengono bloccati e i consumer continuano a smaltire ciò che è già in coda.
  • Riavviate un nodo sotto un carico sostenuto equivalente a quello di produzione. Atteso: rientra nel cluster e le sue repliche si risincronizzano automaticamente, senza interventi manuali e senza picchi visibili nella profondità delle code.
  • Forzate la scadenza di un certificato TLS (o simulatela in un ambiente inferiore). Atteso: le connessioni falliscono con un chiaro errore di handshake, non con un blocco silenzioso, a conferma che il runbook di rotazione funziona davvero prima che scada un certificato reale.
  • Terminate proprio il nodo che è leader di una coda critica, non un nodo a caso. Atteso: un nuovo leader viene eletto in pochi secondi e i publisher confirm in corso vengono ritentati in modo trasparente dalla libreria client.
  • Arrestate contemporaneamente tutti i nodi di un'AZ per simulare l'interruzione completa di una zona. Atteso: le due zone restanti mantengono disponibili per tutto il tempo il cluster e tutte le code quorum.
  • Togliete un nodo dalla rotazione del load balancer tramite il suo health check prima di intervenire. Atteso: il traffico smette di essere instradato verso di esso prima di qualsiasi altra azione, senza alcun errore visibile ai client.
  • Eseguite un rolling upgrade, un nodo alla volta. Atteso: il cluster resta disponibile per l'intera sequenza e la finestra con versioni miste si chiude entro il tempo di manutenzione pianificato.
  • Fate andare in crash un consumer a metà di un acknowledgement. Atteso: i suoi messaggi non confermati tornano automaticamente in coda appena la connessione si chiude, senza perdita di messaggi.
  • Iniettate latenza artificiale tra due AZ invece di interrompere del tutto il collegamento. Atteso: vedete come si presenta nelle metriche una vera congestione di rete, così durante un incidente reale non la scambierete per un guasto hardware.

Per i cluster che girano su Kubernetes gestito, la versione specifica per piattaforma di molte di queste esercitazioni, in particolare i casi di drain dei nodi e rolling upgrade, è trattata in RabbitMQ su EKS, AKS o GKE e in architettura RabbitMQ di produzione per le aziende. Se il vostro cluster è già in produzione e preferite che qualcuno esegua questa lista di esercitazioni con un carico equivalente a quello di produzione invece di scriverla da zero, è il tipo di intervento che il nostro lavoro di stabilizzazione mission-critical su Kubernetes e il team di supporto svolgono regolarmente, con obiettivi di risposta da 15 minuti, in base al piano, se un'esercitazione fa emergere una lacuna reale.

Obiettivi di risposta da 15 minuti, in base al piano. Ingegneri senior dedicati.

Contattateci

Come funziona il disaster recovery tra availability zone o siti?

Il clustering standard di RabbitMQ è progettato per operare a bassa latenza all'interno dello stesso datacenter. Estendere un cluster tra availability zone o siti con una latenza significativa introduce ritardi nel consenso Raft e non è consigliato su distanze geografiche.
L'architettura corretta per il disaster recovery multi-sito o multi-AZ è la warm schema replication (disponibile nella distribuzione commerciale Tanzu RabbitMQ).
Cosa fa la warm schema replication:
  • Mantiene in un sito secondario una copia quasi in tempo reale dell'intero schema RabbitMQ: tutte le code, i binding, gli exchange, i virtual host, gli utenti e i permessi
  • Inoltra in modo asincrono al secondario i messaggi in transito, così il secondario dispone dello stato sincronizzato più recente
  • Consente in qualsiasi momento di promuovere il secondario a primario con uno sforzo di ripristino minimo
  • Supporta la promozione bidirezionale: entrambi i siti possono diventare primari

"È una copia quasi in tempo reale dell'ambiente. Le transazioni vengono effettivamente inviate in modo asincrono e confermate. Quindi, invece di essere una copia su cui bisogna recuperare tutto, è lo stato sincronizzato più recente del message broker che si possa ottenere."

— Scott Sternloff, Principal Architect di AceMQ, discovery call con una società di servizi finanziari, giugno 2026

E le licenze per il DR tra siti?

Nel modello di licenza commerciale, gli ambienti vengono conteggiati indipendentemente dal fatto che siano di produzione, QA, UAT o DR. Una configurazione completamente replicata di produzione più DR richiede licenze sia per il cluster primario sia per quello di DR.
Per i deployment più piccoli è possibile ottimizzare: gli ambienti inferiori (QA, UAT) potrebbero non richiedere repliche di DR, e quegli ambienti possono essere dimensionati in modo più contenuto.

"Se replicate solo la produzione, gli ambienti inferiori non hanno bisogno del DR. Il vostro ambiente di QA potrebbe non aver bisogno affatto del clustering: o è su o è giù. Quindi potete semplificare molto e ridurre di conseguenza il numero di licenze."

— Scott Sternloff, Principal Architect di AceMQ, discovery call con una società di servizi finanziari, giugno 2026

Che stiate dimensionando un nuovo cluster, progettando un failover multi-sito o valutando se la warm schema replication valga il costo della licenza commerciale, contattate il supporto AceMQ e definiremo il perimetro in base al vostro ambiente specifico.

Negli ambienti regolamentati, lo stack circostante comporta obblighi propri: vedere lo stack di messaging nei settori regolamentati.

Se la questione aperta è il meccanismo per spostare i messaggi tra regioni, più che come dimensionare e collocare i cluster, quella decisione ha una guida dedicata: federation o shovel di RabbitMQ per il disaster recovery.

Come testare il disaster recovery di RabbitMQ: l'esercitazione che eseguiamo prima del go-live

Un cluster che non ha mai perso un nodo sul serio vi sorprenderà la prima volta che succede, di solito alle 2 di notte. Questo è il programma che eseguiamo con i clienti prima che un cluster RabbitMQ porti traffico di produzione. Richiede circa una giornata e produce numeri, non opinioni.

Prerequisiti.

  • Un cluster di staging configurato come la produzione: stesso numero di nodi, stesso posizionamento sulle AZ, stessa versione di RabbitMQ (lo eseguiamo su tutte le versioni dalla 3.8.x alla 4.x), stessi tipi di coda, policy, librerie client e impostazioni di connessione. Le code quorum e quelle classiche si guastano in modo diverso, quindi se la produzione le ha entrambe, anche lo staging deve averle. Vedere /blogs/rabbitmq-classic-vs-quorum-queues/ per capire perché qui conta.
  • Publisher e consumer sintetici con numeri di sequenza. Ogni publisher marca i messaggi con uno stream id e un contatore crescente; ogni consumer registra ogni sequenza che vede. Così perdite (un buco) e duplicazioni (una ripetizione) diventano contabili invece che opinabili. I publisher usano i confirm, i consumer gli ack manuali.
  • Dashboard attive: profondità delle code, tassi di pubblicazione e consegna, allarmi di memoria e disco, numero di leader quorum per nodo, connessioni e canali, latenza dei confirm lato client. Se non potete vederlo, non potete superarlo.
  • Un responsabile del runbook designato, un canale condiviso e un cronometro.

Le esercitazioni, in ordine.

  1. Terminate un membro del quorum. Arrestate RabbitMQ su un nodo che è follower della maggior parte delle code. Osservate l'elezione del leader sulle code che guidava e la latenza dei confirm sui publisher. Superato se: l'elezione si completa in pochi secondi, zero buchi di sequenza sui consumer, i publisher confirm continuano ad arrivare per tutto il tempo. Riavviate il nodo e verificate che rientri e si riallinei.
  1. Terminate il nodo con più leader. I leader si accumulano sul nodo avviato per primo, quindi questa è la versione più difficile dell'esercitazione 1. Terminatelo, osservate gli stessi segnali, riportatelo su e poi ribilanciate:
rabbitmq-queues rebalance quorum

Superato se: nessuna perdita, i confirm continuano e dopo il ribilanciamento il numero di leader è all'incirca uniforme tra i nodi.

  1. Riempite un disco fino all'allarme di spazio libero. Scrivete un file di grandi dimensioni su un nodo finché non scatta disk_free_limit. Superato se: le connessioni dei publisher risultano bloccate nella management UI, le pubblicazioni si fermano invece di fallire, i consumer continuano a smaltire e la pubblicazione riprende da sola una volta eliminato il file. Se si fermano anche i consumer, un consumer condivide una connessione con un publisher: correggetelo prima del go-live.
  1. Partizionate la rete tra i nodi. Con cluster_partition_handling = pause_minority, bloccate con iptables il traffico tra un nodo e gli altri due. Superato se: il nodo in minoranza si mette in pausa, le code quorum sul lato della maggioranza continuano a servire, i client sul nodo in pausa ricevono un errore di connessione e si riconnettono a un host superstite della loro lista di indirizzi, e il cluster si ricompone senza intervento manuale quando la regola viene rimossa. Annotate cosa hanno scritto nei log i client: quella riga è ciò che vedrà il vostro ingegnere di reperibilità.
  1. Perdete un'availability zone. Arrestate contemporaneamente tutti i nodi di un'AZ. In una disposizione su tre AZ sopravvive una maggioranza. Superato se: identico all'esercitazione 1, zero perdite e confirm continui. Se il load balancer impiega più di qualche secondo a escludere i nodi caduti, correggete subito l'health check.
  1. Failover regionale. Fermate i publisher, annotate la sequenza più alta confermata nella regione A, mettete giù la regione A ed eseguite il failover sulla regione B usando il percorso cross-region che avete scelto (vedere /blogs/rabbitmq-federation-vs-shovel-disaster-recovery/). L'RPO è il numero di messaggi confermati in A che non compaiono mai in B; si legge direttamente dai log delle sequenze. L'RTO è il tempo effettivo dall'interruzione al momento in cui i consumer girano su B. Superato se: entrambi i valori rientrano negli obiettivi approvati dal business. Metteteli per iscritto: sono la risposta onesta alla domanda "qual è la nostra postura di DR".
  1. Failback senza duplicati. Riportate su la regione A e reindirizzate il traffico verso di essa. Superato se: i log delle sequenze dei consumer non mostrano ripetizioni. Se le mostrano, i consumer non sono idempotenti, e la correzione va fatta nell'applicazione, non nel broker.
  1. Ripristino da backup. Esportate le definitions con rabbitmqctl export_definitions, distruggete il cluster di staging, ricostruitelo e reimportatele. Superato se: exchange, code, binding, vhost, utenti, permessi e policy tornano tutti. Sappiate cosa non torna: i messaggi. Un backup delle definitions è topologia, non dati. La sopravvivenza dei messaggi dipende dalla replica e dal percorso cross-region, mai da un file di backup.
EsercitazioneCosa si misuraCriterio di superamento
Terminare un membroTempo di elezione, buchi di sequenza, flusso dei confirmSecondi, zero, ininterrotto
Terminare il nodo con più leaderGli stessi, più la distribuzione dei leader dopo il ribilanciamentoGli stessi, distribuzione all'incirca uniforme
Allarme discoStato dei publisher, throughput dei consumerBloccati, continuano a smaltire
Partizione di reteComportamento della minoranza, riconnessione dei clientPausa, riconnessione, ricomposizione automatica
Perdita di un'AZLa maggioranza continuaZero perdite
Failover regionaleRPO in messaggi, RTO in minutiEntro gli obiettivi concordati
FailbackNumero di duplicatiZero
Ripristino da backupDefinitions reimportateTopologia completa ripristinata

Cadenza. Eseguite il programma completo prima del go-live e di nuovo dopo ogni modifica della topologia: un nuovo nodo, uno spostamento di AZ, un upgrade di major version, una modifica alla gestione delle partizioni. Eseguite la terminazione di un singolo nodo ogni trimestre: costa poco e intercetta le derive nella riconnessione dei client che nessuno intendeva introdurre. Eseguite il failover regionale almeno una volta l'anno e ogni volta che cambia il responsabile del runbook, perché un runbook che nessuno dei presenti ha mai eseguito è un documento, non una capacità. La maggior parte dei guasti descritti in /blogs/top-10-rabbitmq-troubleshooting-issues-how-to-avoid-them/ sarebbe emersa prima in una di queste esercitazioni.

Una revisione di sizing e DR, esercitazioni incluse, è un normale intervento AceMQ; vedere /rabbitmq/.

How to test RabbitMQ disaster recovery: the drill we run before go-live

A cluster that has never lost a node in anger will surprise you the first time it does, usually at 2am. This is the programme we run with clients before a RabbitMQ cluster carries production traffic. It takes about a day and produces numbers rather than opinions.

Pre-conditions.

  • A staging cluster shaped like production: same node count, same AZ placement, same RabbitMQ version (we run this on everything from 3.8.x to 4.x), same queue types, policies, client libraries and connection settings. Quorum and classic queues fail differently, so if production has both, staging has both. See /blogs/rabbitmq-classic-vs-quorum-queues/ for why that matters here.
  • Synthetic publishers and consumers with sequence numbers. Each publisher stamps messages with a stream id and an increasing counter; each consumer records every sequence it sees. That makes loss (a gap) and duplication (a repeat) countable instead of arguable. Publishers use confirms, consumers use manual acks.
  • Dashboards up: queue depth, publish and deliver rates, memory and disk alarms, quorum leader count per node, connections and channels, and client-side confirm latency. If you cannot see it, you cannot pass it.
  • A named runbook owner, a shared channel, and a clock.

The drills, in order.

  1. Kill one quorum member. Stop RabbitMQ on a node that follows most queues. Watch leader election on the queues it led and watch confirm latency at the publishers. Pass: election completes in a few seconds, zero sequence gaps at the consumers, publisher confirms keep arriving throughout. Restart the node and confirm it rejoins and catches up.
  1. Kill the node holding the most leaders. Leaders pile onto whichever node was up first, so this is the harder version of drill 1. Kill it, watch the same signals, bring it back, then rebalance:
rabbitmq-queues rebalance quorum

Pass: no loss, confirms continue, and after the rebalance the leader count is roughly even across nodes.

  1. Fill a disk to the free-disk alarm. Write a large file on one node until disk_free_limit trips. Pass: publisher connections show as blocked in management, publishes stall rather than fail, consumers keep draining, and publishing resumes on its own once the file is deleted. If consumers stop too, a consumer is sharing a connection with a publisher; fix that before go-live.
  1. Partition the network between nodes. With cluster_partition_handling = pause_minority, block traffic between one node and the other two using iptables. Pass: the minority node pauses itself, quorum queues on the majority side keep serving, clients on the paused node see a connection error and reconnect to a surviving host from their address list, and the cluster heals without manual intervention when the rule is removed. Record what the clients logged; that line is what your on-call engineer will see.
  1. Lose an availability zone. Stop every node in one AZ at once. In a three-AZ layout a majority survives. Pass: identical to drill 1, zero loss and continuing confirms. If the load balancer takes more than a few seconds to drop the dead nodes, fix the health check now.
  1. Regional failover. Stop the publishers, note the highest sequence confirmed in region A, take region A down, and fail over to region B using whichever cross-region path you chose (see /blogs/rabbitmq-federation-vs-shovel-disaster-recovery/). RPO is the count of messages confirmed in A that never appear in B; read it straight from the sequence logs. RTO is wall-clock time from the outage to consumers running against B. Pass: both numbers sit inside the targets the business signed off on. Write them down; they are the honest answer to "what is our DR posture".
  1. Failback without duplicates. Bring region A back and return traffic to it. Pass: consumer sequence logs show no repeats. If they do, the consumers are not idempotent, and that is an application fix, not a broker fix.
  1. Restore from backup. Export definitions with rabbitmqctl export_definitions, destroy the staging cluster, rebuild it, re-import. Pass: exchanges, queues, bindings, vhosts, users, permissions and policies all come back. Know what does not: messages. A definitions backup is topology, not data. Message survival comes from replication and the cross-region path, never from a backup file.
DrillWhat you measurePass criterion
Kill one memberElection time, sequence gaps, confirm flowSeconds, zero, uninterrupted
Kill the leader-heavy nodeSame, plus leader spread after rebalanceSame, roughly even
Disk alarmPublisher state, consumer throughputBlocked, keeps draining
Network partitionMinority behaviour, client reconnectPauses, reconnects, self-heals
Lose an AZMajority continuesZero loss
Regional failoverRPO in messages, RTO in minutesInside agreed targets
FailbackDuplicate countZero
Restore from backupDefinitions re-importedFull topology back

Cadence. Run the full programme before go-live and again after any topology change: a new node, an AZ move, a major version upgrade, a change to partition handling. Run the single-node kill quarterly; it is cheap and catches client reconnect drift nobody meant to introduce. Run the regional failover at least yearly and whenever the runbook owner changes, because a runbook nobody present has executed is a document, not a capability. Most of the failures in /blogs/top-10-rabbitmq-troubleshooting-issues-how-to-avoid-them/ would have surfaced in one of these drills first.

A sizing and DR review, drills included, is a normal AceMQ engagement; see /rabbitmq/.

This post is one step in two longer sequences: the RabbitMQ disaster recovery guide takes HA and DR from the failure you are protecting against through to the failover test, and the clustering and sizing guide covers the node, queue-type and sizing decisions that come first.

Domande frequenti

Come si testa il disaster recovery di RabbitMQ?

Create un cluster di staging configurato come la produzione, avviate publisher e consumer sintetici che marcano ogni messaggio con un numero di sequenza e poi rompete le cose in ordine: un nodo, il nodo con più leader, un disco pieno, una partizione di rete, un'intera availability zone e infine la regione. Ogni esercitazione ha un criterio di superamento misurabile, e i log delle sequenze vi dicono esattamente quanti messaggi sono andati persi o duplicati. L'esercitazione regionale vi fornisce valori reali di RPO e RTO. Chiudete con un export e una reimportazione delle definitions, così il team avrà ripristinato almeno una volta un cluster partendo da zero.

Con quale frequenza va testato il failover di RabbitMQ?

Eseguite il programma completo di esercitazioni prima del go-live e dopo ogni modifica della topologia, compresi l'aggiunta di nodi, gli spostamenti di AZ, gli upgrade di major version e le modifiche alla gestione delle partizioni. Terminate un singolo nodo ogni trimestre: richiede un'ora e intercetta per tempo le regressioni nella riconnessione dei client. Eseguite il failover regionale almeno una volta l'anno e di nuovo ogni volta che cambia il responsabile del runbook, perché lo scopo dell'esercitazione è che chi è di reperibilità lo abbia fatto davvero. Se nessuno dell'attuale turno di reperibilità ha mai eseguito il failover, siete in ritardo. I clienti AceMQ con un contratto di supporto pianificano queste esercitazioni con noi, con obiettivi di risposta da 15 minuti, in base al piano, se dovesse mai verificarsi un failover reale; vedere /support/.

Degli esperti possono dimensionare il nostro cluster RabbitMQ?

Sì. Un intervento di sizing con AceMQ, partner MSP strategico esclusivo di Broadcom per RabbitMQ, parte dai vostri numeri reali: tassi di messaggi, dimensioni dei payload, numero di code, numero di consumer, ritenzione durante un'interruzione dei consumer e gli RPO e RTO di cui il business ha davvero bisogno. Il risultato è un numero di nodi e una disposizione sulle AZ, valori di CPU, memoria e disco per nodo con il relativo margine, impostazioni delle code quorum e delle policy, una raccomandazione sulla gestione delle partizioni, un design cross-region dove necessario e un piano di esercitazioni per dimostrare il risultato prima del go-live. Il sizing è una parte di una revisione più ampia di HA e DR; vedere /rabbitmq/.

Come si progetta un cluster RabbitMQ su più availability zone?

Collocate un nodo per AZ, con tre AZ come base standard, dato che la latenza tra AZ all'interno di una singola regione è tipicamente di uno o due millisecondi, ampiamente entro quanto il consenso Raft tollera. In un cluster a tre nodi, il posizionamento dei membri del quorum segue automaticamente quello dei nodi, assegnando a ogni coda una replica per zona. `pause_minority` vi protegge se una zona diventa irraggiungibile: il nodo isolato si mette in pausa mentre la maggioranza delle due zone superstiti continua a operare. Mettete un load balancer o una voce DNS davanti a tutti e tre i nodi e abilitate il recupero delle connessioni lato client, così la perdita di una zona non richiede una riconnessione manuale.

Come si testa l'alta disponibilità di RabbitMQ prima della produzione?

Eseguite un'esercitazione di guasto strutturata che copra terminazioni di nodi, drain controllati, partizioni a livello di zona, esaurimento di disco e memoria, rolling upgrade e una simulazione completa di interruzione di un'AZ, ciascuna con un'osservazione attesa messa per iscritto. L'obiettivo è dimostrare che il cluster si comporta come presuppone la vostra architettura, non solo confermare che prima o poi torna online. Fatelo prima del go-live e di nuovo dopo ogni modifica significativa di topologia o di versione, perché i presupposti non testati sull'HA tendono a emergere per la prima volta durante un incidente reale.

How do I test RabbitMQ high availability before production?

Run a structured failure drill covering node kills, graceful drains, zone-level partitions, disk and memory exhaustion, rolling upgrades, and a full simulated AZ outage, each with a written expected observation. The goal is proving the cluster behaves the way your architecture assumes it will, not just confirming it eventually comes back online. Do this before go-live and again after any significant topology or version change, since untested assumptions about HA tend to surface for the first time during a real incident.

Consulenza gratuita

Fate esaminare a un esperto il vostro cluster RabbitMQ

Che stiate risolvendo un incidente in produzione, pianificando una migrazione o cercando un secondo parere sulla vostra architettura, il nostro team è pronto. Nessun discorso commerciale, solo risposte.

Scriveteci