Bagaimana Anda menjalankan pekerjaan latar belakang yang kuat (Celery/ARQ)?

Question

Accepted Answer

Untuk **pekerjaan latar belakang yang kuat dan tahan lama** (melampaui `BackgroundTasks` FastAPI yang ringan), Anda menggunakan antrian tugas yang sebenarnya: **Celery** (standar yang mapan) atau **ARQ** (antrian async-native modern). Ini menjalankan pekerjaan berat, dapat dicoba ulang, terjadwal dalam proses pekerja terpisah, didukung oleh broker seperti Redis.

## Mengapa ini penting

```text
BackgroundTasks runs in the web process → NO persistence (lost on crash), NO retries,
NO scheduling, and heavy work ties up the worker. Fine only for quick fire-and-forget.
For durable/critical/heavy/scheduled jobs → use a real task queue (Celery / ARQ).
```

## Celery — tentukan dan antrikan tugas

```python
# tasks.py
from celery import Celery
celery_app = Celery("tasks", broker="redis://localhost:6379")

@celery_app.task(bind=True, max_retries=3)
def process_video(self, video_id: int):
    try:
        do_heavy_processing(video_id)        # runs in a WORKER, not the web process
    except Exception as exc:
        raise self.retry(exc=exc, countdown=60)   # automatic retry on failure
```

```python
# in a FastAPI endpoint — QUEUE the task, return immediately
@app.post("/videos/{id}/process")
def process(id: int):
    process_video.delay(id)                  # enqueue → returns at once (doesn't block)
    return {"status": "processing started"}
# run workers separately: celery -A tasks worker
```

Titik akhir mengantrikan pekerjaan dan merespons secara instan; proses **pekerja** terpisah menjalankannya dengan ketekunan dan percobaan ulang.

## ARQ — async-native (sesuai dengan model async FastAPI)

```python
# ARQ is built on asyncio — a natural fit for async FastAPI codebases
async def process_video(ctx, video_id: int):
    await do_async_processing(video_id)

# enqueue from an endpoint
await redis.enqueue_job("process_video", video_id)
```

ARQ adalah alternatif yang lebih ringan dan berorientasi async — menarik ketika basis kode Anda sudah async.

## Apa yang disediakan antrian tugas yang sebenarnya

```text
✓ Persistence — jobs survive crashes/restarts (stored in the broker)
✓ Retries with backoff — resilience against transient failures
✓ Scheduling — periodic/cron-like jobs (Celery Beat)
✓ Distribution & scaling — workers scale independently of the web servers
✓ Concurrency & rate limiting, task routing/priorities, result tracking
```

## Mengapa ini penting

Menjalankan pekerjaan latar belakang yang kuat adalah penting untuk membangun aplikasi FastAPI tingkat produksi yang menangani pekerjaan berat atau tertunda dengan andal — dan memahami kapan dan bagaimana menggunakan antrian tugas yang sebenarnya adalah pengetahuan tingkat senior yang penting.

Pertimbangan inti adalah mengenali **batasan `BackgroundTasks`** (tidak ada ketekunan, percobaan ulang, atau penjadwalan — baik hanya untuk pekerjaan cepat, tidak kritis) dan beralih ke **Celery atau ARQ** ketika pekerjaan harus tahan lama, dapat dicoba ulang, terjadwal, berat, atau terdistribusi (pemrosesan file/video, pengiriman email massal, sinkronisasi data, pembuatan laporan).

Antrian ini menyediakan kemampuan produksi kritis: **ketekunan** (pekerjaan bertahan dari kerusakan melalui broker, jadi pekerjaan tidak hilang), **percobaan ulang otomatis** (ketahanan terhadap kegagalan sementara), **penjadwalan** (pekerjaan berkala), dan **penskalaan independen** pekerja dari server web.

Mengetahui cara mendefinisikan dan mengantrikan tugas (`.delay()` Celery, API async-native ARQ), arsitektur (broker + pekerja), dan terutama **keputusan kapan menggunakan antrian sebenarnya versus `BackgroundTasks`**, berharga untuk merancang aplikasi andal yang memindahkan pekerjaan berat tanpa kehilangannya — persyaratan umum dan penting yang membedakan sistem produksi yang kuat dari sistem yang rapuh.