Kaip paleisti foninės užduotys naudojant Celery?

Question

Accepted Answer

**Celery** yra standartinis įrankis foninėms ir **planuotoms užduotims** paleisti Django – darbui, kuris neturėtų sustabdyti HTTP užklausos (el. laiškų siuntimas, failų apdorojimas, lėtų API kvietimai) arba kuris vyksta pagal grafiką. Užduotys yra į eilę surikiamos ir asinchroniškai apdorojamos atskirų **worker** procesų.

## Problema, kurią Celery sprendžia

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

Lėto darbo atlikimas nuolatiniame kode verčia vartotojus laukti ir rizikuoja užklausos išėjimu. Celery perkeliama fono darbininkams, kad užklausa būtų grąžinta iš karto.

## Celery užduoties apibrėžimas ir kvietimas

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

Dekoratorius `@shared_task` apibrėžia užduotį; `.delay()` (arba `.apply_async()`) įdeda ją į eilę darbininkui asinchroniškai apdoroti – vaizdo schema nelaukia.

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

## Planuotos / periodinės užduotys (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
    },
}
```

## Patikimumas

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

## Kodėl tai svarbu

Foninių užduočių apdorojimas naudojant Celery yra esminės žinios kuriant greitai reaguojančias, masteliojamas Django programas, nes daugelis realaus pasaulio poreikių reikalauja darbo, kuris neturėtų vykti nuolatiniame užklausos cikle.

Supratimas yra svarbus, nes pagrindinė problema – lėto arba atidėto darbo (el. laiškų siuntimas, vaizdų/failų apdorojimas, ataskaitų generavimas, lėtų išorinių API kvietimai, duomenų sinchronizavimas) perkėlimas iš užklausos-atsako ciklo – yra visur gamybos programose.

Tokio darbo atlikimas nuolatiniame kode verčia vartotojus laukti, rizikuoja užklausos išėjimu ir praranda darbą, jei jis nepavyksta, o **Celery** leidžia iš karto atsakyti vartotojui, o atskiri **darbininkai** asinchroniškai ir patikimai apdoroja darbą.

Be paprasto asinchroninio perkėlimo, Celery suteikia kritines gamybos galimybes: **planuotas/periodines užduotis** (per Celery Beat, pakeičiant cron programos lygio planavimu – kasdieninės ataskaitos, apsaugymo darbai, pasikartojantys sinchronizavimai), **automatiniai iš naujo bandymai su grąžinimu** (atsparumas laikinoms klaidoms), **užduočių išsaugojimas** (eilėje esančios užduotys išlieka paleidus sistemą iš naujo per tarpininką, todėl darbas nėra prarandamas), ir **nepriklausomas darbininkų masteliojimas** iš žiniatinklio serverių.

Supratimas apie Celery architektūrą (tarpininkę kaip Redis/RabbitMQ, kurianti eilę, darbininkus apdorojančius užduotis, rezultatų galinį tašką), kaip apibrėžti ir į eilę sudėti užduotis (`@shared_task`, `.delay()`), planuoti periodinį darbą ir konfigūruoti patikimumą, yra vertinga aukštojo lygio žinojimu kuriant gamybos Django sistemas, kurios elegantiškai tvarko sunkų arba atidėtą darbą.

Bnes fono apdorojimas yra dažnas, svarbus greitai reaguojančių, patikimų programų reikalavimas – o Celery yra de facto standartinis sprendimas Django ekosistemoje – jį įvaldyti yra praktinis, dažnai aktualus įgūdis, atspindintis gebėjimą projektuoti realaus pasaulio Django programas, peržengiant paprastą sinchroninį užklausos apdorojimą.