Task queues with Redis Streams

Redis Streams es una manera de implementar task queues y event processing en backend services. Se usa cuando necesitas encolar requests, coordinar pipes multi-proceso o gestionar long-running ops.
Los Streams te dan la durabilidad y la coordinacion que pub/sub no da.

Redis Streams

Los Streams son append-only task queues donde añades items y los consumers hacen pull de los items de la cola.

Puedes usar

  • XADD para añadir tasks
  • XREADGROUP para hacer pull de tasks en tu worker
  • XACK para marcar tasks como completas

IMPORTANTE

La diferencia de listas con los Streams es que estos trackean que consumidor ha procesado que task, y permiten retries automáticos si tu servicio se crashea.

/IMPORTANTE

What devs get from Streams

  • task survive crashes: cuando hay un reinicio, no pierdes las tasks no procesadas. Estas siguen en el Stream.
  • automatic retry handling: si tu codigo se crashea mientras procesa una task, esa task se pone como disponible para reintentarla automaticamente
  • built-in work distribution: cuando escalas a múltiples workers, Stream consumer groups automaticamente distribuyen tasks a lo largo de instancias sin duplicar trabajo
  • processing history: puedes hacer queries para ver que ha pasado en la pipe, hacer un replay para debuggear o que servicios nuevos se pongan al dia con datos historicos
  • simple async patterns: Los handlers pueden añadir tasks a los streams y volver inmediatamente mientras background workers procesan tasks a su ritmo

Stream task structure

Cada task que añades a un Stream obtiene su ID auto-generado y puede contener cualquier campo que necesites. Piensa que es como añadir un JSON object a una cola.

este ID se asegura que las tasks se procesan en orden

# Adding an AI processing task
stream_id = redis.xadd('ai:inference:requests', {
    'user_id': '12345',
    'model': 'gpt-4',
    'prompt': 'Summarize this document...',
    'priority': 'high'
})
# Returns ID like: '1699980000000-0'

Scaling with multiple workers

Cuando haces deploy de multiples instancias, los consumer groups se aseguran de que cada task solo vaya a un único worker. Creas un grupo una única vez y entonces cada worker instance lee del mismo grupo.

ahora puedes escalar horizontalmente - añade más worker instances para compartir la carga

# In your worker deployment/startup code
try:
    redis.xgroup_create('ai:inference:requests', 'workers', id='0', mkstream=True)
except redis.ResponseError:
    pass  # Group already exists

# In your worker's processing loop (runs on each instance)
while True:
    tasks = redis.xreadgroup('workers', 'worker-instance-1',
                             {'ai:inference:requests': '>'},
                             count=10, block=5000)
    for task_id, task_data in tasks:
        process_ai_task(task_data)
        redis.xack('ai:inference:requests', 'workers', task_id)

Cuando usar Streams

Redis Streams son ideales para escenarios donde queremos reliability y la persistencia de las tasks es importante.

  • API endpoints que encolan requests: En vez de bloquear la API mientras espera una request lo podemos en una cola y devolvemos el ID automáticamente. Los background workers lo procesan y hacen update de los resultados
  • Multi-step processing pipelines: Cuando procesar requiere multiples pasos todos en orden (extraer - analizar - resumir). Si cualquier paso falla, no pierdes progreso
  • Worker services que escalan horizontalmente: los streams distribuyen automaticamente el trabajo
  • Long running operations que necesitan retry
  • System requiring processing history: cuando necesitamos un historial para ver que ha pasado y cuando

Code Examples

Adding AI tasks to a queue

Usa XADD para añadir a un Stream. Cada task tiene un ID unico.

# Your API handler code
def queue_inference_request(user_prompt, model_name):
    task_id = redis.xadd('ai:inference:queue', {
        'prompt': user_prompt,
        'model': model_name,
        'user_id': current_user.id,
        'requested_at': datetime.now().isoformat()
    })
    return task_id

Processing tasks in your worker service

Worker services usan XREADGROUP para hacer fetch de tasks desde un Stream y XACK para marcarlas como completadas.

# Worker service processing loop
def process_ai_tasks():
    # One-time setup: create consumer group
    try:
        redis.xgroup_create('ai:inference:queue', 'workers', id='0', mkstream=True)
    except:
        pass  # Already exists

    # Main processing loop
    while True:
        # Get up to 5 tasks, wait 5 seconds if queue empty
        messages = redis.xreadgroup(
            groupname='workers',
            consumername=f'worker-{os.getpid()}',
            streams={'ai:inference:queue': '>'},
            count=5,
            block=5000
        )

        for stream, tasks in messages:
            for task_id, task_data in tasks:
                try:
                    # Do your AI processing
                    result = run_inference(task_data['prompt'], task_data['model'])
                    save_result(task_id, result)

                    # Mark task complete
                    redis.xack('ai:inference:queue', 'workers', task_id)
                except Exception as e:
                    # Task stays in pending, will retry
                    log_error(f"Task {task_id} failed: {e}")

Handling failed tasks

Usa XPENDING para encontrawr tasks que han estado procesando demasiado tiempo y XCLAIM para reasignarlas. Esto se encarga de casos donde los workers se crashean a medio del proceso.

# Check for tasks that have been pending too long (stuck/crashed)
def retry_stuck_tasks():
    pending = redis.xpending('ai:inference:queue', 'workers', '-', '+', 10)

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

        # If task pending more than 5 minutes, reassign it
        if idle_time > 300000:  # milliseconds
            redis.xclaim('ai:inference:queue', 'workers',
                        f'worker-{os.getpid()}', 0, [task_id])

Monitoring queue health

Usa XINFO para obtener metricas de Stream queues. Estos datos son utiles para dashboards y alertas.

# Get Stream metrics for your application dashboard
def get_queue_stats():
    info = redis_client.xinfo_stream('ai:documents:queue')
    groups = redis_client.xinfo_groups('ai:documents:queue')

    return {
        'total_tasks': info['length'],
        'pending_tasks': groups[0]['pending'],
        'consumers': groups[0]['consumers']
    }

Trade-offs a considerar

  • Memory management es TU responsabilidad: A diferencia de pub/sub donde los mensajes desaparecen despues de ser entregamos, Stream tasks se mantienen en memoria hasta que tu los borrar. Para high-volume queues necesitas encargarte de limpiar
# Trim to most recent 10,000 tasks when adding new ones
redis.xadd('ai:inference:queue', task_data, maxlen=10000, approximate=True)

# Or trim periodically in your worker after acknowledging tasks
if task_count % 100 == 0:  # Every 100 tasks
    redis_client.xtrim('ai:documents:queue', maxlen=10000, approximate=True)
  • Slighty higher latency than pub/sub: Streams añaden unos ms de latencia por la persistencia y el ack tracking. Si necesitas esos ms de latencia, usa pub/sub
  • Más complejidad: Necesitas gestionar consumer groups, ack, y pending task checks. Pub/sub es más simple pero a cambio obtienes esa erliability
  • Tasks no auto-expiran: Las tasks completadas se quedan en el Steram hasta que se borran