Leitfaden · RabbitMQ

Celery und RabbitMQ für LLM-Task-Queues

Viele Python-KI-Teams nutzen Celery bereits für Hintergrundaufgaben, und RabbitMQ gehört zu den Brokern, die die Celery-Dokumentation als stabil führt – inklusive Monitoring und Remote Control. LLM-Jobs belasten diese Kombination anders als gewöhnliche Web-Tasks: Ein einzelner Aufruf kann Minuten dauern, Anbieter drosseln unter Last, und jeder Retry kostet Tokens. Dieser Leitfaden behandelt die entscheidenden Einstellungen in der Reihenfolge, in der sie Incidents verursachen – auf Basis der Dokumentation zu Celery 5.6 und RabbitMQ 4.3, geprüft am 10. Oktober 2026.

Tyler Eastridge

Von Tyler Eastridge, Head of Operations

LinkedIn · Aktualisiert am · 8 Min. Lesezeit · 13 Abschnitte

Auf dieser Seite

Das Setup in einem Absatz

Das Setup in einem Absatz

Setzen Sie task_acks_late = True und worker_prefetch_multiplier = 1, damit jeder Worker-Prozess genau einen Job hält und der Job eines abgestürzten Workers in die Queue zurückkehrt. Halten Sie das harte Task-Zeitlimit unter dem RabbitMQ-Consumer-Timeout (standardmäßig 30 Minuten) und erhöhen Sie diesen Timeout pro Queue. Verwenden Sie Quorum Queues mit Publisher Confirms. Wiederholen Sie Rate-Limit-Fehler per Retry mit exponentiellem Backoff und machen Sie jeden Task idempotent, denn manche Jobs laufen doppelt. Nutzen Sie Redis oder eine Datenbank als Result-Backend, routen Sie GPU- und API-gebundene Arbeit in getrennte Queues und richten Sie Alerting auf unbestätigte Nachrichten und die Consumer-Anzahl ein.

Warum LLM-Arbeit in eine Queue gehört

Eine Queue nimmt langsame, teure Modellaufrufe aus dem Request-Pfad, begrenzt, wie viele gleichzeitig laufen (die Zahl der Worker-Prozesse wird zu Ihrem Parallelitätslimit gegenüber dem Anbieter), und gibt jedem Job eine Retry-Policy. Celery liefert Task-Definitionen, Retries, Workflows wie Groups und Chords sowie die Ergebnisspeicherung. RabbitMQ übernimmt die Zustellung: Ein Job verlässt die Queue erst, wenn der Worker ihn bestätigt. Laut Celerys Broker-Übersicht ist RabbitMQ als Broker mit Redis als Result-Backend eine sehr verbreitete Kombination; dieser Leitfaden geht von diesem Aufbau aus. Die meisten Probleme entstehen durch Standardwerte, die für kurze Tasks gewählt wurden.

Spät bestätigen, Prefetch auf eins

Standardmäßig bestätigt Celery eine Nachricht unmittelbar vor Ausführung des Tasks. Ein Deployment oder ein OOM-Kill mitten in einem zehnminütigen Aufruf lässt den Job daher verloren gehen. Celerys Optimierungsleitfaden nennt die Einstellung für lang laufende Tasks: task_acks_late = True mit worker_prefetch_multiplier = 1. Der Worker reserviert dann nur so viele Tasks, wie er Prozesse hat, und bestätigt jeden erst nach Abschluss. Beim Standard-Multiplikator 4 kann der zuerst gestartete Worker einen Rückstau minutenlanger Jobs horten, während andere untätig sind.

Zwei Details überraschen oft. Ein spät bestätigter Task, der eine Exception wirft oder sein Zeitlimit erreicht, wird standardmäßig trotzdem bestätigt (task_acks_on_failure_or_timeout) – Fehler werden also über Retries behandelt, nicht über Redelivery. Und auch ein per Signal beendeter Worker-Prozess wird bestätigt, sofern task_reject_on_worker_lost nicht aktiviert ist; Celery warnt, dass dies Nachrichtenschleifen verursachen kann.

