En esta página
La configuración en un párrafo
La configuración en un párrafo
Establezca task_acks_late = True y worker_prefetch_multiplier = 1, de modo que cada proceso worker retenga una sola tarea y la tarea de un worker caído vuelva a la cola. Mantenga el límite de tiempo duro de la tarea por debajo del timeout de consumidor de RabbitMQ, 30 minutos por defecto, y amplíe ese timeout por cola. Use colas de quórum con publisher confirms. Reintente los errores de límite de tasa con backoff exponencial y haga que cada tarea sea idempotente, porque algunas se ejecutarán dos veces. Use Redis o una base de datos como backend de resultados, enrute el trabajo de GPU y el dependiente de API a colas separadas, y configure alertas sobre mensajes sin confirmar (unacked) y número de consumidores.
Por qué el trabajo de LLM debe ir en una cola
Una cola saca del camino de la petición las llamadas lentas y caras al modelo, limita cuántas se ejecutan a la vez (el número de procesos worker pasa a ser su límite de concurrencia frente al proveedor) y aplica a cada tarea una política de reintentos. Celery aporta las definiciones de tareas, los reintentos, flujos como groups y chords, y el almacenamiento de resultados. RabbitMQ aporta la entrega: una tarea solo sale de la cola cuando el worker la confirma. La descripción de brokers de Celery señala que RabbitMQ como broker con Redis como backend de resultados es una combinación muy habitual, y esta guía parte de ese esquema. La mayoría de los problemas vienen de valores por defecto pensados para tareas cortas.
Confirme tarde y use prefetch de uno
Por defecto, Celery confirma un mensaje justo antes de ejecutar la tarea, así que un despliegue o un kill por falta de memoria a mitad de una llamada de diez minutos hace que se pierda la tarea. La guía de optimización de Celery indica el ajuste para tareas de larga duración: task_acks_late = True con worker_prefetch_multiplier = 1. Así el worker solo reserva tantas tareas como procesos tiene y confirma cada una cuando termina. Con el multiplicador por defecto de 4, el primer worker en arrancar puede acaparar un backlog de tareas de minutos mientras los demás están ociosos.
Hay dos detalles que pillan desprevenido a cualquiera. Una tarea con confirmación tardía que lanza una excepción o alcanza su límite de tiempo también se confirma por defecto (task_acks_on_failure_or_timeout), así que los fallos se gestionan con reintentos, no con reentrega. Y un proceso worker terminado por una señal también se confirma, salvo que task_reject_on_worker_lost esté activado, lo que según advierte Celery puede provocar bucles de mensajes.
Mantenga los límites de tiempo por debajo del timeout de consumidor
RabbitMQ abandona a un consumidor que retiene una entrega sin confirmar durante más tiempo que el timeout de confirmación (ack) de entrega, 30 minutos por defecto, y devuelve sus mensajes a la cola. Con confirmación tardía el reloj corre durante toda la llamada al LLM, así que un trabajo por lotes de 40 minutos se vuelve a encolar y arranca en otro sitio mientras la primera copia sigue ejecutándose. La documentación de Celery advierte del mismo error PRECONDITION_FAILED con countdowns largos.
Desde RabbitMQ 3.12, una cola puede tener su propio timeout mediante la clave de política consumer-timeout o el argumento de cola x-consumer-timeout, en milisegundos. RabbitMQ 4.3 aplica los timeouts de confirmación solo a las colas de quórum y permite que un consumidor fije el suyo con un argumento de consumidor x-consumer-timeout; una cola clásica en 4.3 no tiene timeout, así que un worker bloqueado conserva sus tareas. Use una política, porque volver a declarar una cola existente con argumentos distintos falla con PRECONDITION_FAILED, mientras que una política puede cambiarse en cualquier momento:
# One policy per queue applies, so set the timeout and dead-lettering together
rabbitmqctl set_policy llm-queues "^llm\." \
'{"consumer-timeout": 900000, "dead-letter-exchange": "llm.dlx"}' \
--apply-to quorum_queuesEl orden que debe respetar: límite blando, luego límite duro y luego timeout de consumidor, cada uno con margen holgado sobre el anterior.
Una configuración de partida
Los pasos 2 y 3 más colas de quórum, enrutamiento, reintentos y una comprobación de idempotencia, en un solo archivo. LLM_URL representa la API de modelo que utilice.
# celery_app.py: Celery 5.6 on RabbitMQ 4.3 quorum queues
import hashlib, os
import httpx, redis
from celery import Celery
from kombu import Queue
app = Celery("llm", broker=os.environ["BROKER_URL"], backend=os.environ["RESULT_URL"])
app.conf.update(
task_acks_late=True,
worker_prefetch_multiplier=1,
broker_transport_options={"confirm_publish": True}, # required for quorum queues
task_queues=[
Queue("llm.api", queue_arguments={"x-queue-type": "quorum"}),
Queue("llm.gpu", queue_arguments={"x-queue-type": "quorum"}),
],
task_default_queue="llm.api",
task_routes={"embeddings.*": {"queue": "llm.gpu"}},
task_soft_time_limit=600,
task_time_limit=660, # below the queue's consumer timeout
)
cache = redis.Redis.from_url(os.environ["CACHE_URL"], decode_responses=True)
class RetryableLLMError(Exception):
pass # a 429 or 5xx from the model endpoint
@app.task(
autoretry_for=(RetryableLLMError, httpx.TransportError),
retry_backoff=2, retry_backoff_max=300, retry_jitter=True, max_retries=8,
)
def summarize(doc_id: str, text: str, model: str) -> str:
key = f"summary:{doc_id}:{model}:{hashlib.sha256(text.encode()).hexdigest()[:16]}"
if (done := cache.get(key)) is not None:
return done # a redelivered task costs no tokens
resp = httpx.post(os.environ["LLM_URL"], json={"model": model, "input": text}, timeout=300)
if resp.status_code == 429 or resp.status_code >= 500:
raise RetryableLLMError(resp.status_code)
resp.raise_for_status() # other 4xx errors fail without retrying
summary = resp.json()["output"]
cache.set(key, summary, ex=7 * 86400)
return summaryUse colas de quórum (quorum queues) y sepa qué cambia
Celery soporta colas de quórum desde la 5.5: declare las colas con x-queue-type: quorum o establezca task_default_queue_type = "quorum", y active publisher confirms, que según la documentación de Celery son obligatorios. El contenido de una cola de quórum lo acuerda una mayoría de sus réplicas, así que perder un nodo de tres no supone perder ninguna tarea encolada.
Cambian tres comportamientos. Las colas de quórum no admiten QoS global, por lo que Celery lo desactiva al detectarlas; el prefetch pasa a ser estático y el autoescalado de workers deja de funcionar. Las tareas con countdown y ETA bloquearían entonces un hueco del worker, así que Celery cambia a la entrega diferida nativa y las programa dentro de RabbitMQ, lo que cubre cualquier reintento con backoff. Y desde RabbitMQ 4.0, una cola de quórum descarta o envía a dead-letter un mensaje tras 20 entregas fallidas por defecto, así que asigne a cada cola un destino dead-letter.
Reintente los límites de tasa con backoff
autoretry_for enumera las excepciones que se reintentan. retry_backoff=True espera 1, 2, 4, 8 segundos y así sucesivamente, y un número fija el factor. retry_backoff_max limita la espera a 600 segundos por defecto, retry_jitter (activado por defecto) aleatoriza cada retardo para que las tareas sometidas a throttling no se reintenten al unísono, y max_retries vale 3 por defecto, poco para un proveedor saturado. Reintente un 429 o un 5xx, nunca un prompt que supere la ventana de contexto, que fallará igual y costará tokens cada vez. El rate_limit de Celery se aplica por instancia de worker, no en todo el clúster; para un límite estricto del proveedor, dé a ese modelo su propia cola y dimensione sus workers.
Haga que cada tarea sea idempotente
La entrega es al menos una vez. Un timeout de consumidor, una conexión perdida mientras se ejecuta una tarea con confirmación tardía y task_reject_on_worker_lost provocan una segunda ejecución, a veces en paralelo con la primera. Celery prevé cancelar estas tareas por defecto al perder la conexión en la 6.0 (worker_cancel_long_running_tasks_on_connection_loss), y activarlo ya es la opción más segura para trabajos largos. Construya una clave a partir del ID del documento, el hash del contenido y la versión del modelo, compruebe si hay un resultado almacenado antes de llamar al modelo y escriba con un upsert. Los pipelines de embeddings obtienen casi todo esto gratis cuando cada vector tiene un ID determinista.
Procese embeddings por lotes con chords y elija el backend de resultados
Un group ejecuta tareas en paralelo, chunks divide una lista larga de argumentos en tareas de tamaño fijo y un chord ejecuta un callback cuando ha terminado todo un grupo, por ejemplo para marcar como completada la construcción de un índice. Los chords necesitan un backend de resultados, y sus tareas no deben ignorar los resultados. El backend rpc:// de Celery devuelve los resultados como mensajes AMQP: un resultado solo puede leerse una vez, únicamente por el cliente que envió la tarea, es transitorio salvo que se establezca result_persistent, y no admite chords. Use Redis o SQL para chords, dashboards de estado y ejecuciones de agentes que lean otros servicios. Envíe IDs de documento en los mensajes, no megabytes de texto.
Fije límites de tiempo y elija el pool en función de ellos
task_soft_time_limit lanza SoftTimeLimitExceeded para que la tarea pueda hacer limpieza; task_time_limit mata y sustituye el proceso worker. Configure en el cliente HTTP un timeout inferior al límite blando. Prefork, el pool por defecto, admite ambos límites. La documentación de Celery indica que los demás pools desactivan sin avisar los límites blandos, y gevent no aplica el límite duro a una tarea bloqueante, así que las tareas dependientes de API que se pasen a gevent o eventlet dependen de los timeouts del cliente.
Enrute por modelo, GPU y duración
La guía de optimización de Celery recomienda workers separados para tareas largas y cortas, porque los ajustes que convienen a unas perjudican a las otras. Un reparto habitual: inferencia local y modelos de embeddings en una cola que solo consumen los hosts con GPU, con la concurrencia ajustada a la memoria de la GPU; llamadas a APIs alojadas en una cola de alta concurrencia; posprocesado en la cola por defecto. task_routes asigna nombres de tareas, con comodines, a colas, y celery worker -Q selecciona las colas que consume un worker. Separe también por proveedor, para que un endpoint con throttling no frene las tareas del otro.
Monitorice el trabajo en curso, no solo la profundidad
Flower es el monitor que recomienda la documentación de Celery para estados de tareas y workers. El plugin de Prometheus de RabbitMQ expone métricas del broker en el puerto 15692. En las colas de LLM, vigile los mensajes sin confirmar (unacked) por cola (tareas en curso), el número de consumidores (una caída a cero con los workers en marcha suele indicar un timeout de consumidor), la tasa de reentrega (gasto duplicado) y las llegadas a la cola dead-letter (DLQ).
Ejecutar agentes de LangGraph o LangChain desde Celery
LangGraph y LangChain no documentan ninguna integración con Celery; el Agent Server alojado de LangChain ejecuta su propia cola de tareas sobre PostgreSQL y Redis. Los equipos que alojan un grafo por su cuenta suelen usar este patrón, que es práctica habitual y no una integración oficial: la tarea de Celery recibe un ID de hilo, el grafo usa un checkpointer persistente como PostgreSQL (uno en memoria se pierde al reiniciar), y la forma documentada por LangGraph de reanudar tras un error es invocarlo con None y el mismo ID de hilo:
@app.task(bind=True, acks_late=True, soft_time_limit=600, time_limit=660)
def run_agent(self, thread_id: str, user_input: dict) -> dict:
config = {"configurable": {"thread_id": thread_id}}
snapshot = graph.get_state(config) # graph compiled with a Postgres checkpointer
payload = None if snapshot.next else user_input # pending nodes: resume, do not restart
return graph.invoke(payload, config, durability="sync")Evite aquí el modo de durabilidad "exit": solo guarda el estado al terminar una ejecución y no puede recuperarse de una caída a mitad. Un nodo fallido se vuelve a ejecutar al reanudar, así que las llamadas a herramientas con efectos secundarios siguen necesitando claves de idempotencia.
Los errores más frecuentes
- Prefetch en 4 con tareas de minutos.
- Un límite de tiempo duro por encima del timeout de consumidor, por lo que las tareas largas se ejecutan dos veces.
- Colas clásicas en RabbitMQ 4.3, donde un worker bloqueado retiene sus tareas indefinidamente.
- Tareas con countdown en colas clásicas, retenidas sin confirmar en la memoria del worker hasta su vencimiento.
autoretry_for=(Exception,), pagando reintentos que nunca pueden tener éxito.- Sin destino dead-letter en las colas de quórum, de modo que un mensaje que falla 20 entregas se descarta.
Estos fallos se sitúan entre Celery y el broker. AceMQ ofrece soporte de RabbitMQ para cargas de trabajo de Celery, y RabbitMQ vs Kafka vs NATS para agentes de IA analiza la elección de broker.
Preguntas frecuentes
¿Qué valor de prefetch debe usar Celery para tareas de LLM?
worker_prefetch_multiplier = 1 con task_acks_late = True. Cada proceso reserva una tarea y la confirma al terminar, así que los trabajos largos se reparten de forma uniforme y la tarea de un worker caído vuelve a la cola.
¿Por qué mis tareas de Celery se ejecutan dos veces en RabbitMQ?
Normalmente porque una tarea con confirmación tardía superó el timeout de consumidor, 30 minutos por defecto, o el worker perdió la conexión a mitad de la tarea, y RabbitMQ la volvió a encolar. Mantenga el límite de tiempo duro por debajo del timeout de consumidor de la cola y haga que las tareas sean idempotentes.
¿Celery es compatible con las colas de quórum de RabbitMQ?
Sí, desde Celery 5.5, con confirm_publish activado. Celery desactiva el QoS global cuando detecta colas de quórum y usa la entrega diferida nativa para las tareas con countdown y ETA.
¿Se pueden ejecutar agentes de LangGraph con Celery?
Sí, como patrón y no como integración oficial: invoque el grafo dentro de una tarea con un ID de hilo y un checkpointer persistente, y reanude una ejecución reentregada invocándolo con None y el mismo ID de hilo.