Güçlü background job'ları nasıl çalıştırırsınız (Celery/ARQ)?

Question

Accepted Answer

**Güçlü, dayanıklı background job'ları** (FastAPI'nin hafif `BackgroundTasks`'ten daha ötesi) için gerçek bir task queue kullanırsınız: **Celery** (yerleşik standart) veya **ARQ** (modern async-native queue). Bunlar ağır, yeniden denenebilir, zamanlanmış işleri ayrı worker süreçlerinde çalıştırır, Redis gibi bir broker tarafından desteklenir.

## Neden sadece BackgroundTasks kullanmayalım?

```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 — task'ları tanımlayın ve queue'ye alın

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

Endpoint job'u queue'ye alır ve anında cevap verir; ayrı bir **worker** süreci bunu kalıcılık ve yeniden denemelerle yürütür.

## ARQ — async-native (FastAPI'nin async modeliyle uyumlu)

```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, daha hafif, async-first bir alternatiftir — codebase'iniz zaten async olduğunda çekicidir.

## Gerçek bir task queue ne sağlar

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

## Neden önemli

Güçlü background job'ları çalıştırmak, ağır veya ertelenen işleri güvenilir bir şekilde işleyen production-grade FastAPI uygulamaları oluşturmak için gereklidir — ve ne zaman ve nasıl gerçek bir task queue kullanılacağını anlamak önemli senior-level bilgisidir.

Temel yargı, **`BackgroundTasks`'ın sınırlarını** (kalıcılık, yeniden denemeler veya zamanlama yok — sadece hızlı, kritik olmayan işler için iyidir) tanımak ve işin dayanıklı, yeniden denenebilir, zamanlanmış, ağır veya dağıtılmış olması gerektiğinde (dosya/video işleme, toplu e-posta gönderme, veri senkronizasyonu, rapor oluşturma) **Celery veya ARQ**'ya yönelmektir.

Bu queue'ler kritik production yetenekleri sunar: **kalıcılık** (broker aracılığıyla job'lar çökmelerden kurtulur, böylece işler kaybolmaz), **otomatik yeniden denemeler** (geçici hatalarına karşı esneklik), **zamanlama** (periyodik job'lar) ve **worker'ların web sunucularından bağımsız ölçeklemesi**.

Task'ları tanımlamayı ve queue'ye almayı (Celery'nin `.delay()`, ARQ'nun async-native API'si), mimarisiyi (broker + worker'lar) ve özellikle **gerçek bir queue'yi BackgroundTasks'a karşı ne zaman kullanılacağı kararını**, güvenilir uygulamalar mimarlandırmak için değerlidir — ağır işi kaybetmeden boşaltmak için ortak, önemli bir gereklilik, bu da robust production sistemlerini kırılgan olanlardan ayırır.