BlogKafka

Kafka rebalance: che cosa lo scatena e come fermare le storm

Scott Sternloff

Di Scott Sternloff, Enterprise Architect senior

LinkedIn · Aggiornato il · 15 min di lettura

Kafka rebalance: che cosa lo scatena e come fermare le storm
On this page

Un rebalance Kafka è il processo con cui le partizioni vengono ridistribuite tra i consumer di un gruppo. Si attiva ogni volta che la membership cambia (un consumer entra, esce o viene dichiarato morto) oppure quando cambia il numero di partizioni di un topic sottoscritto. Un gruppo sano fa rebalance di rado e per poco tempo. Un gruppo che fa rebalance ogni pochi minuti ha un problema di configurazione, e le pause che ne derivano vengono di solito scambiate per un problema del broker o di throughput.

Il rebalancing di Kafka non è di per sé un guasto. È il modo in cui Apache Kafka distribuisce le partizioni ai consumer e mantiene il lavoro equamente ripartito mentre un deployment scala. Capire come funziona è importante perché i problemi nascono quando si attiva molto più spesso di quanto il workload giustifichi.

Vale la pena capire il meccanismo, perché quasi tutte le correzioni sono modifiche alla configurazione dei consumer e non interventi sul cluster.

Che cosa scatena un rebalance Kafka?

Quattro eventi, e solo i primi due sono intenzionali.

Un nuovo consumer entra nel gruppo. Uno scale-up, o un pod che si avvia dopo un deployment. È previsto: quando un nuovo consumer entra nel gruppo, il coordinator ripartisce le partizioni tra i consumer già in esecuzione.

Un consumer esce in modo pulito. Uno shutdown ordinato che invia una richiesta di uscita. Anche questo è previsto. Ogni volta che un consumer entra o esce, segue una ridistribuzione.

Un consumer viene dichiarato morto. È qui che nascono i problemi. Il group coordinator avvia un rebalance nel momento in cui stabilisce che un consumer non c'è più, cosa che accade quando scade uno dei due timer:

  • session.timeout.ms (default 45 secondi). Il consumer invia heartbeat da un thread in background ogni heartbeat.interval.ms (default 3 secondi). Se ne salta abbastanza, il coordinator lo espelle. Questo intercetta i crash reali, le partizioni di rete e le pause di GC lunghe.
  • max.poll.interval.ms (default 5 minuti). L'intervallo tra chiamate successive a poll() sul thread principale. Gli heartbeat continuano a partire dal thread in background, quindi il consumer sembra vivo, ma se l'applicazione impiega troppo a elaborare un batch, il coordinator lo espelle comunque.

È questo secondo caso a causare la maggior parte dei rebalance inspiegabili in produzione. Il consumer non è andato in crash. Sta solo elaborando lentamente, e Kafka non è in grado di distinguere un consumer lento da uno bloccato.

Cambia il numero di partizioni. Quando si aggiungono partizioni a un topic Kafka, segue una riassegnazione. Lo stesso accade quando cambiano le sottoscrizioni.

Gli ultimi due sono eventi di rebalance di cui fareste volentieri a meno. Un rebalance Kafka costa lo stesso qualunque sia la causa, e sono i rebalance non necessari a trasformare un consumer group funzionante in uno bloccato.

Che cosa succede davvero durante un rebalance Kafka?

Tutti i consumer del gruppo smettono di consumare, devono rientrare nel gruppo e attendere prima di poter riprendere. Il group leader, che è uno dei consumer e non un broker Kafka, invia una richiesta al group coordinator, calcola come assegnare le partizioni e distribuisce il risultato. Le partizioni vengono prima revocate e poi riassegnate, e il consumer a cui finiscono determinate partizioni può cambiare a ogni round.

