Celery in Python: Asynchrone Tasks und Hintergrundprozesse einfach umsetzen

Celery ist eine verteilte Aufgaben- oder Job-Queue, die auf asynchroner Nachrichtenübermittlung basiert. Sie ermöglicht es Python-Anwendungen, Hintergrundprozesse entweder sofort oder zu einem geplanten Zeitpunkt auszuführen. Je nach Bedarf kann Celery so konfiguriert werden, dass Aufgaben synchron oder asynchron abgearbeitet werden.

Das asynchrone Nachrichtenmodell sorgt dafür, dass Nachrichten zwischen Sender und Empfänger zwischengespeichert werden. Dadurch kann der Sender nach dem Senden fortfahren, während mehrere Nachrichten in der Warteschlange verbleiben, bis sie verarbeitet werden.

Hauptkomponenten von Celery

• Aufgaben (Tasks)
• Task-Broker
• Result-Backend
• Worker

Aufgaben sind einfache Python-Funktionen, die von Celery in Workern ausgeführt werden. Sie werden mit einem speziellen Decorator gekennzeichnet, um sie von regulären Funktionen zu unterscheiden.

Der Task-Broker ist das Kommunikationssystem zwischen deiner Anwendung und Celery. Er übernimmt die Übermittlung der Aufgaben zur Ausführung. Unterstützte Broker sind unter anderem Redis®, RabbitMQ und Amazon SQS.

Das Result-Backend dient zur Speicherung der Ergebnisse abgeschlossener Aufgaben. Celery kann diese Informationen anschließend abrufen. Unterstützt werden Backends wie Redis®, RabbitMQ (AMQP) oder SQLAlchemy.

Ein Worker ist ein Celery-Prozess, der dauerhaft im Hintergrund läuft und auf neue Aufgaben wartet. In der Regel werden mehrere Worker gleichzeitig betrieben, um parallele Ausführungen zu ermöglichen.

Lebenszyklus einer Aufgabe in Celery

Die Abarbeitung einer Aufgabe durch Celery erfolgt in drei Phasen:

• Registrierung der Aufgabe
• Ausführung der Aufgabe
• Speicherung des Ergebnisses

Die Anwendung sendet eine Aufgabe an den Broker, dieser weist sie einem Worker zu, der sie ausführt. Nach Abschluss wird das Ergebnis im Result-Backend abgelegt.

Anwendungsbereiche von Celery

Celery lässt sich vielseitig einsetzen – abhängig vom Projekt und dessen Anforderungen. Die häufigsten Einsatzszenarien sind:

• Periodische Ausführung – Aufgaben, die in festen Intervallen laufen, etwa das Versenden eines monatlichen Newsletters.
• Drittanbieter-Integration – Aufgaben, die mit externen Diensten interagieren, z. B. das Versenden von E-Mails über SMTP.
• Lange laufende Prozesse – Aufgaben, die viel Zeit beanspruchen, wie das Komprimieren oder Verarbeiten großer Dateien.

Erstellen deines ersten Celery-Programms

In diesem Abschnitt lernst du, wie du Celery-Aufgaben in ein einfaches Python-Programm integrierst.

Voraussetzungen

Um dieses Tutorial zu befolgen, benötigst du:

• Python 3.7 oder höher
• Einen installierten Redis®-Server

Installation von Celery

Celery wird über den Python-Paketmanager (pip) installiert.

Installiere die aktuelle Version von Celery:

pip install celery

Installiere zusätzlich die Abhängigkeiten für Redis®:

pip install celery[redis]

Erstellen deiner ersten Celery-Task

Hier siehst du ein einfaches Beispiel, wie du eine reguläre Python-Funktion in eine Celery-Task umwandelst.

Importiere und initialisiere das Celery-Objekt:

from celery import Celery

app = Celery(
    'tasks',
    broker="redis://localhost:6379/0",
    backend="redis://localhost:6379/0"
)

Wenn du eine angepasste Redis®-Konfiguration verwendest, passe den Verbindungsstring an:

redis://username:password@hostname:port/db

Erstelle eine einfache Celery-Aufgabe:

@app.task
def multiply(a, b):
    import time
    time.sleep(5)
    return a * b

Endgültiger Code für tasks.py:

from celery import Celery

app = Celery(
    'tasks',
    broker="redis://localhost:6379/0",
    backend="redis://localhost:6379/0"
)

@app.task
def multiply(a, b):
   import time
   time.sleep(5)
   return a * b

Verwalten von Celery-Workern

Worker sind Prozesse, die die von Celery in die Warteschlange eingestellten Aufgaben ausführen.

Starte einen Celery-Worker:

celery -A tasks worker -n worker1 -P prefork -l INFO

Erläuterung der Parameter:

• -A: Gibt die Anwendung an.
• -n: Vergibt einen Namen für den Worker.
• -P: Bestimmt den Pool-Typ.
• -l: Legt die Protokollstufe fest.

Um den Worker im Hintergrund auszuführen, füge das Flag -D hinzu.

Beende alle laufenden Celery-Worker:

ps auxww | awk '/celery(.*)worker/ {print $2}' | xargs kill -9

Ausführen von Tasks in Celery

Nachdem der Worker gestartet wurde, öffne eine Python-Konsole im selben Verzeichnis wie tasks.py.

Importiere und führe die Aufgabe aus:

from tasks import multiply
task1 = multiply.delay(512, 100)

Überprüfe den Status der Aufgabe:

task1.state

Rufe das Ergebnis ab:

task1.get()

Arten von Celery-Workern

Die Wahl des richtigen Worker-Typs hat großen Einfluss auf Leistung und Effizienz.

• Solo – Führt Aufgaben nacheinander aus.
• Prefork – Nutzt mehrere Prozesse für parallele Aufgaben.
• Eventlet – Verwendet Green Threads für I/O-lastige Aufgaben.
• Gevent – Ähnlich wie Eventlet, ideal für netzwerkgebundene Prozesse.

Starte Worker mit Solo-Pool:

celery -A tasks worker --pool=solo --loglevel=info

Starte Worker mit Prefork-Pool:

celery -A tasks worker --pool=prefork --concurrency=4 --loglevel=info

Starte Worker mit Eventlet- oder Gevent-Pool:

celery -A tasks worker --pool=eventlet --concurrency=500 --loglevel=info
celery -A tasks worker --pool=gevent --concurrency=500 --loglevel=info

Hinweis: Installiere zusätzliche Abhängigkeiten für Eventlet oder Gevent separat:

pip install celery[eventlet] oder pip install celery[gevent]

Fazit

Mit diesem Leitfaden hast du gelernt, wie du Celery in Python-Anwendungen einbindest. Celery wird in vielen SaaS-Anwendungen als Hintergrundprozessor eingesetzt, um asynchrone Prozesse effizient und skalierbar auszuführen.