Broadcast (pub/sub) vs Coordinated distribution (streams)

Imagina que tienes tres worker services procesando requests.

Con pub/sub si suscribes a los 3 workers al mismo channel, cada worker recibe cada mensaje, lo que crea duplica el procesamiento.

Con Streams consumer groups cada request va a un solo worker, distribuyendo la carga de trabajo automáticamente.

Choosing the right approach

IMPORTANTE

Usa pub/sub cuando:

  • Todos los subscribers necesiten procesar el mismo mensaje (cache invalidation, config updates, notifications)
  • No necesites garantias de entrega o acknowledgments
  • Cada subscriber ejecuta acciones diferentes basados en el mismo evento

Usa Stream consumer groups cuando:

  • Cada mensaje deba ser procesado por exactamente un worker (task queues, job processing)
  • Si que necesites garantias de entrega o acknowledgments
  • Necesites escalar el procesamiento añadiendo más consumidores
  • Necesites poder manejar fallos y reasignar tareas

/IMPORTANTE

Pub/Sub: Broadcast to all subscribers

Cuando subscribes multiples servicios al mismo pub/sub channel, cada subscriber recibe cada mensaje. Redis pub/sub está diseñado para hacer broadcasting de eventos a múltiples consumidores de manera simultánea.

How broadcast distribution works

Redis delivers each published message to all active subscribers of that channel.

Si tienes 5 consumidores subscritos al channel ai:models:updated y publicas un mensaje en ese canal, los 5 servicios reciben el mismo mensaje de manera simultánea

# Publisher service
redis_client.publish('ai:cache:invalidate', 'embeddings-v2')

# All of these subscribers receive the message:
# - Subscriber 1 (API server instance 1)
# - Subscriber 2 (API server instance 2)
# - Subscriber 3 (Background worker)
# - Subscriber 4 (Analytics service)

Casos de uso

IMPORTANTE

Este diseño es intencional y es útil para escenarios específicos.

Usa pub/sub cuando necesites que todos tus servicios reaccionen al mismo evento de manera simultánea

  • Cache invalidation across microservices: publicamos en un channel para asegurar que cada instancia y cada microservicio recibe la señal de invalidar caché
# Model update service
def update_model(model_id, new_version):
    save_model_to_storage(model_id, new_version)
    # Notify all API instances to clear cache
    redis_client.publish('ai:models:cache:invalidate',
                        f'{model_id}:{new_version}')

# Each API instance subscribes and clears its own cache
pubsub = redis_client.pubsub()
pubsub.subscribe('ai:models:cache:invalidate')
for message in pubsub.listen():
    if message['type'] == 'message':
        clear_local_model_cache(message['data'])
  • Configuration updates for distributed services: Cuando al cambiar un param o una feature flag queremos que todos los servicios actualicen su conf
  • Real-time monitoring and metrics collection: podemos conectar multiples monitoring systems al mismo canal para que todos reciban los mismos datos sin interferir entre ellos
  • Event notification: Cuando un user completa una interacción y necesitamos avisar a múltiples servicios de manera simultánea

/IMPORTANTE

Cuando causa problemas

IMPORTANTE

No uses pub/sub cuando necesites:

  • Process tasks that should only run once: si tienes 3 consumers subscritos a un channel y publicas un mensaje, los 3 consumers procesan la misma request.
  • Load balancing across workers: pub/sub no distribuye mensajes - los duplica. No sirve para escalar horizontalmente.
  • Queue-like work distribution: pub/sub no garantiza que los mensajes han sido consumidos y no da acknowledgments. pub/sub es fire-and-forget. Los mensajes puedes ser procesados múltiples veces o ninguna - no hay manera de saberlo

/IMPORTANTE

Streams: Coordinated work distribution

Usar Streams cuando necesitas coordinar multiples subscribers para evitar duplica processing y distribuir carga de trabajo. Redis Streams consumer groups resuelven este problema. A diferencia de pub/sub, los consumer groups aseguran que cada mensaje vaya a un único subscriber.

How consumer groups distribute work

Los consumer groups particionan el Stream entre los group members. Cuando múltiples workers leen del mismo consumer group, Redis reparte automáticamente y asigna diferentes mensajes a diferentes workers. Cada mensaje se entrega a un único consumer en el grupo.
Esto ocurre automáticamente, no tienes que balancear nada.

# Setup: Create a consumer group once
redis_client.xgroup_create('ai:inference:queue', 'workers', '0', mkstream=True)

# Worker 1 gets messages 1, 3, 5
# Worker 2 gets messages 2, 4, 6
# Worker 3 gets messages 7, 8, 9

