Guide · RabbitMQ

Celery et RabbitMQ pour les files de tâches LLM

De nombreuses équipes IA Python utilisent déjà Celery pour les traitements en arrière-plan, et RabbitMQ figure parmi les brokers que la documentation de Celery qualifie de stables, avec prise en charge du monitoring et du contrôle à distance. Les tâches LLM mettent ce duo à rude épreuve, bien plus que les tâches web ordinaires : un seul appel peut durer plusieurs minutes, les fournisseurs appliquent du throttling sous charge et chaque nouvelle tentative consomme des tokens. Ce guide passe en revue les paramètres qui comptent, dans l'ordre où ils provoquent des incidents, d'après la documentation de Celery 5.6 et de RabbitMQ 4.3 vérifiée le 10 octobre 2026.

Tyler Eastridge

Par Tyler Eastridge, Directeur des opérations

LinkedIn · Mis à jour le · Lecture : 10 min · 13 sections

Sur cette page

La configuration en un paragraphe

La configuration en un paragraphe

Définissez task_acks_late = True et worker_prefetch_multiplier = 1 : chaque processus worker ne détient alors qu'une tâche, et la tâche d'un worker planté retourne dans la file d'attente. Maintenez la limite de temps stricte des tâches en dessous du timeout consommateur de RabbitMQ, 30 minutes par défaut, et relevez ce timeout file d'attente par file d'attente. Utilisez des quorum queues avec les publisher confirms. Relancez les erreurs de limitation de débit avec un backoff exponentiel, et rendez chaque tâche idempotente, car certaines tâches s'exécuteront deux fois. Utilisez Redis ou une base de données comme backend de résultats, routez le travail GPU et le travail lié aux API vers des files d'attente distinctes, et configurez des alertes sur les messages non acquittés et le nombre de consommateurs.

Pourquoi les tâches LLM ont leur place dans une file d'attente

Une file d'attente sort les appels de modèle lents et coûteux du chemin des requêtes, plafonne le nombre d'exécutions simultanées (le nombre de processus worker devient votre limite de concurrence vis-à-vis du fournisseur) et dote chaque tâche d'une politique de nouvelles tentatives. Celery fournit les définitions de tâches, les nouvelles tentatives, les workflows tels que les groups et les chords, ainsi que le stockage des résultats. RabbitMQ assure la livraison : une tâche ne quitte la file d'attente que lorsque le worker l'acquitte. La présentation des brokers de Celery indique que RabbitMQ comme broker avec Redis comme backend de résultats est une combinaison très courante, et ce guide part de cette architecture. La plupart des problèmes viennent de valeurs par défaut pensées pour des tâches courtes.

Acquitter tardivement et fixer le prefetch à 1

Par défaut, Celery acquitte un message juste avant d'exécuter la tâche : un déploiement ou un arrêt pour manque de mémoire au milieu d'un appel de dix minutes fait donc perdre la tâche. Le guide d'optimisation de Celery donne le réglage adapté aux tâches longues : task_acks_late = True avec worker_prefetch_multiplier = 1. Le worker ne réserve alors que autant de tâches qu'il a de processus et acquitte chacune une fois terminée. Avec le multiplicateur par défaut de 4, le premier worker démarré peut accaparer un backlog de tâches d'une minute pendant que les autres restent inactifs.

Deux détails piègent souvent. Une tâche à acquittement tardif qui lève une exception ou atteint sa limite de temps est tout de même acquittée par défaut (task_acks_on_failure_or_timeout) : les échecs sont donc gérés par les nouvelles tentatives, et non par une nouvelle livraison. Et un processus worker tué par un signal est lui aussi acquitté, sauf si task_reject_on_worker_lost est activé, ce qui, prévient Celery, peut provoquer des boucles de messages.

Maintenir les limites de temps sous le timeout consommateur

RabbitMQ abandonne un consommateur qui garde une livraison non acquittée au-delà du timeout d'acquittement de livraison, 30 minutes par défaut, et remet ses messages dans la file d'attente. Avec l'acquittement tardif, le compteur tourne pendant tout l'appel LLM : une tâche batch de 40 minutes est donc remise en file et relancée ailleurs alors que la première copie tourne encore. La documentation de Celery signale la même erreur PRECONDITION_FAILED pour les longs countdowns.

Depuis RabbitMQ 3.12, une file d'attente peut porter son propre timeout via la clé de politique consumer-timeout ou l'argument de file d'attente x-consumer-timeout, en millisecondes. RabbitMQ 4.3 n'applique les timeouts d'acquittement qu'aux quorum queues et permet à un consommateur de définir le sien avec un argument consommateur x-consumer-timeout ; une file classique en 4.3 n'a pas de timeout, si bien qu'un worker bloqué conserve ses tâches. Utilisez une politique : redéclarer une file d'attente existante avec des arguments différents échoue avec PRECONDITION_FAILED, alors qu'une politique peut être modifiée à tout moment :

