Hoe voer je achtergrondtaken uit met Celery?

Question

Accepted Answer

**Celery** is de standaardtool voor het uitvoeren van **achtergrondtaken en geplande taken** in Django — werk dat de HTTP-aanvraag niet mag blokkeren (e-mails verzenden, bestanden verwerken, trage API's aanroepen) of dat volgens een schema wordt uitgevoerd. Taken worden in de wachtrij geplaatst en asynchroon verwerkt door aparte **worker**-processen.

## Het probleem dat Celery oplost

```python
# ❌ doing slow work inline blocks the response — the user waits, risks timeouts
def register(request):
    user = create_user(request.POST)
    send_welcome_email(user)           # slow — the user waits for the email to send
    generate_report(user)               # even slower
    return redirect("home")             # finally responds after all that
```

Het uitvoeren van traag werk inline laat gebruikers wachten en riskeert timeouts van aanvragen. Celery verplaatst dit naar achtergrondworkers zodat de aanvraag onmiddellijk wordt geretourneerd.

## Een Celery-taak definiëren en aanroepen

```python
# tasks.py — define a task
from celery import shared_task

@shared_task
def send_welcome_email(user_id):
    user = User.objects.get(id=user_id)
    send_email(user.email, "Welcome!")    # runs in a WORKER, not the web process

# in a view — QUEUE the task instead of running it inline
def register(request):
    user = create_user(request.POST)
    send_welcome_email.delay(user.id)     # .delay() queues it → returns IMMEDIATELY
    return redirect("home")                # user gets a fast response
```

De `@shared_task`-decorator definieert een taak; `.delay()` (of `.apply_async()`) plaatst deze in de wachtrij zodat een worker deze asynchroon kan verwerken — de view wacht niet.

## De architectuur

```text
Django (web) --.delay()--> BROKER (Redis/RabbitMQ) --> CELERY WORKER (processes the task)
                              (the message queue)         (separate process/machine)
```

```text
Components:
  ✓ Broker (Redis or RabbitMQ) — holds the queue of pending tasks
  ✓ Celery worker(s) — separate processes that pull and execute tasks
  ✓ Result backend (optional) — stores task results/status
Run workers separately: `celery -A myproject worker`
```

## Geplande / periodieke taken (Celery Beat)

```python
# run tasks on a schedule (like cron) via Celery Beat
CELERY_BEAT_SCHEDULE = {
    "daily-report": {
        "task": "myapp.tasks.generate_daily_report",
        "schedule": crontab(hour=0, minute=0),     # every midnight
    },
}
```

## Betrouwbaarheidsfuncties

```python
@shared_task(bind=True, max_retries=3, default_retry_delay=60)
def sync_data(self):
    try:
        do_sync()
    except Exception as exc:
        raise self.retry(exc=exc)             # automatic retries on failure
```

```text
✓ Retries with backoff (resilience against transient failures)
✓ Task persistence (queued tasks survive restarts via the broker)
✓ Scheduling (Celery Beat — periodic/cron-like tasks)
✓ Rate limiting, concurrency control, task routing/priorities
✓ Workers scale independently of web servers
```

## Waarom het belangrijk is

Achtergrondtaakverwerking met Celery is essentiële kennis voor het bouwen van responsieve, schaalbare Django-toepassingen, omdat veel praktische behoeften werk vereisen dat niet inline tijdens een aanvraag mag gebeuren.

De begripswaarde ligt in het kernprobleem — het verplaatsen van traag of uitgesteld werk (e-mails verzenden, afbeeldingen/bestanden verwerken, rapporten genereren, trage externe API's aanroepen, datasynchronisatie) van de request-response-cycle — wat alomtegenwoordig is in productietoepassingen.

Zodanig werk inline uitvoeren laat gebruikers wachten, riskeert aanvraagtime-outs en verliest het werk als het mislukt, terwijl **Celery** je toestaat onmiddellijk op de gebruiker te reageren terwijl aparte **workers** het werk asynchroon en betrouwbaar verwerken.

Naast eenvoudige async-offloading biedt Celery kritieke productiemogelijkheden: **geplande/periodieke taken** (via Celery Beat, vervanging van cron voor scheduling op applicatieniveau — dagelijkse rapporten, opschoonklussen, terugkerende synchronisaties), **automatische pogingen met uitstel** (weerbaarheid tegen voorbijgaande fouten), **taakpersistentie** (taken in de wachtrij overleven herstarts via de broker, dus werk gaat niet verloren), en **onafhankelijke schaling** van workers van webservers.

De architectuur van Celery begrijpen (de broker zoals Redis/RabbitMQ met de wachtrij, workers die taken verwerken, de resultaatbackend), hoe je taken definieert en in de wachtrij plaatst (`@shared_task`, `.delay()`), periodiek werk inplant, en betrouwbaarheidsfuncties configureert, is waardevolle seniorlevelkennis voor het bouwen van productie-Django-systemen die zwaar of uitgesteld werk elegant afhandelen.

Omdat achtergrondverwerking een veel voorkomende, belangrijke vereiste is voor responsieve, robuuste toepassingen — en Celery de de facto standaardoplossing in het Django-ecosysteem is — is het beheersen ervan een praktische, regelmatig relevante vaardigheid die het vermogen weerspiegelt om Django-toepassingen uit de echte wereld op te zetten buiten eenvoudige synchrone aanvraagafhandeling.