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
XADDpara añadir tasksXREADGROUPpara hacer pull de tasks en tu workerXACKpara 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