Piye carane nglakokne tugas latar belakang nganggo Celery?

Question

Accepted Answer

**Celery** yaiku alat standar kanggo nglakokne **tugas latar belakang lan terjadwal** ing Django — pekerjaan sing ora kudu ngalangi HTTP request (ngirim email, ngolah file, nelpon API sing alon) utawa sing mlaku ing jadwal. Tugas dikuqueue lan diproses sacara asinkron dening proses **worker** sing kapisah.

## Masalah sing digatekake Celery

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

Nglakokne pekerjaan sing alon inlining ndadekne pangguna ngantri lan risiko request timeout. Celery ngalihne menyang background worker supaya request bali langsung.

## Nggawe lan nelpon tugas 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
```

Dekorator `@shared_task` nggawe tugas; `.delay()` (utawa `.apply_async()`) ngekuqueue ing worker kanggo diproses sacara asinkron — view ora ngantri.

## Arsitektur

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

## Tugas terjadwal / periodik (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
    },
}
```

## Fitur Reliabilitas

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

## Mengapa iki penting

Pemrosesan tugas latar belakang nganggo Celery yaiku pengetahuan penting kanggo mbangun aplikasi Django sing responsif lan scalable, amarga akeh kebutuhan real-world sing mbutuhke pekerjaan sing ora kudu kelakon inlining nalika request.

Pahaming iku penting amarga masalah inti — ngalihne pekerjaan sing alon utawa ditunda (ngirim email, ngolah gambar/file, nggawe laporan, nelpon API eksternal sing alon, sinkronisasi data) saka siklus request-response — umum banget ing aplikasi produksi.

Nglakokne pekerjaan kaya ngono inlining ndadekne pangguna ngantri, risiko request timeout, lan kelangan pekerjaan yen gagal, nalika **Celery** ndadekne kowe bisa njawab pangguna langsung sawisé **worker** kapisah ngolah pekerjaan sacara asinkron lan reliable.

Saluwise panganggo asinkron sing sederhana, Celery nyediakne kemampuan produksi sing kritis: **tugas terjadwal/periodik** (liwat Celery Beat, ngganti cron kanggo scheduling tingkat aplikasi — laporan harian, pekerjaan pembersihan, sinkronisasi berulang), **retry otomatis nganggo backoff** (ketahanan marang kegagalan sementara), **persistensi tugas** (tugas sing dikuqueue bisa tembus restart liwat broker, supaya pekerjaan ora ilang), lan **scaling independen** worker saka web server.

Pahaming arsitektur Celery (broker kaya Redis/RabbitMQ ngang queue, worker ngolah tugas, backend asil), carane nggawe lan ngekuqueue tugas (`@shared_task`, `.delay()`), jadwal pekerjaan periodik, lan konfigurasi fitur reliabilitas yaiku pengetahuan tingkat senior sing berharga kanggo mbangun sistem Django produksi sing bisa nangani pekerjaan abot utawa ditunda kanthi anggun.

Amarga pemrosesan latar belakang yaiku kabutuhan umum lan penting kanggo aplikasi sing responsif lan robust — lan Celery yaiku solusi de facto standar ing ekosistem Django — ngowahi iku yaiku katrampilan praktis lan sering dadi relevan sing nunjukke kemampuan kanggo merancang aplikasi Django real-world saluwise penanganan request sinkron sing sederhana.