ਤੁਸੀਂ Celery ਨਾਲ ਬੈਕਗ੍ਰਾਉਂਡ ਟਾਸਕ ਕਿਵੇਂ ਚਲਾਉਂਦੇ ਹੋ?

Question

Accepted Answer

**Celery** Django ਵਿੱਚ **ਬੈਕਗ੍ਰਾਉਂਡ ਅਤੇ ਸਮਾਂਤਵੀ ਕੰਮ** ਚਲਾਉਣ ਲਈ ਸਟੈਂਡਰਡ ਟੂਲ ਹੈ — ਉਹ ਕੰਮ ਜੋ HTTP ਬੇਨਤੀ ਨੂੰ ਰੋਕ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ (ਈਮੇਲਾਂ ਭੇਜਣਾ, ਫਾਇਲਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ, ਹੌਲੀ APIs ਨੂੰ ਕਾਲ ਕਰਨਾ) ਜਾਂ ਜੋ ਇੱਕ ਸ਼ਿਡਿਊਲ ਉੱਪਰ ਚਲਦਾ ਹੈ। ਟਾਸਕ ਕਿਊ ਵਿੱਚ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ **worker** ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੁਆਰਾ ਅਸਮਾਨਤਾਤਮਕ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਕਿਰਿਆ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

## ਸਮੱਸਿਆ ਜੋ 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
```

ਹੌਲੀ ਕੰਮ ਨੂੰ ਇਨਲਾਈਨ ਕਰਨਾ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਰੁਕਣ ਦਿੰਦਾ ਹੈ ਅਤੇ ਬੇਨਤੀ ਟਾਈਮਆਉਟ ਦੇ ਖਤਰੇ ਵਿੱਚ ਪਾਉਂਦਾ ਹੈ। Celery ਇਸਨੂੰ ਬੈਕਗ੍ਰਾਉਂਡ workers ਵਿੱਚ ਭੇਜ ਦਿੰਦਾ ਹੈ ਤਾਂ ਕਿ ਬੇਨਤੀ ਤੁਰੰਤ ਵਾਪਸ ਆ ਸਕੇ।

## Celery ਟਾਸਕ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਅਤੇ ਕਾਲ ਕਰਨਾ

```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` ਡੈਕੋਰੇਟਰ ਇੱਕ ਟਾਸਕ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ; `.delay()` (ਜਾਂ `.apply_async()`) ਇਸਨੂੰ ਇੱਕ worker ਦੁਆਰਾ ਅਸਮਾਨਤਾਤਮਕ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ ਕਿਊ ਵਿੱਚ ਰੱਖਦਾ ਹੈ — ਵਿਊ ਉਡੀਕ ਨਹੀਂ ਕਰਦਾ।

## ਆਰਕੀਟੈਕਚਰ

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

## ਸਮਾਂਤਵੀ / ਨਿਯਮਿਤ ਕੰਮ (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
    },
}
```

## ਭਰੋਸੇਯੋਗਤਾ ਫੀਚਰਾਂ