# 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_queues

L'ordre à respecter : limite souple, puis limite stricte, puis timeout consommateur, chacun nettement au-dessus du précédent.

Une configuration de départ

Les étapes 2 et 3, plus les quorum queues, le routage, les nouvelles tentatives et un contrôle d'idempotence, dans un seul fichier. LLM_URL désigne l'API de modèle que vous appelez, quelle qu'elle soit.

# 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 summary

Utiliser les quorum queues, en sachant ce qui change

Celery prend en charge les quorum queues depuis la version 5.5 : déclarez les files d'attente avec x-queue-type: quorum ou définissez task_default_queue_type = "quorum", et activez les publisher confirms, que la documentation de Celery présente comme obligatoires. Le contenu d'une quorum queue est validé par une majorité de ses réplicas : perdre un nœud sur trois ne fait perdre aucune tâche en file.

Trois comportements changent. Les quorum queues ne prennent pas en charge le QoS global : Celery le désactive lorsqu'il les détecte, le prefetch devient statique et l'autoscaling des workers ne fonctionne plus. Les tâches countdown et ETA bloqueraient alors un slot de worker : Celery passe donc à la livraison différée native et les planifie dans RabbitMQ, ce qui couvre toutes les nouvelles tentatives avec backoff. Enfin, depuis RabbitMQ 4.0, une quorum queue supprime un message ou l'envoie en dead-letter après 20 livraisons échouées par défaut : prévoyez donc une cible dead-letter pour chaque file d'attente.

Relancer les erreurs de limitation avec backoff

autoretry_for liste les exceptions à relancer. retry_backoff=True attend 1, 2, 4, 8 secondes et ainsi de suite, et une valeur numérique fixe le facteur. retry_backoff_max plafonne l'attente à 600 secondes par défaut, retry_jitter (activé par défaut) rend chaque délai aléatoire pour que les tâches soumises au throttling ne relancent pas toutes en même temps, et max_retries vaut 3 par défaut, ce qui est peu pour un fournisseur très sollicité. Relancez une erreur 429 ou 5xx, jamais un prompt qui dépasse la fenêtre de contexte : il échouera de la même façon et coûtera des tokens à chaque fois. Le rate_limit de Celery s'applique par instance de worker, et non à l'échelle du cluster ; face à une limite stricte du fournisseur, donnez à ce modèle sa propre file d'attente et dimensionnez ses workers.

SLA d'urgence de 15 minutes. Ingénieurs seniors attitrés.

Nous contacter

Rendre chaque tâche idempotente

La livraison est de type « au moins une fois ». Un timeout consommateur, une connexion perdue pendant l'exécution d'une tâche à acquittement tardif et task_reject_on_worker_lost entraînent tous une seconde exécution, parfois en parallèle de la première. Celery prévoit d'annuler par défaut ces tâches en cas de perte de connexion dans la version 6.0 (worker_cancel_long_running_tasks_on_connection_loss), et l'activer dès maintenant est le choix le plus sûr pour les tâches longues. Construisez une clé à partir de l'ID du document, du hash du contenu et de la version du modèle, vérifiez l'existence d'un résultat stocké avant d'appeler le modèle, et écrivez avec un upsert. Les pipelines d'embeddings en bénéficient presque gratuitement lorsque chaque vecteur possède un ID déterministe.

Traiter les embeddings par lots avec des chords, et choisir le backend de résultats

Un group exécute des tâches en parallèle, chunks découpe une longue liste d'arguments en tâches de taille fixe, et un chord exécute un callback une fois tout un group terminé, par exemple pour marquer la construction d'un index comme achevée. Les chords nécessitent un backend de résultats, et leurs tâches ne doivent pas ignorer les résultats. Le backend rpc:// de Celery renvoie les résultats sous forme de messages AMQP : un résultat ne peut être lu qu'une fois, uniquement par le client qui a envoyé la tâche, il est transitoire sauf si result_persistent est défini, et les chords n'y sont pas pris en charge. Utilisez Redis ou SQL pour les chords, les tableaux de bord de statut et les exécutions d'agents lues par d'autres services. Envoyez dans les messages des ID de documents, pas des mégaoctets de texte.

Définir les limites de temps, et choisir le pool en conséquence

task_soft_time_limit lève SoftTimeLimitExceeded pour que la tâche puisse faire le ménage ; task_time_limit tue et remplace le processus worker. Donnez au client HTTP un timeout inférieur à la limite souple. Prefork, le pool par défaut, prend en charge les deux limites. La documentation de Celery précise que les autres pools désactivent silencieusement les limites souples, et que gevent n'applique pas la limite stricte à une tâche bloquante : les tâches liées aux API déplacées vers gevent ou eventlet reposent donc sur les timeouts du client.

