Jak spustíte úlohy na pozadí pomocí Celery?

Question

Accepted Answer

**Celery** je standardní nástroj pro spouštění **úloh na pozadí a naplánovaných úloh** v Django — práce, která by neměla blokovat HTTP požadavek (odesílání e-mailů, zpracování souborů, volání pomalých API) nebo která běží podle plánu. Úlohy jsou zařazeny do fronty a zpracovávány asynchronně samostatnými **worker** procesy.

## Problém, který Celery řeší

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

Provedení pomalé práce inline způsobuje, že uživatelé čekají a riskují vypršení času požadavku. Celery ji přesune na background workery, aby se požadavek vrátil okamžitě.

## Definování a volání Celery úlohy

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

Dekorátor `@shared_task` definuje úlohu; `.delay()` (nebo `.apply_async()`) ji zařadí do fronty pro zpracování workerem asynchronně — pohled nečeká.

## Architektura

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

## Naplánované / periodické úlohy (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
    },
}
```

## Funkce spolehlivosti

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

## Proč na tom záleží

Zpracování úloh na pozadí pomocí Celery je základní znalost pro vytváření responzivních a škálovatelných Django aplikací, protože mnohé skutečné potřeby vyžadují práci, která by neměla probíhat inline během požadavku.

Rozumění je důležité, protože jádro problému — přesun pomalé nebo odložené práce (odesílání e-mailů, zpracování obrázků/souborů, generování zpráv, volání pomalých externích API, synchronizace dat) z cyklu request-response — je všudypřítomné v produkčních aplikacích.

Provedení takové práce inline způsobuje, že uživatelé čekají, riskují vypršení času požadavku a práce se ztratí, pokud selže, zatímco **Celery** vám umožňuje okamžitě reagovat na uživatele, zatímco samostatné **workery** asynchronně a spolehlivě zpracovávají práci.

Beyond jednoduché asynchronní přesunu, Celery poskytuje kritické produkční schopnosti: **naplánované/periodické úlohy** (prostřednictvím Celery Beat, nahrazující cron pro plánování na úrovni aplikace — denní zprávy, úkoly čištění, opakující se synchronizace), **automatické opakované pokusy s exponenciálním zpožděním** (odolnost vůči přechodným chybám), **trvalost úloh** (zařazené úlohy přežijí restartování prostřednictvím brokera, takže se práce neztratí), a **nezávislé škálování** workerů od webových serverů.

Rozumění architektuře Celery (broker jako Redis/RabbitMQ s frontou, workery zpracovávající úlohy, backend výsledků), způsobům definování a zařazování úloh do fronty (`@shared_task`, `.delay()`), plánování periodické práce a konfiguraci funkcí spolehlivosti je cenná znalost na úrovni senior pro vytváření produkčních Django systémů, které elegantně zpracovávají těžkou nebo odloženou práci.

Protože zpracování na pozadí je běžnou, důležitou požadavkem pro responzivní a robustní aplikace — a Celery je de facto standardní řešení v ekosystému Django — její zvládnutí je praktická, často relevantní dovednost, která odráží schopnost architektury skutečných Django aplikací nad rámec jednoduchého synchronního zpracování požadavků.