Si i drejtoni detyrat në sfond me Celery?

Question

Accepted Answer

**Celery** është mjeti standard për drejtimin e **detyrave në sfond dhe të planifikuara** në Django — punë që nuk duhet të bllokojë kërkesën HTTP (dërgim emailesh, përpunim skedarësh, thirrje API-sh të ngadaltë) ose që funksionon në një orar. Detyrat radhiten dhe përpunohen në mënyrë asinkrone nga proceset **worker** të ndara.

## Problemi që Celery zgjedh

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

Bëja e punës së ngadaltë në linjë e bën përdoruesit të presin dhe rrezikon timeout-et e kërkesave. Celery e ngarkon atë në worker-ët në sfond kështu që kërkesa kthehet menjëherë.

## Përcaktimi dhe thirrja e një detyre Celery

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

Dekoratori `@shared_task` përcakton një detyrë; `.delay()` (ose `.apply_async()`) e rradhit për përpunim asinkron nga një worker — pamja nuk pret.

## Arkitektura

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

## Detyrat e planifikuara / periodike (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
    },
}
```

## Veçoritë e besueshmërisë

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

## Pse ka rëndësi

Përpunimi i detyrave në sfond me Celery është njohuri thelbësore për ndërtimin e aplikacioneve Django të përgjegjshme dhe të shkallëzueshme, pasi shumë nevojat e botës reale kërkojnë punë që nuk duhet të ndodhë në linjë gjatë një kërkese.

Kuptimi i kësaj është i rëndësishëm sepse problemi themelor — ngarkim i punës së ngadaltë ose të shtyra (dërgim emailesh, përpunim imazhesh/skedarësh, gjenerimi i raporteve, thirrje API-sh të ngadaltë, sinkronizim të dhënash) jashtë ciklit përgjigje-kërkesë — është i përhapur në aplikacionet e prodhimit.

Bëja e një pune të tillë në linjë e bën përdoruesit të presin, rrezikon timeout-et e kërkesave dhe humbet punën nëse dështon, ndërsa **Celery** ju lejon të përgjigjeni menjëherë përdoruesit ndërsa **worker-ët** e ndara përpunojnë punën në mënyrë asinkrone dhe të sigurt.

Për të kaluar përpunimin e thjeshtë asinkron, Celery siguron aftësi kritike të prodhimit: **detyra të planifikuara/periodike** (përmes Celery Beat, duke zëvendësuar cron për planifikim në nivel aplikacioni — raporte të përditshme, punë pastrimi, sinkronizime të përsëritura), **përpjekje të automatike me prapavijë** (rezilienca ndaj dështimeve kalimtare), **qëndrueshmëri e detyrave** (detyrat e radhitë mbijetojnë rindritjet përmes broker-it, prandaj puna nuk humbet), dhe **shkallëzim i pavarur** i worker-ëve nga serverët e web-it.

Kuptimi i arkitekturës së Celery (broker-i si Redis/RabbitMQ që mban radhën, worker-ët që përpunojnë detyrat, backend-i i rezultateve), si të përcaktojnë dhe të radhiten detyrat (`@shared_task`, `.delay()`), të planifikojnë punë periodike dhe të konfiguroni veçoritë e besueshmërisë është njohuri e vlerës për nivelin e lartë për ndërtimin e sistemeve Django të prodhimit që trajtojnë punën e rëndë ose të shtyra me elegancë.

Sepse përpunimi në sfond është një kërkesë e zakonshme dhe e rëndësishme për aplikacionet e përgjegjshme dhe të fuqishme — dhe Celery është zgjidhja de facto standarde në ekosistemën Django — zotërimi i tij është një aftësi praktike, shpesh të rëndësishme që pasqyron aftësinë për të arkitekturuar aplikacione Django të botës reale përtej trajtimit të thjeshtë të kërkesave sinkrone.