Task-Zeitlimits unter dem Consumer-Timeout halten

RabbitMQ gibt einen Consumer auf, der eine Zustellung länger als den Delivery-Acknowledgement-Timeout (standardmäßig 30 Minuten) unbestätigt hält, und stellt seine Nachrichten zurück in die Queue. Mit Late Acknowledgement läuft die Uhr während des gesamten LLM-Aufrufs. Ein 40-minütiger Batch-Job wird daher erneut eingereiht und anderswo gestartet, während die erste Kopie noch läuft. Die Celery-Dokumentation warnt bei langen Countdowns vor demselben Fehler PRECONDITION_FAILED.

Ab RabbitMQ 3.12 kann eine Queue über den Policy-Schlüssel consumer-timeout oder das Queue-Argument x-consumer-timeout einen eigenen Timeout in Millisekunden erhalten. RabbitMQ 4.3 wendet Acknowledgement-Timeouts nur auf Quorum Queues an und erlaubt einem Consumer, über das Consumer-Argument x-consumer-timeout einen eigenen festzulegen. Eine Classic Queue hat unter 4.3 keinen Timeout, ein hängender Worker behält seine Jobs also. Verwenden Sie eine Policy: Eine bestehende Queue mit anderen Argumenten neu zu deklarieren, schlägt mit PRECONDITION_FAILED fehl, während sich eine Policy jederzeit ändern lässt:

# 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

Die einzuhaltende Reihenfolge: Soft Limit, dann Hard Limit, dann Consumer-Timeout – jeweils mit reichlich Abstand zum vorherigen Wert.

Eine Konfiguration als Ausgangspunkt

Schritt 2 und 3 plus Quorum Queues, Routing, Retries und eine Idempotenzprüfung in einer Datei. LLM_URL steht für die Modell-API, die Sie aufrufen.

# 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

Quorum Queues nutzen – und wissen, was sich ändert

Celery unterstützt Quorum Queues ab Version 5.5: Deklarieren Sie Queues mit x-queue-type: quorum oder setzen Sie task_default_queue_type = "quorum", und aktivieren Sie Publisher Confirms, die laut Celery-Dokumentation erforderlich sind. Über den Inhalt einer Quorum Queue entscheidet eine Mehrheit ihrer Replikate. Fällt einer von drei Knoten aus, gehen daher keine eingereihten Jobs verloren.

Drei Verhaltensweisen ändern sich. Quorum Queues unterstützen kein globales QoS, daher schaltet Celery es ab, sobald es sie erkennt; Prefetch wird statisch, und Worker-Autoscaling funktioniert nicht mehr. Countdown- und ETA-Tasks würden dann einen Worker-Slot blockieren. Celery wechselt deshalb zur nativen verzögerten Zustellung und plant sie innerhalb von RabbitMQ ein – das deckt jeden Retry mit Backoff ab. Und ab RabbitMQ 4.0 verwirft eine Quorum Queue eine Nachricht nach standardmäßig 20 fehlgeschlagenen Zustellungen oder leitet sie als Dead-Letter weiter. Geben Sie daher jeder Queue ein Dead-Letter-Ziel.

Rate Limits mit Backoff wiederholen

autoretry_for listet die Exceptions, die einen Retry auslösen. retry_backoff=True wartet 1, 2, 4, 8 Sekunden und so weiter; eine Zahl legt den Faktor fest. retry_backoff_max begrenzt die Wartezeit standardmäßig auf 600 Sekunden, retry_jitter (standardmäßig aktiv) randomisiert jede Verzögerung, damit gedrosselte Tasks nicht im Gleichschritt wiederholen, und max_retries steht standardmäßig auf 3 – zu niedrig für einen ausgelasteten Anbieter. Wiederholen Sie einen 429 oder 5xx, niemals einen Prompt, der das Kontextfenster überschreitet: Er scheitert jedes Mal gleich und kostet jedes Mal Tokens. Celerys rate_limit wird pro Worker-Instanz durchgesetzt, nicht clusterweit. Bei einem harten Anbieterlimit geben Sie dem Modell eine eigene Queue und dimensionieren deren Worker entsprechend.

