तुम्ही Celery सह बॅकग्राउंड कार्य कसे चलवता?

Question

Accepted Answer

**Celery** हा Django मध्ये **बॅकग्राउंड आणि शेड्यूल केलेल्या कार्य** चलवण्यासाठी मानक साधन आहे — असे कार्य जे HTTP विनंती अवरोधित करू नये (ईमेल पाठवणे, फाइली प्रक्रिया करणे, संस्था API कॉल करणे) किंवा जे वेळापत्रकानुसार चलते. कार्य रांगेत असतात आणि स्वतंत्र **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
```

सावकाशीच काम इनलाइन केल्याने वापरकर्त्यांना प्रतीक्षा करावी लागते आणि विनंती timouts चे जोखीम असते. 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 अनुप्रयोग तयार करण्यासाठी आवश्यक ज्ञान आहे, कारण अनेक वास्तविक-जगातील गरजा विनंती-प्रतिसाद चक्रादरम्यान इनलाइन न घडणारे कार्य आवश्यक आहेत.

त्यास समजणे महत्वाचे आहे कारण मूळ समस्या — संस्था API कॉल करणे, संस्था प्रक्रिया करणे, प्रतिवेदन तयार करणे, संस्था सिंक करणे या मंद किंवा स्थगित कार्य (ईमेल पाठवणे, चित्र/फाइली प्रक्रिया करणे) विनंती-प्रतिसाद चक्रातून हस्तांतरित करणे — उत्पादन अनुप्रयोगांमध्ये सर्वव्यापी आहे.

असे कार्य इनलाइन केल्याने वापरकर्त्यांना प्रतीक्षा करावी लागते, विनंती timouts चे जोखीम असते आणि विफल झाल्यास कार्य गमावले जाते, तर **Celery** तुम्हाला वापरकर्त्यांना लगेच प्रतिसाद देऊ देते जेव्हा स्वतंत्र **workers** कार्य अतुल्यकालीनरित्या आणि विश्वसनीयरित्या प्रक्रिया करते.

सोप्या अतुल्यकालीन हस्तांतरणाच्या पलीकडे, Celery महत्त्वपूर्ण उत्पादन क्षमता प्रदान करते: **शेड्यूल केलेले/नियतकालिक कार्य** (Celery Beat द्वारे, cron ला अनुप्रयोग-स्तरीय शेड्यूलिंग साठी बदलणे — दैनिक प्रतिवेदन, स्वच्छता कार्य, आवर्ती syncs), **स्वयंचलित retrys backoff सह** (क्षणिक विफलता विरुद्ध लचकीपणा), **कार्य स्थिरता** (रांगेत असलेली कार्ये broker द्वारे restarts ला टिकून राहतात, म्हणून कार्य गमावले जात नाही), आणि **स्वतंत्र स्केलिंग** वेब सर्व्हरपासून workers.

Celery च्या आर्किटेक्चर (Redis/RabbitMQ सारख्या broker रांग धारण करणे, कार्य प्रक्रिया करणारे workers, परिणाम backend), कार्य परिभाषित आणि रांगेत कसे घालायचे (`@shared_task`, `.delay()`), नियतकालिक कार्य शेड्यूल करणे, आणि विश्वसनीयता वैशिष्ट्ये कॉन्फिगर करणे समजणे हे उत्पादन Django प्रणाली तयार करण्यासाठी मूल्यवान senior-level ज्ञान आहे जे मोठे किंवा स्थगित कार्य सुंदरपणे हाताळते.

कारण बॅकग्राउंड प्रक्रिया हे प्रतिक्रियाशील, मजबूत अनुप्रयोगांसाठी एक सामान्य, महत्त्वाचे आवश्यकता आहे — आणि Celery हा Django ecosystem मध्ये de facto मानक उपाय आहे — हे आयत्त करणे हे व्यावहारिक, वारंवार-संबंधित कौशल्य आहे जे साधारण synchronous विनंती हाताळणीच्या पलीकडे वास्तविक-जगातील Django अनुप्रयोग संरचित करण्याची क्षमता प्रतिबिंबित करते.