La proprietà fondamentale è che si tratta di una barriera di sincronizzazione: tutti i consumer di un consumer group si muovono insieme, e il membro più lento detta il ritmo. Se un consumer impiega trenta secondi a rientrare, l'intero gruppo aspetta trenta secondi. Durante il rebalancing non viene elaborato alcun messaggio, quindi si forma un backlog e il lag sale anche se ogni broker del cluster Kafka è in salute.

Ecco perché rebalance e lag vengono confusi così spesso. Se state inseguendo un lag in crescita anziché i rebalance che lo causano, diagnosticare il consumer lag di Kafka copre il lato dei sintomi.

Rebalancing eager e rebalancing cooperativo

Il protocollo di rebalance di Kafka ha due generazioni, e quella in uso cambia enormemente il costo di ogni rebalance.

Il rebalancing eager è il comportamento originale, stop-the-world. Ogni consumer revoca tutte le partizioni assegnate prima che venga calcolata la nuova assegnazione. Anche se la riassegnazione sposta solo due partizioni su duecento, si ferma tutto. La pausa cresce con la dimensione del gruppo e con il tempo di rientro, non con l'entità effettiva del cambiamento.

Il rebalancing incrementale revoca solo le partizioni che si spostano davvero. I consumer continuano a elaborare tutto ciò che mantengono. Il protocollo di rebalancing cooperativo si svolge in due round più leggeri anziché in uno pesante, quindi l'impatto del rebalancing cresce con la dimensione del cambiamento e non con il numero di membri. Questo approccio incrementale cooperativo è quello che la maggior parte degli ambienti dovrebbe usare.

È disponibile da Kafka 2.4 e non sempre è il default nei client Kafka più vecchi. La static membership è arrivata poco prima, con Kafka 2.3. Il passaggio richiede una sola riga:

partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor

⚠️ Non limitatevi a impostarlo e fare il deploy. Il passaggio da eager a cooperativo richiede un rolling upgrade in due fasi: prima un deploy con entrambe le strategie elencate, così il gruppo può accordarsi, poi la rimozione di quella eager in un secondo passaggio. Cambiarla in un solo passaggio su un gruppo in esecuzione fa fallire il rebalance.

Le release più recenti vanno ancora oltre. Il nuovo protocollo di rebalance dei consumer sposta il calcolo dell'assegnazione sul broker ed elimina del tutto la barriera di sincronizzazione globale, quindi i consumer non si fermano più tutti insieme. Questo nuovo protocollo è diventato generalmente disponibile con Apache Kafka 4.0. Se siete su una release recente vale la pena valutarlo, ma la maggior parte degli ambienti di produzione non ci è ancora arrivata, e lo sticky assignor offre già oggi gran parte del beneficio.

Confronto tra il rebalancing eager, che ferma tutti i consumer, e il rebalancing incrementale cooperativo, che sposta solo le partizioni interessate

Strategie di assegnazione delle partizioni

AssignorComportamentoCosto del rebalance
RangeAssignorIntervalli contigui per topicEager; può distribuire in modo non uniforme su più topic
RoundRobinAssignorDistribuzione uniforme su tutte le partizioniEager; riassegna tutto
StickyAssignorDistribuzione uniforme, conserva l'assegnazione precedente dove possibileEager, ma sposta meno partizioni
CooperativeStickyAssignorSticky, e revoca solo ciò che si spostaIncrementale: quello da scegliere

La stickiness conta al di là della pausa in sé. Quando un consumer mantiene le stesse partizioni dei topic attraverso un rebalance, conserva lo stato locale già caldo: cache, aggregazioni in corso, state store di Kafka Streams. Rimescolare inutilmente le assegnazioni butta via tutto questo, e il costo del recupero supera spesso quello del rebalance stesso.

Se usate Spring Kafka o un altro framework, l'impostazione passa per la stessa proprietà sottostante: il framework non cambia le strategie disponibili.

Tabella delle strategie di assegnazione delle partizioni Kafka che confronta gli assignor range, round robin, sticky e cooperative sticky

La rebalance storm di Kafka: perché non si risolve da sola

