Kako pokrenuti pozadinske zadatke s Celeryjem?

Question

Accepted Answer

**Celery** je standardni alat za pokretanje **pozadinskih i planiranih zadataka** u Djangu — rad koji ne bi trebao blokirati HTTP zahtjev (slanje e-pošte, obrada datoteka, pozivanje sporog API-ja) ili koji se izvršava po rasporedu. Zadaci se stavljaju u red čekanja i obrađuju asinkriono od strane odvojenih **worker** procesa.

## Problem koji Celery rješava

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

Sporaja obrada inline-a tjera korisnike da čekaju i rizikuje vremensko ograničenje zahtjeva. Celery je prebacuje na pozadinske workere kako bi se zahtjev odmah vratio.

## Definiranje i pozivanje Celery zadatka

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

Dekorator `@shared_task` definira zadatak; `.delay()` (ili `.apply_async()`) ga stavlja u red čekanja kako bi ga worker obradio asinkriono — prikaz ne čeka.

## Arhitektura

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

## Planirani / periodični zadaci (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
    },
}
```

## Značajke pouzdanosti

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

## Zašto je to važno

Obrada pozadinskih zadataka s Celeryjem je bitno znanje za izgradnju odgovorne i skalabilne Django aplikacije, jer mnogo zahtjeva iz stvarnog svijeta zahtijeva rad koji ne bi trebao biti inline tijekom zahtjeva.

Razumijevanje je važno jer je osnovni problem — prebacivanje sporog ili odgoženог rada (slanje e-pošte, obrada slika/datoteka, generiranje izvještaja, pozivanje sporog vanjskog API-ja, sinkronizacija podataka) s ciklusa zahtjev-odgovor — sveprisutan u proizvodnim aplikacijama.

Takav rad inline-a tjera korisnike da čekaju, rizikuje vremensko ograničenje zahtjeva i gubi rad ako ne uspe, dok **Celery** omogućuje da odmah odgovorite korisniku dok odvojeni **workers** asinkriono i pouzdano obrađuju rad.

Izvan jednostavnog asinkronog prebacivanja, Celery pruža kritične proizvodne mogućnosti: **planirane/periodične zadatke** (preko Celery Beata, zamjena za cron za planiranje na razini aplikacije — dnevni izvještaji, poslovi čišćenja, ponavljajuće sinkronizacije), **automatske pokušaje s backoff-om** (otpornost protiv prolaznih grešaka), **trajnost zadataka** (zadaci u redu čekanja opstanu restart kroz broker, pa se rad ne gubi), i **neovisno skaliranje** workera od web servera.

Razumijevanje Celery arhitekture (broker poput Redis/RabbitMQ koji drži red čekanja, workeri obrađuju zadatke, backend za rezultate), kako definirati i staviti zadatke u red čekanja (`@shared_task`, `.delay()`), planirati periodički rad i konfigurirati značajke pouzdanosti je vrijedna znanja na razini seniora za izgradnju proizvodnih Django sustava koji elegantno rukuju teškim ili odgoženим radom.

Jer je obrada u pozadini česta, važna zahtjev za odgovorne i robusne aplikacije — a Celery je de facto standardno rješenje u Django ekosustavu — ovladavanje time je praktična, često relevantna vještina koja odražava sposobnost arhitekture stvarnih Django aplikacija izvan jednostavnog sinkronog rukovanja zahtjevima.