Celery ile arka plan görevlerini nasıl çalıştırırsınız?

Question

Accepted Answer

**Celery**, Django'da **arka plan ve planlanmış görevleri** çalıştırmak için standart araçtır — HTTP isteklerini bloke etmemesi gereken çalışmalar (e-posta gönderme, dosya işleme, yavaş API'ları çağırma) veya belirli bir programa göre çalışan görevler. Görevler sıraya alınır ve ayrı **worker** süreçleri tarafından asenkron olarak işlenir.

## Celery'nin çözdüğü sorun

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

Yavaş işi inline olarak yapmak, kullanıcıları bekletir ve istek zaman aşımlarına neden olur. Celery bunu arka plan worker'larına devreder, böylece istek hemen döner.

## Celery görevini tanımlama ve çağırma

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

`@shared_task` dekoratörü bir görevi tanımlar; `.delay()` (veya `.apply_async()`) onu bir worker'ın asenkron olarak işlemesi için sıraya alır — view beklemez.

## Mimari

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

## Planlanmış / periyodik görevler (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
    },
}
```

## Güvenilirlik özellikleri

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

## Neden önemli

Celery ile arka plan görev işleme, birçok gerçek dünya ihtiyacı inline olarak gerçekleşmemesi gereken işleri gerekli kıldığından, duyarlı ve ölçeklenebilir Django uygulamaları oluşturmak için gerekli bilgidir.

Bunu anlamak önemlidir çünkü temel sorun — yavaş veya ertelenmiş işleri (e-posta gönderme, görüntü/dosya işleme, rapor oluşturma, yavaş dış API'ları çağırma, veri senkronizasyonu) istek-yanıt döngüsünden ayıklama — üretim uygulamalarında yaygındır.

Böyle işleri inline olarak yapmak, kullanıcıları bekletir, istek zaman aşımlarına neden olur ve başarısız olursa işi kaybeder. Oysa **Celery** sayesinde kullanıcıya hemen yanıt verebilirken ayrı **worker'lar** işi asenkron ve güvenli bir şekilde işler.

Basit async ayıklamanın ötesinde, Celery kritik üretim yetenekleri sağlar: **planlanmış/periyodik görevler** (Celery Beat aracılığıyla, uygulamada cron yerine — günlük raporlar, temizlik işleri, yinelenen senkronizasyonlar), **geri alma stratejisiyle otomatik yeniden denemeler** (geçici hatalara karşı dayanıklılık), **görev kalıcılığı** (sıraya alınan görevler broker aracılığıyla yeniden başlantıları hayatta kalır, bu yüzden iş kaybolmaz) ve **web sunucularından bağımsız worker ölçeklendirmesi**.

Celery mimarisini (Redis/RabbitMQ gibi sırası tutan broker, görevleri işleyen worker'lar, sonuç backend'i), görevleri tanımlamayı ve sıraya almayı (`@shared_task`, `.delay()`), periyodik işleri planlamayı ve güvenilirlik özelliklerini yapılandırmayı anlamak, ağır veya ertelenmiş işleri zarif bir şekilde işleyen üretim Django sistemleri inşa etmek için değerli ileri seviye bilgidir.

Arka plan işleme, duyarlı ve sağlam uygulamalar için yaygın ve önemli bir gereksinimdir ve Celery Django ekosisteminde fiili standart çözüm olduğundan — bunu ustalıkla kullanmak, basit senkron istek işlemenin ötesinde gerçek dünya Django uygulamalarını tasarlama yeteneğini yansıtan pratik ve sık kullanılan bir beceridir.