Reaktionszeitziele ab 15 Minuten, je nach Plan. Namentlich zugeordnete Senior Engineers.

Kontakt

Jeden Task idempotent machen

Die Zustellung erfolgt at least once. Ein Consumer-Timeout, ein Verbindungsabbruch während eines spät bestätigten Tasks und task_reject_on_worker_lost führen alle zu einem zweiten Lauf, mitunter parallel zum ersten. Celery plant, solche Tasks ab 6.0 bei Verbindungsverlust standardmäßig abzubrechen (worker_cancel_long_running_tasks_on_connection_loss); für lange Jobs ist es sicherer, dies schon jetzt zu aktivieren. Bilden Sie einen Schlüssel aus Dokument-ID, Content-Hash und Modellversion, prüfen Sie vor dem Modellaufruf auf ein gespeichertes Ergebnis und schreiben Sie per Upsert. Embedding-Pipelines erhalten das meiste davon gratis, wenn jeder Vektor eine deterministische ID hat.

Embeddings per Chord bündeln und das Result-Backend wählen

Eine group führt Tasks parallel aus, chunks teilt eine lange Argumentliste in Tasks fester Größe, und ein chord führt einen Callback aus, sobald eine ganze Group abgeschlossen ist – etwa um einen Index-Aufbau als fertig zu markieren. Chords benötigen ein Result-Backend, und ihre Tasks dürfen Ergebnisse nicht ignorieren. Celerys Backend rpc:// liefert Ergebnisse als AMQP-Nachrichten: Ein Ergebnis ist nur einmal lesbar, nur vom Client, der den Task gesendet hat, und flüchtig, sofern result_persistent nicht gesetzt ist; Chords werden dort nicht unterstützt. Nutzen Sie Redis oder SQL für Chords, Status-Dashboards und Agent-Läufe, die andere Services lesen. Senden Sie Dokument-IDs statt Megabytes an Text in Nachrichten.

Zeitlimits setzen und den Pool darauf abstimmen

task_soft_time_limit löst SoftTimeLimitExceeded aus, damit der Task aufräumen kann; task_time_limit beendet den Worker-Prozess und ersetzt ihn. Geben Sie dem HTTP-Client einen Timeout unterhalb des Soft Limits. Prefork, der Standard-Pool, unterstützt beide Limits. Laut Celery-Dokumentation deaktivieren andere Pools Soft Limits stillschweigend, und gevent setzt das Hard Limit bei einem blockierenden Task nicht durch. API-gebundene Tasks unter gevent oder eventlet sind daher auf Client-Timeouts angewiesen.

Nach Modell, GPU und Laufzeit routen

Celerys Optimierungsleitfaden empfiehlt getrennte Worker für lange und kurze Tasks, weil Einstellungen, die dem einen nützen, dem anderen schaden. Eine gängige Aufteilung: lokale Inferenz- und Embedding-Modelle auf einer Queue, die nur GPU-Hosts konsumieren, mit an den GPU-Speicher angepasster Parallelität; Aufrufe gehosteter APIs auf einer Queue mit hoher Parallelität; Nachbearbeitung auf der Standard-Queue. task_routes ordnet Task-Namen (mit Wildcards) Queues zu, und celery worker -Q legt fest, welche Queues ein Worker konsumiert. Trennen Sie auch nach Anbieter, damit ein gedrosselter Endpoint nicht die Jobs des anderen blockiert.

Laufende Arbeit überwachen, nicht nur die Queue-Tiefe

Flower ist das Monitoring-Tool, das die Celery-Dokumentation für Task-Status und Worker empfiehlt. Das Prometheus-Plugin von RabbitMQ stellt Broker-Metriken auf Port 15692 bereit. Beobachten Sie bei LLM-Queues die unbestätigten Nachrichten pro Queue (laufende Jobs), die Consumer-Anzahl (ein Abfall auf null bei laufenden Workern bedeutet meist einen Consumer-Timeout), die Redelivery-Rate (doppelte Kosten) und Eingänge in der Dead-Letter-Queue (DLQ).

