Dein Einstieg in Django-Celery: Asynchrone Aufgabenverarbeitung wie ein Profi verwaltenDjango-Celery meistern: Asynchrone Aufgaben wie ein Profi verwalten

Die Integration von Celery in deine Django-Anwendung ermöglicht leistungsstarke, asynchrone Aufgabenverarbeitung. Erfahre, wie du Django-Celery effektiv einrichtest und für Produktionsumgebungen optimierst, um deine Anwendung stabil und performant zu machen.

Kennst du das? Eine Bestellung geht ein – und plötzlich hängt deine Django-App, weil gerade E-Mails verschickt oder PDFs generiert werden? Hier kommt Django Celery ins Spiel. Die Integration in deine Django-Anwendung ermöglicht leistungsstarke, asynchrone Aufgabenverarbeitung. Erfahre, wie du Django-Celery effektiv einrichtest und für Produktionsumgebungen optimierst, um deine Anwendung stabil und performant zu machen.

Warum Django-Celery?

Viele Aufgaben in Webanwendungen müssen nicht synchron abgearbeitet werden. Dazu zählen z. B. das Versenden von E-Mails, das Generieren von PDFs oder das Verarbeiten großer Datenmengen. Genau hier kommt Celery ins Spiel: Es ermöglicht dir, diese Aufgaben im Hintergrund (asynchron) zu erledigen.

Typische Anwendungsfälle für Celery in Django:

• E-Mail-Versand
• Bildverarbeitung
• Externe API-Aufrufe
• Datenbankbereinigung oder -analyse
• Wiederkehrende Aufgaben (z. B. Reportgenerierung mit celery beat)

So richtest du Celery ein

1. Installation der notwendigen Pakete

pip install celery redis

Falls du periodische Tasks brauchst:

pip install django-celery-beat

2. Projektstruktur vorbereiten

Erstelle eine Datei celery.py in deinem Projektordner:

# myproject/celery.py
import os
from celery import Celery

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")

app = Celery("myproject")
app.config_from_object("django.conf:settings", namespace="CELERY")
app.autodiscover_tasks()

In __init__.py:

from .celery import app as celery_app
__all__ = ["celery_app"]

3. Beispielkonfiguration in settings.py

CELERY_BROKER_URL = "redis://localhost:6379/0"
CELERY_RESULT_BACKEND = "redis://localhost:6379/0"
CELERY_ACCEPT_CONTENT = ["json"]
CELERY_TASK_SERIALIZER = "json"

Teste dein Setup mit einem simplen Task.

So sehen Celery-Tasks in Django aus

1. Einfacher Task

@shared_task
def send_email_to_user(user_id):
    print(f"E-Mail an User {user_id} gesendet")

Aufgerufen wird dieser jetzt mit:

send_email_to_user.delay(user.id)

.delay() vs. .apply_async()

• .delay() ist ein Shortcut für .apply_async() mit Standardparametern.
• Mit .apply_async() kannst du z. B. countdown, eta oder retry nutzen.

2. Komplexere Aufgaben mit Transaktionen und Logging

@shared_task
def run_customer_basket_groups_processing(basket_id):
    from shop.order.processing import BasketProcessor
    from shop.models import Basket
    from shop.exceptions import ReachedAdvertisingMediumQuotaWarning
    from django.db import transaction
    import logging

    logger = logging.getLogger(__name__)

    basket = Basket.objects.get(pk=basket_id)

    try:
        if basket.user.groups.exists():
            with transaction.atomic():
                for cbg in basket.customerbasketgroups.all():
                    user = cbg.consignee.user
                    customer_basket = Basket.objects.create(
                        user=user,
                        field_staff=basket.user,
                        discount=basket.discount,
                        discount_code=basket.discount_code,
                        shipment_options=basket.shipment_options
                    )
                    customer_basket.add_basket_lines_to_basket(
                        cbg.basket_lines, as_stock_order=True, check_quotas=False
                    )
                    basket_processor = BasketProcessor(basket=customer_basket)
                    basket_processor.process_basket()
    except Exception as e:
        logger.error(f"Fehler beim Verarbeiten von Basket {basket_id}: {e}")

transaction.atomic() sorgt dafür, dass bei einem Fehler keine halbfertige Bestellung angelegt wird.

Periodische Aufgaben mit django-celery-beat

Migrationen:

python manage.py migrate

App aktivieren:

INSTALLED_APPS += ["django_celery_beat"]

Beispieltask anlegen:

from django_celery_beat.models import PeriodicTask, IntervalSchedule

schedule, _ = IntervalSchedule.objects.get_or_create(every=10, period=IntervalSchedule.SECONDS)
PeriodicTask.objects.create(interval=schedule, name="Beispiel Task", task="myapp.tasks.send_email_to_user")

Fertig! Deine erste periodische Aufgabe ist erstellt. Das bedeutet: Celery ruft in diesem Intervall die Task auf – etwa um regelmäßig eine Benachrichtigung oder Erinnerungs-E-Mail zu versenden. Diese Konfiguration ist besonders nützlich für wiederkehrende Aufgaben, die zeitgesteuert ausgelöst werden sollen.

Die Admin-Oberfläche zeigt dir dann alle eingerichteten Tasks mit Status und Zeitplan – ideal für Monitoring und Management im Live-Betrieb.

Celery in der Produktion

1. Worker starten

celery -A myproject worker -l info

2. Beat starten

celery -A myproject beat -l info

3. Deployment-Tools nutzen

• Verwende Supervisor oder systemd zum Prozessmanagement.
• Logge Fehler z. B. mit Sentry oder externen Tools.
• Implementiere Retries bei temporären Fehlern.

Häufige Stolpersteine

• Redis nicht gestartet → ConnectionRefusedError
• .autodiscover_tasks() vergessen → Tasks werden nicht gefunden
• Task hängt → Worker nicht gestartet oder Deadlock in Datenbank

Best Practices für saubere Tasks

• Halte Tasks klein, schnell und wiederholbar
• Nutze Logging (z. B. logger.info(), logger.error())
• Plane Timeouts und Retry-Logik ein
• Verwende transaction.atomic() bei Datenbank-Aktionen
• Verwende .apply_async(countdown=...) für geplante Ausführung

Fazit

Celery ist ein kraftvolles Werkzeug, das deine Django-App flexibler, schneller und robuster machen kann. Ob einfache E-Mail-Tasks oder komplexe Bestellverarbeitung - mit dem richtigen Setup und ein paar Best Practices bist du dann auf der sicheren Seite.

Lege jetzt los - und bringe Django-Celery in deine App!