Bagaimanakah anda menjalankan tugas latar belakang dengan Celery?

Question

Accepted Answer

**Celery** ialah alat standard untuk menjalankan **tugas latar belakang dan berjadual** dalam Django — kerja yang tidak sepatutnya menyekat permintaan HTTP (menghantar e-mel, memproses fail, memanggil API perlahan) atau yang berjalan mengikut jadual. Tugas diberatur dan diproses secara tak segerak oleh proses **worker** yang berasingan.

## Masalah yang diselesaikan oleh 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
```

Melakukan kerja perlahan secara inline menjadikan pengguna menunggu dan berisiko request timeout. Celery memindahkannya kepada worker latar belakang supaya permintaan kembali dengan serta-merta.

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

Decorator `@shared_task` mentakrifkan tugas; `.delay()` (atau `.apply_async()`) memberaturkannya untuk worker memprosesnya secara tak segerak — view tidak menunggu.

## Senibina

```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 berjadual / berkala (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
    },
}
```

## Ciri-ciri kebolehpercayaan

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

Pemprosesan tugas latar belakang dengan Celery ialah pengetahuan penting untuk membina aplikasi Django yang responsif dan boleh berskala, kerana banyak keperluan dunia sebenar memerlukan kerja yang tidak sepatutnya berlaku secara inline semasa permintaan.

Memahaminya adalah penting kerana masalah teras — memindahkan kerja yang perlahan atau ditangguhkan (menghantar e-mel, memproses imej/fail, menjana laporan, memanggil API luaran yang perlahan, penyegerakan data) daripada kitaran request-response — adalah lazim dalam aplikasi pengeluaran.

Melakukan kerja sedemikian secara inline menjadikan pengguna menunggu, berisiko request timeout, dan kehilangan kerja jika ia gagal, manakala **Celery** membenarkan anda membalas kepada pengguna dengan serta-merta sementara **worker** berasingan memproses kerja secara tak segerak dan boleh dipercayai.

Di luar pemindahan async yang ringkas, Celery menyediakan keupayaan pengeluaran yang kritikal: **tugas berjadual/berkala** (melalui Celery Beat, menggantikan cron untuk penjadualan peringkat aplikasi — laporan harian, kerja pembersihan, penyegerakan berulang), **percubaan semula automatik dengan backoff** (ketahanan terhadap kegagalan sementara), **ketekalan tugas** (tugas berbaris kekal melepasi mula semula melalui broker, jadi kerja tidak hilang), dan **penskalaan bebas** worker daripada pelayan web.

Memahami senibina Celery (broker seperti Redis/RabbitMQ yang menyimpan baris gilir, worker memproses tugas, result backend), cara mentakrif dan memberatur tugas (`@shared_task`, `.delay()`), menjadualkan kerja berkala, dan mengkonfigurasi ciri kebolehpercayaan ialah pengetahuan peringkat senior yang berharga untuk membina sistem Django pengeluaran yang mengendalikan kerja berat atau tertangguh dengan baik.

Kerana pemprosesan latar belakang ialah keperluan biasa dan penting untuk aplikasi yang responsif dan teguh — dan Celery ialah penyelesaian standard de facto dalam ekosistem Django — menguasainya ialah kemahiran praktikal yang kerap relevan yang mencerminkan keupayaan untuk merangka aplikasi Django dunia sebenar di luar pengendalian permintaan segerak yang ringkas.