```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 ਦੇ ਨਾਲ ਬੈਕਗ੍ਰਾਉਂਡ ਟਾਸਕ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ, ਸਕੇਲਿਬਲ Django ਐਪਲੀਕੇਸਨਾਂ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਗਿਆਨ ਹੈ, ਕਿਉਂਕਿ ਬਹੁਤ ਸਾਰੀਆਂ ਵਾਸਤਵਿਕ ਲੋੜਾਂ ਨੂੰ ਅਜਿਹੇ ਕੰਮ ਦੀ ਲੋੜ ਹੈ ਜੋ ਇਨਲਾਈਨ ਦੌਰਾਨ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ।

ਇਹ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਮੁੱਖ ਸਮੱਸਿਆ — ਹੌਲੀ ਜਾਂ ਸਥਗਿਤ ਕੰਮ (ਈਮੇਲਾਂ ਭੇਜਣਾ, ਚਿੱਤਰ/ਫਾਇਲਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ, ਰਿਪੋਰਟਾਂ ਜਾਰੀ ਕਰਨਾ, ਹੌਲੀ ਬਾਹਰੀ APIs ਨੂੰ ਕਾਲ ਕਰਨਾ, ਡਾਟਾ ਸਿੰਕ ਕਰਨਾ) ਨੂੰ ਬੇਨਤੀ-ਪ੍ਰਤੀਸਾਡ ਸਾਈਕਲ ਤੋਂ ਬਾਹਰ ਕੱਢਣਾ — ਪ੍ਰੋਡਕਸ਼ਨ ਐਪਲੀਕੇਸਨਾਂ ਵਿੱਚ ਸਰਵਵਿਆਪੀ ਹੈ।

ਅਜਿਹਾ ਕੰਮ ਇਨਲਾਈਨ ਕਰਨਾ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਰੁਕਣ ਦਿੰਦਾ ਹੈ, ਬੇਨਤੀ ਟਾਈਮਆਉਟ ਦੇ ਖਤਰੇ ਵਿੱਚ ਪਾਉਂਦਾ ਹੈ, ਅਤੇ ਅਸਫਲ ਹੋਣ 'ਤੇ ਕੰਮ ਗੁਆ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ **Celery** ਤੁਹਾਨੂੰ ਤੁਰੰਤ ਉਪਭੋਗਤਾ ਨੂੰ ਜਵਾਬ ਦੇਣ ਦਿੰਦਾ ਹੈ ਜਦੋਂ ਵੱਖ-ਵੱਖ **workers** ਕੰਮ ਨੂੰ ਅਸਮਾਨਤਾਤਮਕ ਅਤੇ ਭਰੋਸੇਮੰਦ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਕਿਰਿਆ ਕਰਦੇ ਹਨ।

ਸਧਾਰਨ ਅਸਮਾਨਤਾਤਮਕ ਵਿਸਥਾਪਨ ਤੋਂ ਅੱਗੇ, Celery ਮਹੱਤਵਪੂਰਨ ਪ੍ਰੋਡਕਸ਼ਨ ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ: **ਸ਼ਿਡਿਊਲ ਕੀਤੇ/ਨਿਯਮਿਤ ਕੰਮ** (Celery Beat ਦੁਆਰਾ, cron ਨੂੰ ਐਪਲੀਕੇਸ਼ਨ-ਪੱਧਰ ਸ਼ਿਡਿਊਲਿੰਗ ਲਈ ਬਦਲਦੇ ਹੋਏ — ਰੋਜ਼ਾਨਾ ਰਿਪੋਰਟਾਂ, ਸਫ਼ਾਈ ਨੌਕਰੀਆਂ, ਆਵਰਤੀ ਸਿੰਕ), **ਬੈਕਆਫ ਦੇ ਨਾਲ ਸਵੈ-ਚਾਲਿਤ ਮੁੜ-ਕੋਸ਼ਿਸ਼ਾਂ** (ਅਸਥਾਈ ਅਸਫਲਤਾਵਾਂ ਵਿਰੁੱਧ ਲਚਕ), **ਟਾਸਕ ਸਥਿਤੀ** (ਕਿਊ ਵਿੱਚ ਕੀਤੇ ਗਏ ਕੰਮ ਬ੍ਰੋਕਰ ਦੁਆਰਾ ਜਾਰੀ ਰਹਿੰਦੇ ਹਨ, ਇਸ ਲਈ ਕੰਮ ਗੁਆ ਨਹੀਂ ਜਾਂਦਾ), ਅਤੇ **ਵੈੱਬ ਸਰਵਰਾਂ ਤੋਂ workers ਦੀ ਸੁਤੰਤਰ ਸਕੇਲਿੰਗ**।

Celery ਦੀ ਆਰਕੀਟੈਕਚਰ (broker ਜਿਵੇਂ Redis/RabbitMQ ਕਿਊ ਰੱਖਦੇ ਹੋਏ, workers ਕੰਮ ਪ੍ਰਕਿਰਿਆ ਕਰਦੇ ਹੋਏ, result backend), ਕਿਵੇਂ ਟਾਸਕ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਅਤੇ ਕਿਊ ਕਰਨਾ ਹੈ (`@shared_task`, `.delay()`), ਨਿਯਮਿਤ ਕੰਮ ਨੂੰ ਸ਼ਿਡਿਊਲ ਕਰਨਾ, ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ ਫੀਚਰਾਂ ਨੂੰ ਸੰਜੋ ਕਰਨਾ ਸਮਝਣਾ ਪ੍ਰੋਡਕਸ਼ਨ Django ਪ੍ਰਣਾਲੀਆਂ ਬਣਾਉਣ ਲਈ ਸਹਾਏਕ-ਸਤਰ ਦਾ ਮੂਲਯਵਾਨ ਗਿਆਨ ਹੈ ਜੋ ਭਾਰੀ ਜਾਂ ਸਥਗਿਤ ਕੰਮ ਨੂੰ ਸੁਕੋਮਲ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲਦੇ ਹਨ।

ਕਿਉਂਕਿ ਬੈਕਗ੍ਰਾਉਂਡ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ, ਮਜ਼ਬੂਤ ਐਪਲੀਕੇਸਨਾਂ ਲਈ ਇੱਕ ਆਮ, ਮਹੱਤਵਪੂਰਨ ਲੋੜ ਹੈ — ਅਤੇ Celery Django ਈਕੋਸਿਸਟਮ ਵਿੱਚ ਡਿ ਫੈਕਟੋ ਮਿਆਰੀ ਹੱਲ ਹੈ — ਇਸਨੂੰ ਮਾਹਰ ਬਣਾਉਣਾ ਇੱਕ ਵਿਹਾਰਕ, ਆਵਰਤੀ-ਪ੍ਰਸੰਗਿਕ ਕੌਸ਼ਲ ਹੈ ਜੋ ਸਧਾਰਨ ਸਮਕਾਲੀ ਬੇਨਤੀ ਹੈਂਡਲਿੰਗ ਤੋਂ ਪਰੇ ਵਾਸਤਵਿਕ-ਵਿਸ਼ਵ Django ਐਪਲੀਕੇਸਨਾਂ ਨੂੰ ਆਰਕੀਟੈਕਟ ਕਰਨ ਦੀ ਯੋਗਤਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।