Bagaimana Anda menjalankan tugas latar belakang dengan Celery?

Question

Accepted Answer

**Celery** adalah alat standar untuk menjalankan **tugas latar belakang dan terjadwal** di Django — pekerjaan yang tidak boleh memblokir permintaan HTTP (mengirim email, memproses file, memanggil API lambat) atau yang berjalan sesuai jadwal. Tugas antri dan diproses secara asinkron oleh proses **worker** terpisah.

## Masalah yang Celery selesaikan

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

Melakukan pekerjaan lambat secara inline membuat pengguna menunggu dan berisiko timeout permintaan. Celery memindahkannya ke worker latar belakang sehingga permintaan kembali segera.

## Mendefinisikan dan memanggil 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` mendefinisikan tugas; `.delay()` (atau `.apply_async()`) antri untuk diproses worker secara asinkron — view tidak menunggu.

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

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

Pemrosesan tugas latar belakang dengan Celery adalah pengetahuan penting untuk membangun aplikasi Django yang responsif dan scalable, karena banyak kebutuhan dunia nyata memerlukan pekerjaan yang tidak boleh terjadi secara inline selama permintaan.

Memahaminya penting karena masalah inti — memindahkan pekerjaan lambat atau tertunda (mengirim email, memproses gambar/file, menghasilkan laporan, memanggil API eksternal lambat, sinkronisasi data) dari siklus permintaan-respons — tersebar luas dalam aplikasi produksi.

Melakukan pekerjaan seperti itu secara inline membuat pengguna menunggu, berisiko timeout permintaan, dan kehilangan pekerjaan jika gagal, sedangkan **Celery** memungkinkan Anda merespons pengguna segera sementara **worker** terpisah memproses pekerjaan secara asinkron dan andal.

Beyond offloading asinkron sederhana, Celery menyediakan kemampuan produksi penting: **tugas terjadwal/periodik** (melalui Celery Beat, menggantikan cron untuk penjadwalan tingkat aplikasi — laporan harian, pekerjaan pembersihan, sinkronisasi berulang), **retry otomatis dengan backoff** (ketahanan terhadap kegagalan sementara), **persistensi tugas** (tugas antri bertahan restart melalui broker, jadi pekerjaan tidak hilang), dan **penskalaan independen** worker dari server web.

Memahami arsitektur Celery (broker seperti Redis/RabbitMQ menahan antrian, worker memproses tugas, backend hasil), cara mendefinisikan dan antri tugas (`@shared_task`, `.delay()`), menjadwalkan pekerjaan periodik, dan mengonfigurasi fitur keandalan adalah pengetahuan tingkat senior yang berharga untuk membangun sistem Django produksi yang menangani pekerjaan berat atau tertunda dengan elegan.

Karena pemrosesan latar belakang adalah persyaratan umum dan penting untuk aplikasi yang responsif dan robust — dan Celery adalah solusi de facto standard dalam ekosistem Django — menguasainya adalah keterampilan praktis dan relevan yang mencerminkan kemampuan untuk merancang aplikasi Django dunia nyata beyond penanganan permintaan sinkron sederhana.