I problemi di rebalancing per cui veniamo chiamati seguono quasi sempre lo stesso schema:

  1. L'elaborazione rallenta: un'API a valle si degrada, oppure un batch diventa più grande.
  2. Un consumer supera max.poll.interval.ms e viene espulso.
  3. Il gruppo fa rebalance. Tutti si fermano.
  4. Durante la pausa il backlog cresce.
  5. Alla ripresa, ogni consumer preleva un batch completo da un backlog più grande e impiega più tempo a elaborarlo.
  6. Un altro consumer supera l'intervallo. Si torna al punto 3.

Il throughput di elaborazione crolla mentre il cluster in sé resta in salute.

Non si risolve mai da sola, perché ogni nuovo rebalance Kafka rende più probabile il successivo: ed è proprio per questo che i team iniziano a indagare sul cluster anziché su come configurano il consumer.

Spezzare il ciclo significa di solito fare in modo che i batch terminino entro l'intervallo:

  • Ridurre max.poll.records. È la singola modifica più efficace. Meno record per poll significa meno tempo tra un poll e l'altro. Per iniziare, dimezzatelo.
  • Alzare max.poll.interval.ms in modo che superi davvero il tempo di elaborazione nel caso peggiore, non quello tipico. Misurate il p99, non stimatelo.
  • Spostare il lavoro lento fuori dal thread di polling. Se l'elaborazione comporta una chiamata di rete di durata imprevedibile, il ciclo di poll è il posto sbagliato per farla.
  • Non aumentare session.timeout.ms per risolvere il problema. È un timer diverso e non aiuta: ritarda soltanto il rilevamento dei consumer davvero morti.
Diagramma del ciclo di retroazione: l'elaborazione lenta supera max.poll.interval.ms, scatena un rebalance, il backlog cresce e seguono altri rebalance

Static membership

Dove i consumer si riavviano di routine, come nei rolling deployment su Kubernetes, la static membership impedisce che il riavvio scateni un rebalance.

Assegnate a ogni consumer un group.instance.id stabile. Se il riavvio avviene entro la finestra di timeout, il coordinator riconosce il membro che rientra e gli restituisce le partizioni precedenti senza ridistribuire nulla:

group.instance.id=consumer-3
session.timeout.ms=45000

Il compromesso va detto chiaramente: un membro davvero morto non viene sostituito finché la sua sessione non scade, quindi le sue partizioni restano non consumate per quella finestra. Prima di abilitarla, valutate se un rebalance al riavvio sia necessario. Impostate il timeout in modo che superi con margine il tempo del rolling restart, e non di più.

Esiste anche un'impostazione lato broker utile per l'avvio. group.initial.rebalance.delay.ms (default 3 secondi) fa attendere brevemente il coordinator prima del primo rebalance, così i consumer che partono insieme formano un unico gruppo anziché fare rebalance ripetutamente a ogni nuovo arrivo. È un dettaglio che elimina molto rumore dai deployment su Kubernetes.

Che cosa monitorare

Tenete d'occhio tre elementi, e osservateli insieme:

  • Frequenza dei rebalance. È il segnale stesso. Tutto ciò che va oltre l'occasionale merita un'indagine, e un consumer bloccato in un ciclo di rebalance compare qui per primo.
  • Durata dei rebalance. Una durata crescente indica che i consumer rientrano lentamente, spesso per la stessa elaborazione lenta che ha scatenato il rebalance.
  • Consumer lag durante i rebalance. Conferma se le pause vi costano davvero throughput o sono abbastanza brevi da non contare.

Un consumer group che esegue un rebalance Kafka qualche volta al giorno in corrispondenza dei deployment va bene. Uno che fa rebalance ogni pochi minuti vi sta dicendo che max.poll.interval.ms viene superato, e nessuna ottimizzazione del cluster lo cambierà.

Rebalance storm o pause dei consumer inspiegabili? Dipendono quasi sempre dalla configurazione