LangGraph- oder LangChain-Agenten aus Celery ausführen

LangGraph und LangChain dokumentieren keine Celery-Integration; LangChains gehosteter Agent Server betreibt eine eigene Task-Queue auf PostgreSQL und Redis. Teams, die einen Graphen selbst hosten, nutzen oft folgendes Muster – gängige Praxis, keine offizielle Integration: Der Celery-Task erhält eine Thread-ID, der Graph nutzt einen persistenten Checkpointer wie PostgreSQL (ein In-Memory-Checkpointer geht beim Neustart verloren), und laut LangGraph-Dokumentation setzt man nach einem Fehler fort, indem man mit None und derselben Thread-ID aufruft:

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

Vermeiden Sie hier den Durability-Modus "exit": Er speichert den Zustand erst am Ende eines Laufs und kann sich von einem Absturz mittendrin nicht erholen. Ein fehlgeschlagener Graph-Node läuft beim Fortsetzen erneut, daher benötigen Tool-Aufrufe mit Seiteneffekten weiterhin Idempotenzschlüssel.

Die häufigsten Fallstricke

  • Prefetch bleibt auf 4 bei minutenlangen Jobs.
  • Ein Hard Limit über dem Consumer-Timeout, sodass lange Jobs doppelt laufen.
  • Classic Queues unter RabbitMQ 4.3, wo ein hängender Worker seine Jobs unbegrenzt festhält.
  • Countdown-Tasks auf Classic Queues, die bis zur Fälligkeit unbestätigt im Worker-Speicher liegen.
  • autoretry_for=(Exception,) – Sie bezahlen für Retries, die nie gelingen können.
  • Kein Dead-Letter-Ziel bei Quorum Queues, sodass eine Nachricht nach 20 fehlgeschlagenen Zustellungen verworfen wird.

Diese Fehler liegen zwischen Celery und dem Broker. AceMQ bietet RabbitMQ-Support für Celery-Workloads, und RabbitMQ vs. Kafka vs. NATS für KI-Agenten behandelt die Wahl des Brokers.

Häufig gestellte Fragen

Welche Prefetch-Einstellung sollte Celery für LLM-Tasks verwenden?

worker_prefetch_multiplier = 1 mit task_acks_late = True. Jeder Prozess reserviert einen Task und bestätigt ihn nach Abschluss. So verteilen sich lange Jobs gleichmäßig, und der Job eines abgestürzten Workers kehrt in die Queue zurück.

Warum laufen meine Celery-Tasks auf RabbitMQ doppelt?

Meist hat ein spät bestätigter Task den Consumer-Timeout (standardmäßig 30 Minuten) überschritten oder der Worker hat mitten im Task die Verbindung verloren, und RabbitMQ hat ihn erneut eingereiht. Halten Sie das Hard Limit unter dem Consumer-Timeout der Queue und machen Sie Tasks idempotent.

Unterstützt Celery RabbitMQ Quorum Queues?

Ja, ab Celery 5.5 mit aktiviertem confirm_publish. Celery deaktiviert globales QoS, sobald es Quorum Queues erkennt, und nutzt für Countdown- und ETA-Tasks die native verzögerte Zustellung.

Kann ich LangGraph-Agenten mit Celery ausführen?

Ja, als Muster statt als offizielle Integration: Rufen Sie den Graphen innerhalb eines Tasks mit einer Thread-ID und einem persistenten Checkpointer auf, und setzen Sie einen erneut zugestellten Lauf fort, indem Sie mit None und derselben Thread-ID aufrufen.

Kostenlose Beratung

Lassen Sie Experten auf Ihre RabbitMQ-Cluster-Umgebung schauen

Ob Sie einen Produktionsvorfall beheben, eine Migration planen oder eine zweite Meinung zu Ihrer Architektur wünschen – unser Team steht bereit. Kein Verkaufsgespräch, nur Antworten.

E-Mail schreiben