En esta página
Un rebalanceo en Kafka es el proceso de redistribuir las particiones entre los consumidores de un grupo. Se dispara cada vez que cambian los miembros del grupo (un consumidor se une, sale o es declarado muerto) o cuando cambial número de particiones de un topic suscrito. Un grupo sano se rebalancea de vez en cuando y por poco tiempo. Un grupo que se rebalancea cada pocos minutos tiene un problema de configuración, y las pausas resultantes suelen confundirse con un problema del broker o de throughput.
El rebalanceo de Kafka no es un fallo en sí mismo. Es la forma en que Apache Kafka distribuye las particiones entre los consumidores y mantiene el trabajo repartido de manera uniforme a medida que el despliegue escala. Entender cómo funciona importa porque los problemas aparecen cuando se dispara con mucha más frecuencia de la que justifica la carga de trabajo.
Vale la pena entender el mecanismo, porque casi todas las soluciones son un cambio en la configuración del consumidor y no algo que se haga en el clúster.
¿Qué provoca un rebalanceo en Kafka?
Cuatro cosas, y solo las dos primeras son intencionadas.
Un nuevo consumidor se une al grupo. Un escalado hacia arriba, o un pod que arranca después de un despliegue. Es lo esperado: cuando un nuevo consumidor se une al grupo, el coordinador reparte las particiones entre los consumidores que ya están en ejecución.
Un consumidor sale de forma ordenada. Un apagado controlado que envía una solicitud de salida. También es lo esperado. Cada vez que un consumidor se une o sale, viene una redistribución.
Un consumidor es declarado muerto. Aquí es donde están los problemas. El coordinador del grupo inicia un rebalanceo en el momento en que decide que un consumidor ya no está, lo que ocurre cuando vence alguno de dos relojes:
session.timeout.ms(45 segundos por defecto). El consumidor envía heartbeats desde un hilo en segundo plano cadaheartbeat.interval.ms(3 segundos por defecto). Si pierde suficientes heartbeats, el coordinador lo expulsa. Esto detecta caídas reales, particiones de red y pausas largas de GC.max.poll.interval.ms(5 minutos por defecto). El intervalo entre llamadas sucesivas apoll()en el hilo principal. Los heartbeats siguen fluyendo desde el hilo en segundo plano, así que el consumidor parece vivo; pero si la aplicación tarda demasiado en procesar un lote, el coordinador lo expulsa de todos modos.
Ese segundo reloj causa la mayoría de los rebalanceos inexplicables en producción. El consumidor no se ha caído. Simplemente está procesando despacio, y Kafka no puede distinguir un consumidor lento de uno atascado.
Cambial número de particiones. Cuando se añaden particiones a un topic de Kafka, viene una reasignación. Los cambios de suscripción tienen el mismo efecto.
Los dos últimos son eventos de rebalanceo que preferiría no tener. Disparar un rebalanceo de Kafka cuesta lo mismo sin importar la causa, y la actividad de rebalanceo innecesaria es lo que convierte un grupo de consumidores que funciona en uno paralizado.
¿Qué ocurre realmente durante un rebalanceo de Kafka?
Todos los consumidores del grupo dejan de consumir, deben volver a unirse al grupo y esperar antes de poder reanudar. El líder del grupo (uno de los consumidores, no un broker de Kafka) envía una solicitud al coordinador del grupo, calcula cómo se asignan las particiones y distribuye el resultado. Primero se revocan las particiones y luego se vuelven a repartir, y qué consumidor termina con cada partición puede cambiar en cada ronda.
La propiedad importante es que se trata de una barrera de sincronización: todos los consumidores de un grupo avanzan juntos y el miembro más lento marca el ritmo. Si un consumidor tarda treinta segundos en volver a unirse, todo el grupo espera treinta segundos. Durante el proceso de rebalanceo no se procesa ningún mensaje, así que se acumula backlog y el lag sube aunque todos los brokers del clúster de Kafka estén sanos.
Por eso los rebalanceos y el lag se confunden con tanta frecuencia. Si está persiguiendo un lag creciente y no los rebalanceos que lo causan, cómo diagnosticar el lag de consumidores en Kafka cubre el lado de los síntomas.
Rebalanceo eager frente a rebalanceo cooperativo
El protocolo de rebalanceo de Kafka tiene dos generaciones, y cuál esté usando cambia enormemente el coste de cada rebalanceo.
El rebalanceo eager es el comportamiento original, de tipo stop-the-world. Cada consumidor revoca todas sus particiones asignadas antes de que se calcule la nueva asignación. Aunque la reasignación solo mueva dos particiones de doscientas, todo se detiene. La pausa crece con el tamaño del grupo y el tiempo de reincorporación, no con lo que realmente cambió.
El rebalanceo incremental revoca solo las particiones que realmente se mueven. Los consumidores siguen procesando todo lo que conservan. El protocolo de rebalanceo cooperativo se ejecuta en dos rondas más ligeras en lugar de una pesada, de modo que el impacto del rebalanceo crece con el tamaño del cambio y no con el número de miembros. Este enfoque cooperativo incremental es el que deberían usar la mayoría de los entornos.
Está disponible desde Kafka 2.4 y no siempre es el valor predeterminado en un cliente de Kafka antiguo. La pertenencia estática llegó un poco antes, en Kafka 2.3. El cambio es una sola línea:
partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor⚠️ No se limite a configurarlo y desplegar. Pasar de eager a cooperativo requiere una actualización rolling en dos fases: primero despliegue con ambas estrategias listadas para que el grupo pueda ponerse de acuerdo y luego quite la eager en una segunda pasada. Cambiarlo en un solo paso en un grupo en ejecución hará fallar el rebalanceo.
Las versiones más recientes van todavía más lejos. El nuevo protocolo de rebalanceo de consumidores traslada el cálculo de la asignación al broker y elimina por completo la barrera de sincronización global, así que los consumidores ya no se detienen todos a la vez. Este nuevo protocolo alcanzó disponibilidad general en Apache Kafka 4.0. Si usa una versión reciente vale la pena evaluarlo, pero la mayoría de los entornos de producción todavía no han llegado ahí, y el assignor sticky ofrece hoy la mayor parte del beneficio.
Estrategias de asignación de particiones
| Assignor | Comportamiento | Coste del rebalanceo |
|---|---|---|
RangeAssignor | Rangos contiguos por topic | Eager; puede distribuir de forma desigual entre varios topics |
RoundRobinAssignor | Reparto uniforme entre todas las particiones | Eager; reasigna todo |
StickyAssignor | Reparto uniforme, conserva la asignación anterior cuando es posible | Eager, pero mueve menos particiones |
CooperativeStickyAssignor | Sticky, y revoca solo lo que se mueve | Incremental: el que conviene usar |
La afinidad (stickiness) importa más allá de la pausa en sí. Cuando un consumidor conserva las mismas particiones del topic a través de un rebalanceo, conserva su estado local ya cargado: cachés, agregaciones en curso, state stores de Kafka Streams. Reordenar sin necesidad desecha todo eso, y el coste de recuperación suele superar al del propio rebalanceo.
Si usa Spring Kafka u otro framework que lo envuelva, esto se configura mediante la misma propiedad subyacente: el framework no cambia qué estrategias tiene disponibles.
La tormenta de rebalanceos en Kafka: por qué nunca se recupera
Los problemas de rebalanceo por los que nos contactan casi siempre siguen el mismo patrón:
- El procesamiento se vuelve más lento: una API posterior se degrada o un lote crece.
- Un consumidor supera
max.poll.interval.msy es expulsado. - El grupo se rebalancea. Todos se detienen.
- El backlog crece durante la pausa.
- Al reanudar, cada consumidor recoge un lote completo frente a un backlog mayor y tarda más en procesarlo.
- Otro consumidor supera el intervalo. Volver al paso 3.
El throughput de procesamiento de datos se desploma mientras el clúster en sí sigue sano.
Nunca se recupera por sí solo, porque cada nuevo rebalanceo de Kafka hace más probable el siguiente; precisamente por eso los equipos empiezan a investigar el clúster en lugar de cómo configuran el consumidor.
Romper el ciclo suele ser cuestión de conseguir que los lotes terminen dentro del intervalo:
- Reduzca
max.poll.records. Es el cambio individual más eficaz. Menos registros por poll significa menos tiempo entre polls. Empiece por reducirlo a la mitad. - Suba
max.poll.interval.mspara que supere de verdad el tiempo de procesamiento del peor caso, no el típico. Mida el p99; no lo estime. - Saque el trabajo lento del hilo de polling. Si el procesamiento implica una llamada de red de duración impredecible, el ciclo de poll no es el lugar adecuado.
- No aumente
session.timeout.mspara resolver esto. Es otro reloj y no ayudará: solo retrasa la detección de consumidores realmente muertos.
Pertenencia estática
Donde los consumidores se reinician con frecuencia (el caso más obvio son los despliegues rolling en Kubernetes), esto evita que el reinicio dispare un rebalanceo.
Asigne a cada consumidor un group.instance.id estable. Si se reinicia dentro de la ventana del timeout, el coordinador reconoce al miembro que vuelve y le devuelve sus particiones anteriores sin redistribuir nada:
group.instance.id=consumer-3
session.timeout.ms=45000La contrapartida es clara: un miembro realmente muerto no se reemplaza hasta que vence su sesión, así que sus particiones quedan sin consumir durante esa ventana. Decida si el rebalanceo es necesario al reiniciar antes de activarlo. Configure el timeout para que supere con holgura el tiempo de su reinicio rolling, y nada más.
También hay un ajuste del lado del broker que conviene conocer para el arranque. group.initial.rebalance.delay.ms (3 segundos por defecto) hace que el coordinador espere un momento antes del primer rebalanceo, para que los consumidores que arrancan juntos formen un solo grupo en lugar de rebalancearse repetidamente a medida que llega cada uno. Es un detalle pequeño que elimina mucho ruido en los despliegues de Kubernetes.
Qué monitorizar
Vigile tres cosas, y hágalo a la vez:
- Tasa de rebalanceos. Es la señal en sí. Cualquier valor por encima de lo ocasional merece investigarse, y un consumidor atrapado en un ciclo de rebalanceo aparece aquí primero.
- Duración del rebalanceo. Una duración creciente significa que los consumidores tardan en volver a unirse, a menudo por el mismo procesamiento lento que disparó el rebalanceo.
- Lag de los consumidores durante los rebalanceos. Confirma si las pausas realmente le cuestan throughput o si son lo bastante cortas como para no importar.
Un grupo de consumidores que ejecuta un rebalanceo de Kafka unas pocas veces al día en torno a los despliegues está bien. Uno que se rebalancea cada pocos minutos le está diciendo que se está superando max.poll.interval.ms, y ningún ajuste del clúster cambiará eso.
¿Ve tormentas de rebalanceo o pausas inexplicables de los consumidores? Casi siempre están en la configuración
del consumidor y no en el clúster, por eso las métricas del broker parecen limpias mientras el throughput
se desploma. AceMQ realiza evaluaciones estructuradas de Kafka que las encuentran:
Si una sola persona concentra todo este conocimiento, eso es un riesgo de personal más que un riesgo de Kafka: lo que realmente cuesta dar soporte a Kafka por cuenta propia.
Rebalanceo cooperativo en la práctica: cómo comprobarlo, cómo migrar y qué hacen Streams y Connect
Range, round-robin y el assignor sticky original usan el protocolo eager. Ante cualquier cambio de miembros, el coordinador pasa el grupo a PreparingRebalance, cada consumidor revoca todas las particiones que tiene, todos se vuelven a unir y el líder reparte una asignación nueva. Todo el grupo se detiene durante ese ciclo completo.
Kafka 2.4 introdujo el rebalanceo cooperativo para consumidores. Con el protocolo cooperativo incremental, un rebalanceo se ejecuta en dos fases. En la primera, el líder calcula la nueva asignación y cada consumidor revoca solo las particiones que deja, mientras sigue haciendo poll y confirmando offsets en todo lo demás. Inmediatamente después viene un segundo rebalanceo, en el que las particiones liberadas pasan a sus nuevos propietarios. El único assignor del lado del cliente que usa este protocolo es CooperativeStickyAssignor.
La mayoría de los grupos por los que nos llaman usan eager sin saberlo. Primero, la configuración del consumidor: partition.assignment.strategy es una lista, y en los clientes recientes la lista predeterminada contiene tanto range como cooperative-sticky. El coordinador elige una estrategia que admitan todos los miembros, así que el valor predeterminado termina en range. Segundo, describa el grupo y compruebe qué ha elegido realmente el coordinador:
kafka-consumer-groups.sh --bootstrap-server broker:9092 \
--describe --group orders-svc --stateLa columna ASSIGNMENT-STRATEGY muestra range o cooperative-sticky. Range significa que cada reinicio sigue siendo stop-the-world.
Migrar un grupo en producción requiere dos reinicios rolling, y el orden importa. En el primero, configure partition.assignment.strategy con el assignor eager actual seguido de CooperativeStickyAssignor, dejando el eager en primer lugar para que siga siendo el elegido mientras conviven instancias antiguas y nuevas. En el segundo, quite el assignor eager. Hacerlo en un solo paso falla porque un miembro que se une a mitad del reinicio no encuentra ninguna estrategia en común con los demás y el rebalanceo termina en error.
Las aplicaciones de Kafka Streams ya usan el protocolo cooperativo mediante su propio assignor, así que ahí no hay nada que configurar. Los workers de Kafka Connect equilibran conectores y tareas con un protocolo cooperativo incremental independiente, controlado por connect.protocol, y el valor predeterminado lo activa cuando todos los workers lo admiten.
La contrapartida es pequeña. Un rebalanceo cooperativo tarda un poco más de principio a fin porque son dos rebalanceos en lugar de uno, y las particiones que se mueven quedan sin asignar durante esa ventana. A cambio, las particiones que no se mueven nunca se detienen. El número de particiones que elija limita cuántos consumidores pueden compartir el trabajo, tema que tratamos en nuestra guía de estrategia de particiones.
Cómo resolver los ciclos de rebalanceo: el error REBALANCE_IN_PROGRESS y los bucles de PreparingRebalance
"The group is rebalancing, so a rejoin is needed" es el mensaje asociado al código de error REBALANCE_IN_PROGRESS. El coordinador lo devuelve a un consumidor cuya solicitud lleva una generación que ya no es la actual; lo más frecuente es un heartbeat, un sync o una confirmación de offset enviados después de que el grupo pasara a PreparingRebalance. Por sí solo no es un fallo: el cliente se vuelve a unir y el grupo se estabiliza. Se convierte en un problema cuando se repite cada pocos segundos, el grupo nunca llega a Stable y el lag sube. El broker coordinador registra una línea correspondiente "Preparing to rebalance group ... (reason: ...)", y ese campo reason es la forma más rápida de saber cuál de los siguientes casos está ocurriendo.
1. Se supera max.poll.interval.ms. El consumidor está vivo, pero ha tardado demasiado entre polls, así que lo han expulsado. Cómo confirmarlo: los logs del consumidor dicen "consumer poll timeout has expired" y el reason del broker menciona la salida de un miembro. Solución: baje max.poll.records hasta que el procesamiento del lote en el peor caso quepa en el intervalo, y suba max.poll.interval.ms solo si el p99 sigue sin caber.
2. session.timeout.ms demasiado bajo para las pausas de GC o la red. El hilo de heartbeat se frena o sus paquetes se retrasan, y el miembro es expulsado. Cómo confirmarlo: el reason del broker dice "heartbeat expiration", los logs de GC muestran pausas cercanas al timeout y no aparece el mensaje de poll timeout. Solución: suba session.timeout.ms dentro del límite de group.max.session.timeout.ms del broker y corrija la pausa. Los productores en la misma JVM muestran síntomas relacionados, que se tratan en causas y soluciones del timeout del productor.
- 3. Consumidores que escalan en un ciclo. Un autoescalador añade réplicas cuando sube el lag, el lag baja, las quita y el lag vuelve a subir. Cada evento de escalado es un rebalanceo. Cómo confirmarlo: al describir el grupo con
--membersse ve un número de miembros que cambia minuto a minuto y coincide con los eventos de despliegue. Solución: añada una ventana de estabilización para el escalado hacia abajo, limite las réplicas al número de particiones y escale con una señal más suave que el lag en bruto. Cómo medir bien el lag se explica en nuestra guía de lag de consumidores. - 4. No se usa pertenencia estática. Sin
group.instance.id, un despliegue rolling de diez pods equivale a diez salidas y diez entradas. Con él, un pod que vuelve dentro del session timeout retoma su asignación anterior sin rebalanceo. Cómo confirmarlo:--members --verbosemuestra IDs de miembro generados que cambian en cada reinicio. Solución: configure un ID de instancia estable por pod. - 5. Cambio de coordinador o de broker. La partición de
__consumer_offsetsque aloja al grupo ha cambiado de broker, el grupo se ha vuelto a cargar y todos los miembros han tenido que redescubrirlo y volver a unirse. Cómo confirmarlo: los logs del broker muestran "Loading group metadata" en un broker nuevo y el momento coincide con un reinicio o una elección de líder. Solución: nada del lado del cliente. Un rebalanceo por cada reinicio de broker es lo esperado; los cambios repetidos de coordinador indican que el propio clúster es inestable.
Las tres propiedades que terminan con la mayoría de estos ciclos:
max.poll.records=100
group.instance.id=orders-svc-${POD_ORDINAL}
partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignorAplicamos estas soluciones para clientes empresariales con el soporte de Kafka 24/7, con objetivos de respuesta desde 15 minutos, según el plan, y diseñamos los grupos de esta forma desde el principio en los proyectos de consultoría de Kafka.
Este es el cuarto de los diez pasos de la guía de operaciones de Kafka, que aborda las decisiones operativas en el orden en que surgen en un entorno de producción.
Preguntas frecuentes
¿Qué provoca un rebalanceo del grupo de consumidores en Kafka?
Que un consumidor se una, salga de forma ordenada o sea declarado muerto por el coordinador del grupo, ya sea por heartbeats perdidos más allá de session.timeout.ms o por superar max.poll.interval.ms entre polls. Un cambio en el número de particiones de un topic suscrito también provoca uno.
¿Por qué el rebalanceo causa latencia y acumulación de mensajes?
Porque es una barrera de sincronización. Los consumidores dejan de consumir mientras el grupo se vuelve a unir y espera una nueva asignación, así que el miembro más lento define la pausa para todos. Durante esa ventana no se procesa nada y el lag se acumula.
¿Qué es el rebalanceo cooperativo en Kafka?
Un protocolo incremental que revoca solo las particiones que realmente cambian de propietario, y permite que los consumidores sigan procesando todo lo demás. El rebalanceo eager revoca todas las particiones de todos los consumidores, por poco que se mueva.
¿Cómo detengo los rebalanceos frecuentes en Kafka?
Averigüe qué reloj está venciendo. Si los lotes tardan demasiado, baje max.poll.records y suba max.poll.interval.ms por encima del peor caso. Si la causa son los reinicios, use pertenencia estática. Luego pase al assignor cooperative sticky para que los rebalanceos restantes cuesten menos.
¿Qué es la pertenencia estática de grupo?
Un group.instance.id estable por consumidor que permite al coordinador reconocer a un miembro que se reinicia y devolverle sus particiones anteriores sin rebalanceo, siempre que vuelva dentro del session timeout.
¿Qué estrategia de asignación de particiones debo usar?
CooperativeStickyAssignor para la mayoría de las cargas de trabajo: minimiza tanto el movimiento de particiones como la interrupción del rebalanceo. Migre a esta estrategia en dos despliegues rolling en lugar de cambiar el ajuste en un solo paso.
¿Añadir particiones provoca un rebalanceo en Kafka?
Sí. Aumentar el número de particiones de un topic suscrito hace que el grupo se reasigne, así que trate los cambios de particiones como una operación programada y no como algo rutinario.
¿Un rebalanceo de Kafka es lo mismo que reasignar particiones entre brokers?
No, y el vocabulario compartido genera confusión real. Un rebalanceo del grupo de consumidores redistribuye particiones entre consumidores. Mover réplicas de particiones entre brokers es una reasignación de particiones: una operación de clúster distinta, con otras herramientas y otros riesgos.
¿Por qué mi grupo de consumidores de Kafka se rebalancea una y otra vez?
Según nuestra experiencia, las causas, en orden, son: procesar un lote de poll tarda más que max.poll.interval.ms; session.timeout.ms es demasiado corto para las pausas de GC de la JVM o para la red; un autoescalador añade y quita consumidores en un ciclo; los consumidores se reinician sin group.instance.id, así que cada despliegue es una salida más una entrada; o el coordinador del grupo ha cambiado de broker. El campo reason de la línea de log "Preparing to rebalance group" del broker coordinador le indica cuál es. Describa el grupo con --state para ver si alguna vez llega a Stable.
¿Cómo evito que un rebalanceo de Kafka cause tiempo de inactividad?
Tres ajustes eliminan la mayor parte del problema. Cambie el grupo a CooperativeStickyAssignor para que solo se pausen las particiones que se mueven, con la migración en dos reinicios. Asigne a cada consumidor un group.instance.id estable para que los reinicios dentro del session timeout no provoquen ningún rebalanceo. Limite max.poll.records para que un lote lento no haga expulsar a un consumidor sano. Después, ataque la rotación en su origen: estabilice el autoescalado y mantenga el número de réplicas igual o inferior al número de particiones. Un grupo bien configurado solo debería rebalancearse cuando usted cambia su tamaño de forma deliberada.
Fuentes
Guías, comparativas e investigación
Profundice en Kafka
Guías
2Comparativas
9- NATS vs Kafka en 2026: comparativa de Core NATS, JetStream y Kafka
- Mosquitto vs Kafka: ¿broker MQTT o log de eventos?
- Kafka vs Kinesis: comparativa
- Mejores proveedores de Kafka gestionado en 2026, más allá de los hiperescaladores
- Comparativa de opciones de Kafka BYOC (en su propia nube)
- Alternativas a Confluent y competidores tras la adquisición por IBM