dei consumer e non dal cluster, ed è per questo che le metriche dei broker sembrano pulite mentre il throughput

crolla. AceMQ esegue assessment Kafka strutturati che le individuano:

Se tutta questa conoscenza è nelle mani di una sola persona, il rischio riguarda il personale prima ancora che Kafka: quanto costa davvero supportare Kafka in proprio.

Rebalancing cooperativo in pratica: verificarlo, migrare e che cosa fanno Streams e Connect

Range, round-robin e lo sticky assignor originale usano tutti il protocollo eager. A ogni cambiamento della membership il coordinator porta il gruppo in PreparingRebalance, ogni consumer revoca tutte le partizioni che possiede, tutti rientrano e il leader distribuisce una nuova assegnazione. L'intero gruppo resta fermo per tutto il giro.

Kafka 2.4 ha introdotto il rebalancing cooperativo per i consumer. Con il protocollo incrementale cooperativo un rebalance si svolge in due fasi. Nella prima, il leader calcola la nuova assegnazione e ogni consumer revoca solo le partizioni che gli vengono tolte, continuando a fare poll e commit su tutte le altre. Segue immediatamente un secondo rebalance, in cui le partizioni liberate passano ai nuovi proprietari. L'unico assignor lato client che usa questo protocollo è CooperativeStickyAssignor.

La maggior parte dei gruppi per cui veniamo chiamati usa eager senza saperlo. Primo, la configurazione del consumer: partition.assignment.strategy è una lista, e nei client recenti la lista di default contiene sia range sia cooperative-sticky. Il coordinator seleziona una strategia supportata da tutti i membri, quindi il default finisce su range. Secondo, descrivete il gruppo e verificate che cosa ha effettivamente selezionato il coordinator:

kafka-consumer-groups.sh --bootstrap-server broker:9092 \
  --describe --group orders-svc --state

La colonna ASSIGNMENT-STRATEGY riporta range o cooperative-sticky. Range significa che ogni riavvio è ancora stop-the-world.

La migrazione di un gruppo attivo richiede due rolling restart, e l'ordine conta. Nel primo, impostate partition.assignment.strategy sull'assignor eager attuale seguito da CooperativeStickyAssignor, lasciando quello eager per primo così resta selezionato mentre istanze vecchie e nuove convivono. Nel secondo, rimuovete l'assignor eager. Farlo in un solo passaggio fallisce perché un membro che entra a metà riavvio non trova alcuna strategia in comune con gli altri e il rebalance va in errore.

Le applicazioni Kafka Streams usano già il protocollo cooperativo tramite il proprio assignor, quindi lì non serve configurare nulla. I worker di Kafka Connect bilanciano connector e task con un protocollo incrementale cooperativo separato, controllato da connect.protocol, e il default lo abilita quando tutti i worker lo supportano.

Il compromesso è modesto. Un rebalance cooperativo dura complessivamente un po' di più, perché si tratta di due rebalance anziché uno, e le partizioni che si spostano restano non assegnate per quella finestra. In cambio, le partizioni che non si spostano non si fermano mai. Il numero di partizioni scelto limita quanti consumer possono condividere il lavoro, come spieghiamo nella nostra guida alla strategia di partizionamento.

Risolvere i loop di rebalance: errore REBALANCE_IN_PROGRESS, rejoin continui e "preparing rebalance"

"The group is rebalancing, so a rejoin is needed" è il messaggio associato al codice di errore REBALANCE_IN_PROGRESS. Il coordinator lo restituisce a un consumer la cui richiesta riporta una generation non più corrente, il più delle volte un heartbeat, una sync o un commit degli offset inviati dopo che il gruppo è passato in PreparingRebalance. Di per sé non è un guasto: il client rientra e il gruppo si assesta. Diventa un problema quando si ripete ogni pochi secondi, il gruppo non raggiunge mai lo stato Stable e il lag sale. Il broker coordinator registra una riga corrispondente "Preparing to rebalance group ... (reason: ...)", e quel campo reason è il modo più rapido per capire quale dei casi seguenti si sta verificando.

