آپ Celery کے ساتھ background tasks کو کیسے چلاتے ہیں؟

Question

Accepted Answer

**Celery** Django میں **background اور scheduled tasks** چلانے کا معیاری ٹول ہے — یہ وہ کام ہے جو HTTP request کو block نہیں کرنا چاہیے (ای میلز بھیجنا، فائلیں پروسیس کرنا، سست APIs کو کال کرنا) یا جو schedule پر چلتا ہے۔ Tasks قطار میں ڈالے جاتے ہیں اور الگ الگ **worker** processes کے ذریعے asynchronously پروسیس کیے جاتے ہیں۔

## وہ مسئلہ جسے 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
```

سست کام کو inline کرنے سے صارفین کو انتظار کرنا پڑتا ہے اور request timeouts کا خطرہ ہوتا ہے۔ Celery اسے background workers کو منتقل کر دیتا ہے تاکہ request فوری واپس آ جائے۔

## Celery task کو define اور call کرنا

```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` decorator ایک task کو define کرتا ہے؛ `.delay()` (یا `.apply_async()`) اسے worker کے ذریعے asynchronously پروسیس کرنے کے لیے queue میں ڈالتا ہے — view انتظار نہیں کرتا۔

## Architecture

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

## Scheduled / periodic tasks (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
    },
}
```

## Reliability features

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

## اہمیت

Celery کے ساتھ background task processing responsive، scalable Django applications بنانے کے لیے ضروری علم ہے، کیونکہ بہت سی حقیقی دنیا کی ضروریات کے لیے ایسے کام کی ضرورت ہوتی ہے جو request کے دوران inline نہیں ہونا چاہیے۔

اس کو سمجھنا اہم ہے کیونکہ بنیادی مسئلہ — سست یا deferred کام (ای میلز بھیجنا، تصاویر/فائلیں پروسیس کرنا، رپورٹس تیار کرنا، سست بیرونی APIs کو کال کرنا، ڈیٹا syncing) کو request-response cycle سے منتقل کرنا — production applications میں ہر جگہ موجود ہے۔

ایسے کام کو inline کرنے سے صارفین کو انتظار کرنا پڑتا ہے، request timeouts کا خطرہ ہوتا ہے، اور ناکام ہونے پر کام ضائع ہو جاتا ہے، جبکہ **Celery** آپ کو صارف کو فوری جواب دینے دیتا ہے جبکہ الگ الگ **workers** کام کو asynchronously اور قابل اعتماد طریقے سے پروسیس کرتے ہیں۔

سادہ async offloading سے ہٹ کر، Celery اہم production صلاحیتیں فراہم کرتا ہے: **scheduled/periodic tasks** (Celery Beat کے ذریعے، cron کو بدلتے ہوئے application-level scheduling کے لیے — روزانہ کی رپورٹس، صفائی کی jobs، بار بار ہونے والی syncs)، **automatic retries with backoff** (عارضی ناکامیوں کے خلاف resilience)، **task persistence** (queued tasks broker کے ذریعے restarts سے بچ جاتے ہیں، تو کام ضائع نہیں ہوتا)، اور web servers سے workers کی **independent scaling**۔

Celery کی architecture کو سمجھنا (broker جیسے Redis/RabbitMQ queue کو رکھتے ہوئے، workers tasks کو پروسیس کرتے ہوئے، result backend)، tasks کو کیسے define اور queue کریں (`@shared_task`, `.delay()`)، periodic work کو schedule کریں، اور reliability features کو configure کریں، production Django systems بنانے کے لیے قیمتی senior-level علم ہے جو بھاری یا deferred کام کو gracefully ہینڈل کرتے ہیں۔

کیونکہ background processing responsive، robust applications کے لیے ایک عام، اہم ضرورت ہے — اور Celery Django ecosystem میں de facto معیاری حل ہے — اسے master کرنا ایک عملی، اکثر متعلقہ مہارت ہے جو سادہ synchronous request handling سے ہٹ کر حقیقی دنیا کے Django applications کو design کرنے کی صلاحیت کو ظاہر کرتی ہے۔