आप Celery के साथ background tasks कैसे चलाते हैं?

Question

Accepted Answer

**Celery** Django में **background और scheduled tasks** चलाने के लिए standard tool है — ऐसा काम जो HTTP request को block नहीं करना चाहिए (emails भेजना, files process करना, slow APIs call करना) या जो एक schedule पर चलता है। Tasks को queue किया जाता है और अलग **worker** processes द्वारा asynchronously process किया जाता है।

## जिस समस्या को 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
```

Slow काम को inline करना users को प्रतीक्षा कराता है और request timeouts का जोखिम पैदा करता है। Celery इसे background workers को सौंप देता है ताकि request तुरंत return हो जाए।

## एक 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 process करने के लिए 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 बनाने के लिए आवश्यक ज्ञान है, क्योंकि कई वास्तविक-दुनिया की needs को ऐसे काम की आवश्यकता होती है जो request के दौरान inline नहीं होना चाहिए।

इसे समझना महत्वपूर्ण है क्योंकि मुख्य समस्या — slow या deferred काम (emails भेजना, images/files process करना, reports generate करना, slow external APIs call करना, data syncing) को request-response cycle से offload करना — production applications में सर्वव्यापी है।

ऐसे काम को inline करना users को प्रतीक्षा कराता है, request timeouts का जोखिम पैदा करता है, और यदि यह विफल हो जाए तो काम खो देता है, जबकि **Celery** आपको user को तुरंत respond करने देता है जबकि अलग **workers** काम को asynchronously और reliably process करते हैं।

सरल async offloading से परे, Celery महत्वपूर्ण production capabilities प्रदान करता है: **scheduled/periodic tasks** (Celery Beat के माध्यम से, application-level scheduling के लिए cron की जगह — daily reports, cleanup jobs, recurring syncs), **automatic retries with backoff** (transient failures के विरुद्ध resilience), **task persistence** (queued tasks broker के माध्यम से restarts में बच जाते हैं, इसलिए काम खोता नहीं), और web servers से workers की **independent scaling**।

Celery की architecture (queue रखने वाला Redis/RabbitMQ जैसा broker, tasks process करने वाले workers, result backend) को समझना, tasks को define और queue कैसे करें (`@shared_task`, `.delay()`), periodic काम को schedule कैसे करें, और reliability features को configure कैसे करें, यह production Django systems बनाने के लिए मूल्यवान senior-level ज्ञान है जो heavy या deferred काम को graceful ढंग से handle करते हैं।

क्योंकि background processing responsive, robust applications के लिए एक आम, महत्वपूर्ण आवश्यकता है — और Celery Django ecosystem में de facto standard समाधान है — इसमें महारत हासिल करना एक व्यावहारिक, अक्सर प्रासंगिक skill है जो सरल synchronous request handling से परे वास्तविक-दुनिया की Django applications को architect करने की क्षमता को दर्शाती है।