1. max.poll.interval.ms superato. Il consumer è vivo ma ha impiegato troppo tempo tra un poll e l'altro, quindi è stato escluso. Conferma: i log del consumer riportano "consumer poll timeout has expired" e la reason del broker cita un membro in uscita. Correzione: abbassare max.poll.records finché l'elaborazione del batch nel caso peggiore rientra nell'intervallo, poi alzare max.poll.interval.ms solo se il p99 continua a non rientrare.

2. session.timeout.ms troppo basso per le pause di GC o per la rete. Il thread degli heartbeat si blocca o i suoi pacchetti arrivano in ritardo e il membro viene espulso. Conferma: la reason del broker indica "heartbeat expiration", i log di GC mostrano pause vicine al timeout e non c'è alcun messaggio di poll timeout. Correzione: alzare session.timeout.ms entro il group.max.session.timeout.ms del broker e risolvere la causa della pausa. I producer nella stessa JVM mostrano sintomi correlati, trattati in cause e soluzioni dei timeout del producer.

  • 3. Consumer che scalano in un ciclo continuo. Un autoscaler aggiunge repliche quando il lag sale, il lag scende, le rimuove, il lag risale. Ogni evento di scaling è un rebalance. Conferma: descrivendo il gruppo con --members si vede un numero di membri che cambia di minuto in minuto in corrispondenza degli eventi di deployment. Correzione: aggiungere una finestra di stabilizzazione allo scale-down, limitare le repliche al numero di partizioni e scalare su un segnale più regolare del lag grezzo. Come misurare correttamente il lag è spiegato nella nostra guida al consumer lag.
  • 4. Static membership non in uso. Senza group.instance.id, un rolling deploy di dieci pod equivale a dieci uscite e dieci ingressi. Con l'id, un pod che rientra entro il session timeout riprende la sua vecchia assegnazione senza rebalance. Conferma: --members --verbose mostra member id generati che cambiano a ogni riavvio. Correzione: impostare un instance id stabile per ogni pod.
  • 5. Cambio di coordinator o di broker. La partizione di __consumer_offsets che ospita il gruppo è passata a un altro broker, il gruppo è stato ricaricato e ogni membro ha dovuto ritrovarlo e rientrare. Conferma: i log del broker mostrano "Loading group metadata" su un nuovo broker e la tempistica coincide con un riavvio o un'elezione del leader. Correzione: nulla lato client. Un rebalance per ogni riavvio di broker è previsto; spostamenti ripetuti del coordinator indicano che è il cluster stesso a essere instabile.

Le tre proprietà che chiudono la maggior parte di questi loop:

max.poll.records=100
group.instance.id=orders-svc-${POD_ORDINAL}
partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor

Applichiamo queste correzioni per i clienti enterprise nell'ambito del supporto Kafka 24/7 con risposta P1 in 15 minuti, e progettiamo i gruppi in questo modo fin dall'inizio nei progetti di consulenza Kafka.

Questo è il quarto di dieci passaggi della guida alle operations di Kafka, che affronta le decisioni operative nell'ordine in cui si presentano in un ambiente di produzione.

Domande frequenti

Che cosa scatena il rebalance di un consumer group Kafka?

Un consumer che entra nel gruppo, che esce in modo pulito o che viene dichiarato morto dal group coordinator, per heartbeat mancati oltre session.timeout.ms oppure perché ha superato max.poll.interval.ms tra un poll e l'altro. Anche una variazione del numero di partizioni di un topic sottoscritto ne scatena uno.

Perché il rebalancing causa latenza e backlog?

Perché è una barriera di sincronizzazione. I consumer smettono di consumare mentre il gruppo si ricompone e attende una nuova assegnazione, quindi il membro più lento determina la pausa per tutti. In quella finestra non viene elaborato nulla e il lag si accumula.

