---
title: "Django-Celery meistern: Asynchrone Aufgaben wie ein Profi verwalten"
description: "Lerne, wie du Django-Celery für asynchrone Aufgabenverarbeitung einrichtest und für die Produktion optimierst. Der perfekte Leitfaden für Stabilität und Performance!"
canonical_url: "https://www.blueshoe.de/blog/django-celery-in-produktion/"
---

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](https://docs.celeryq.dev/en/latest/django/first-steps-with-django.html) 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.

![Alles, was du über Django-Celery wissen musst](/img/blog/celery.png)

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

```bash
pip install celery redis
```

Falls du periodische Tasks brauchst:

```bash
pip install django-celery-beat
```

### 2. Projektstruktur vorbereiten

Erstelle eine Datei `celery.py` in deinem Projektordner:

```python
# 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`:

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

### 3. Beispielkonfiguration in `settings.py`

```python
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

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

Aufgerufen wird dieser jetzt mit:

```python
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

```python
@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:

```bash
python manage.py migrate
```

### App aktivieren:

```bash
INSTALLED_APPS += ["django_celery_beat"]
```

### Beispieltask anlegen:

```python
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.

![Django-Celery Admin](/img/blog/celery-1.png)

---

## Celery in der Produktion

### 1. Worker starten

```bash
celery -A myproject worker -l info
```

### 2. Beat starten

```bash
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!

## Sitemap

See the full [sitemap](/sitemap.md) for all pages.