# All workers use the same group name but different consumer names
messages = redis_client.xreadgroup(
    groupname='workers',  # Same group
    consumername=f'worker-{worker_id}',  # Unique per worker
    streams={'ai:inference:queue': '>'},
    count=10
)

Setting up consumer groups in your worker services

Lo normal es crear el consumer group una única vez durante la inicialización de la App, y a partir de entonces que cada worker instance lea del mismo group.

cada worker obtiene tasks diferentes de manera automática, lo que permite un escalado horizontal

# Application startup code (runs once per deployment, not per instance)
def setup_worker_infrastructure():
    try:
        redis_client.xgroup_create(
            'ai:document:analysis',
            'analysis-workers',
            '0',  # Start from beginning
            mkstream=True  # Create stream if doesn't exist
        )
    except redis.ResponseError as e:
        # Group already exists, which is fine
        if 'BUSYGROUP' not in str(e):
            raise

# Worker processing loop (runs on each worker instance)
def process_documents():
    worker_id = f"{os.getenv('HOSTNAME')}-{os.getpid()}"

    while True:
        messages = redis_client.xreadgroup(
            groupname='analysis-workers',
            consumername=worker_id,
            streams={'ai:document:analysis': '>'},
            count=5,
            block=5000
        )

        for stream, tasks in messages:
            for task_id, task_data in tasks:
                analyze_document(task_data)
                redis_client.xack('ai:document:analysis',
                                 'analysis-workers',
                                 task_id)

Understand the > symbol and consumer positions

Al leer del consumer group el símbolo > le comunica a Redis que te dé nuevos mensajes que no hayan sido entregados todavía a ningún consumidor.

esto es lo que permite work distribution. Cuando worker-1 lee con > obtienes mensajes que worker-2 no recibe. Redis hace track de que mensajes se entregan a que consumidores

# Read only NEW messages not yet delivered to any consumer
redis_client.xreadgroup('workers', 'worker-1',
                       {'ai:queue': '>'}, count=10)

También podemos especificar un ID para leer de una posición específica, lo cual es útil para manejar pending messages.

# Read messages pending for this specific consumer
redis_client.xreadgroup('workers', 'worker-1',
                       {'ai:queue': '0'}, count=10)

Scaling workers dynamically

Una de las ventajas principales de los consumer groups es que permiten escalar horizontalmente sin cambios de código. Solo con escalar los micros es suficiente ya que automaticamente se distribuye el trabajo

# This same code runs on 2 workers or 20 workers
# Redis automatically distributes work based on how many workers are reading

def worker_main():
    setup_worker_infrastructure()  # Idempotent group creation

    worker_id = generate_unique_worker_id()

    while True:
        tasks = fetch_next_tasks('workers', worker_id)
        process_tasks(tasks)
        acknowledge_completion(tasks)

Handling failures and task reassignment

Los consumer groups tienen built-in mechanism para manejar fallos de los consumidores. Cuando un consumidor (worker) se crashea mientras procesa una task, esa task se queda en la lista de pendientes y se puede reasignar a otro healthy worker.

Detecting and claiming stuck tasks

Usa XPENDING para encontrar tasks que llevan en progreso demasiado tiempo y usa XCLAIM para reasignarlas.

# In a separate monitoring/health-check service or worker
def reassign_abandoned_tasks():
    # Check for tasks pending more than 5 minutes
    pending = redis_client.xpending_range(
        'ai:inference:queue',
        'workers',
        '-', '+',
        count=100
    )

    current_time = int(time.time() * 1000)

    for task in pending:
        task_id = task['message_id']
        idle_time = current_time - task['time_since_delivered']

        # Task processes for more than 5 minutes, likely stuck
        if idle_time > 300000:
            # Claim it for reprocessing
            redis_client.xclaim(
                'ai:inference:queue',
                'workers',
                f'recovery-worker-{os.getpid()}',
                300000,
                message_ids=(task_id,)
            )

            # Now process it
            reprocess_stuck_task(task_id)

Implement automatic retry in workers

Cada worker puede hacer check de sus propias tasks en startup, permitiendo automatic recovery después de los restarts.

def worker_startup_recovery():
    worker_id = get_worker_id()

    # Check if this worker holds any pending tasks from before crash
    pending = redis_client.xpending_range(
        'ai:inference:queue',
        'workers',
        '-', '+',
        count=100
    )

    # Filter for tasks assigned to this consumer
    my_pending = [p for p in pending if p['consumer'] == worker_id]

    # Retry each pending task
    for task in my_pending:
        try:
            retry_task(task['message_id'])
            redis_client.xack('ai:inference:queue', 'workers',
                            task['message_id'])
        except Exception as e:
            log_error(f"Retry failed for {task['message_id']}: {e}")