Che cos'è il rebalancing cooperativo in Kafka?

Un protocollo incrementale che revoca solo le partizioni che cambiano effettivamente proprietario, lasciando che i consumer continuino a elaborare tutto il resto. Il rebalancing eager revoca ogni partizione a ogni consumer, per quanto poco si stia spostando.

Come fermare i rebalance Kafka frequenti?

Capire quale timeout sta scadendo. Se i batch richiedono troppo tempo, abbassare max.poll.records e alzare max.poll.interval.ms oltre il caso peggiore. Se la causa sono i riavvii, usare la static membership. Poi passare al cooperative sticky assignor per rendere meno costosi i rebalance rimanenti.

Che cos'è la static group membership?

Un group.instance.id stabile per ogni consumer, che consente al coordinator di riconoscere un membro che si riavvia e di restituirgli le partizioni precedenti senza rebalance, a condizione che rientri entro il session timeout.

Quale strategia di assegnazione delle partizioni conviene usare?

CooperativeStickyAssignor per la maggior parte dei workload: riduce al minimo sia lo spostamento delle partizioni sia l'interruzione dovuta al rebalance. La migrazione va fatta con due rolling deployment, non cambiando l'impostazione in un solo passaggio.

Aggiungere partizioni scatena un rebalance Kafka?

Sì. Aumentare il numero di partizioni di un topic sottoscritto obbliga il gruppo a riassegnarle, quindi le modifiche alle partizioni vanno trattate come un'operazione pianificata, non come un'attività di routine.

Un rebalance Kafka è la stessa cosa della riassegnazione delle partizioni tra broker?

No, e il vocabolario comune crea una confusione reale. Il rebalance di un consumer group ridistribuisce le partizioni tra i consumer. Spostare le repliche delle partizioni tra i broker è la partition reassignment, un'operazione di cluster separata, con strumenti diversi e rischi diversi.

Perché il mio consumer group Kafka continua a fare rebalance?

Nella nostra esperienza le cause, in ordine, sono: l'elaborazione di un batch di poll richiede più di max.poll.interval.ms; session.timeout.ms è troppo breve per le pause di GC della JVM o per la rete; un autoscaler aggiunge e rimuove consumer in un ciclo continuo; i consumer si riavviano senza un group.instance.id, quindi ogni deploy equivale a un'uscita più un ingresso nel gruppo; oppure il group coordinator è passato a un altro broker. Il campo reason nella riga di log "Preparing to rebalance group" del broker coordinator indica quale. Descrivere il gruppo con --state per vedere se raggiunge mai lo stato Stable.

Come evitare che un rebalance Kafka causi downtime?

Tre impostazioni eliminano gran parte del problema. Passare il gruppo a CooperativeStickyAssignor, con la migrazione in due rolling restart, così si fermano solo le partizioni che si spostano. Assegnare a ogni consumer un group.instance.id stabile, così i riavvii entro il session timeout non scatenano alcun rebalance. Limitare max.poll.records, così un batch lento non può far espellere un consumer sano. Poi eliminare il churn alla fonte: stabilizzare l'autoscaling e mantenere il numero di repliche pari o inferiore al numero di partizioni. Un gruppo ben configurato dovrebbe fare rebalance solo quando se ne modifica deliberatamente la dimensione.

Fonti

Scott Sternloff

Autore

Scott SternloffEnterprise Architect senior

Enterprise Architect senior di AceMQ. Firma qui gli articoli tecnici: architettura, clustering e migrazioni di RabbitMQ, Kafka e Redis.

Talk to an engineer

Need a hand with Kafka?

Senior engineers who run it in production. Get a quote or a free consultation, no sales pitch.

Guide, confronti e ricerche

Approfondite Kafka

Consulenza gratuita

Fate esaminare a un esperto il vostro cluster Kafka

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