Hogyan futtatsz háttérben futó feladatokat Celery-vel?

Question

Accepted Answer

**A Celery** a Django-ban az **háttérben futó és ütemezett feladatok** futtatásának standard eszköze — olyan munka, amely nem kellene hogy blokkolja a HTTP kérést (e-mailek küldése, fájlfeldolgozás, lassú API hívások) vagy amely ütemezés szerint fut. A feladatok sorbaállnak és **worker** folyamatok dolgozzák fel őket aszinkron módon.

## A probléma, amit a Celery megold

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

A lassú munka inline végzése arra készteti a felhasználókat, hogy várjanak, és kockázatot jelent a kérés időtúllépése. A Celery ezt háttérben futó worker-ekre bízza, így a kérés azonnal visszatérhet.

## Celery feladat definiálása és hívása

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

A `@shared_task` dekorátor definiál egy feladatot; a `.delay()` (vagy `.apply_async()`) sorbaállítja azt egy worker számára aszinkron feldolgozásra — a view nem vár.

## Az architektúra

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

## Ütemezett / periodikus feladatok (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
    },
}
```

## Megbízhatósági funkciók

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

## Miért fontos

A háttérben futó feladatok feldolgozása a Celery-vel alapvető ismeret a reszponzív, skálázható Django alkalmazások építéséhez, mivel számos valós igény olyan munkát igényel, amely nem történhet meg inline egy kérés alatt.

Fontos megérteni, mert az alapvető probléma — a lassú vagy halasztott munka (e-mailek küldése, képek/fájlok feldolgozása, jelentések generálása, lassú külső API-hívások, adatszinkronizálás) kérés-válasz ciklustól való eltávolítása — ubikwitous az éles alkalmazásokban.

Ilyen munka inline végzése arra készteti a felhasználókat, hogy várjanak, kockázatot jelent a kérés időtúllépésére, és elvesziti a munkát, ha meghiúsul, míg a **Celery** lehetővé teszi, hogy azonnal válaszolj a felhasználónak, miközben a külön futó **workerek** aszinkron és megbízhatóan feldolgozzák a munkát.

Az egyszerű aszinkron eltávolításon túl a Celery kritikus termelési képességeket biztosít: **ütemezett/periodikus feladatok** (Celery Beat-en keresztül, helyettesítve a cron-t az alkalmazásszintű ütemezéshez — napi jelentések, tisztítási feladatok, ismétlődő szinkronizálások), **automatikus újrapróbálkozások visszatartással** (rugalmasság az átmeneti hibákkal szemben), **feladatperzisztencia** (sorbaállított feladatok a közvetítőn keresztül megmaradnak az újraindítások után, így a munka nem vész el), és a **workerek független skálázása** a webszerverekről.

A Celery architektúrájának megértése (a Redis/RabbitMQ-hoz hasonló közvetítő, amely a várakozási sort tartja, workerek feldolgozzák a feladatokat, az eredmény backend), a feladatok definiálása és sorbaállítása (`@shared_task`, `.delay()`), az időszakos munka ütemezése, és a megbízhatósági funkciók konfigurálása értékes senior szintű ismeret az olyan termelési Django rendszerek építéséhez, amelyek elegánsan kezelik a nagy vagy halasztott munkát.

Mivel a háttérben futó feldolgozás gyakori, fontos követelmény a reszponzív, robusztus alkalmazások számára — és a Celery az érdeklődések de facto standard megoldása a Django ökoszisztémában — annak elsajátítása praktikus, gyakran relevans készség, amely tükrözi a valós Django alkalmazások architektúrájának képességét az egyszerű szinkron kérésfeldolgozáson túl.