Router par modèle, GPU et durée d'exécution

Le guide d'optimisation de Celery recommande des workers distincts pour les tâches longues et courtes, car les réglages qui conviennent aux unes pénalisent les autres. Une répartition courante : l'inférence locale et les modèles d'embedding sur une file d'attente consommée uniquement par les hôtes GPU, avec une concurrence calée sur la mémoire GPU ; les appels aux API hébergées sur une file d'attente à forte concurrence ; le post-traitement sur la file d'attente par défaut. task_routes associe des noms de tâches, avec jokers, à des files d'attente, et celery worker -Q choisit les files d'attente consommées par un worker. Séparez aussi par fournisseur, pour qu'un endpoint soumis au throttling ne bloque pas les tâches de l'autre.

Surveiller le travail en cours, pas seulement la profondeur

Flower est l'outil de monitoring recommandé par la documentation de Celery pour l'état des tâches et des workers. Le plugin Prometheus de RabbitMQ expose les métriques du broker sur le port 15692. Pour les files d'attente LLM, suivez les messages non acquittés par file d'attente (tâches en cours), le nombre de consommateurs (une chute à zéro alors que les workers tournent signale généralement un timeout consommateur), le taux de nouvelle livraison (dépense en double) et les arrivées dans la dead-letter queue (DLQ).

Exécuter des agents LangGraph ou LangChain depuis Celery

LangGraph et LangChain ne documentent aucune intégration Celery ; l'Agent Server hébergé de LangChain exécute sa propre file d'attente de tâches sur PostgreSQL et Redis. Les équipes qui auto-hébergent un graphe utilisent souvent ce modèle, qui relève de la pratique courante et non d'une intégration officielle : la tâche Celery reçoit un ID de thread, le graphe utilise un checkpointer persistant tel que PostgreSQL (un checkpointer en mémoire est perdu au redémarrage), et la méthode documentée par LangGraph pour reprendre après une erreur consiste à l'invoquer avec None et le même ID de thread :

@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")

Évitez ici le mode de durabilité "exit" : il n'enregistre l'état qu'à la fin d'une exécution et ne permet pas de récupérer après un plantage en cours de route. Un nœud en échec est réexécuté à la reprise : les appels d'outils à effets de bord ont donc toujours besoin de clés d'idempotence.

Les pièges les plus fréquents

  • Un prefetch laissé à 4 avec des tâches d'une minute.
  • Une limite de temps stricte supérieure au timeout consommateur, si bien que les tâches longues s'exécutent deux fois.
  • Des files classiques sur RabbitMQ 4.3, où un worker bloqué conserve ses tâches indéfiniment.
  • Des tâches countdown sur des files classiques, gardées non acquittées dans la mémoire du worker jusqu'à leur échéance.
  • autoretry_for=(Exception,), qui fait payer des nouvelles tentatives vouées à l'échec.
  • Aucune cible dead-letter sur les quorum queues, si bien qu'un message qui échoue 20 livraisons est supprimé.

Ces défaillances se situent entre Celery et le broker. AceMQ propose un support RabbitMQ pour les charges de travail Celery, et le comparatif RabbitMQ, Kafka ou NATS pour les agents IA aide à choisir le broker.

Questions fréquentes

Quel réglage de prefetch utiliser dans Celery pour les tâches LLM ?

worker_prefetch_multiplier = 1 avec task_acks_late = True. Chaque processus réserve une tâche et l'acquitte une fois terminée : les tâches longues sont réparties équitablement et la tâche d'un worker planté retourne dans la file d'attente.

Pourquoi mes tâches Celery s'exécutent-elles deux fois sur RabbitMQ ?

Le plus souvent, une tâche à acquittement tardif a dépassé le timeout consommateur, 30 minutes par défaut, ou le worker a perdu sa connexion en cours de tâche, et RabbitMQ l'a remise en file. Maintenez la limite de temps stricte sous le timeout consommateur de la file d'attente et rendez les tâches idempotentes.

Celery prend-il en charge les quorum queues de RabbitMQ ?

Oui, depuis Celery 5.5, avec confirm_publish activé. Celery désactive le QoS global lorsqu'il détecte des quorum queues et utilise la livraison différée native pour les tâches countdown et ETA.

Peut-on exécuter des agents LangGraph avec Celery ?

Oui, sous forme de modèle plutôt que d'intégration officielle : invoquez le graphe dans une tâche avec un ID de thread et un checkpointer persistant, et reprenez une exécution relivrée en l'invoquant avec None et le même ID de thread.

Autres ressources

Autres guides, comparatifs et études RabbitMQ

Consultation gratuite

Un regard expert sur votre cluster RabbitMQ

Que vous deviez résoudre un incident de production, planifier une migration ou obtenir un second avis sur votre architecture, notre équipe est prête. Pas d’argumentaire commercial, seulement des réponses.

Nous écrire