आप मजबूत पार्श्वभूमी कार्य (Celery/ARQ) कैसे चलाते हैं?

Question

Accepted Answer

**मजबूत, टिकाऊ पार्श्वभूमी कार्यों के लिए** (FastAPI के हल्के `BackgroundTasks` से परे), आप एक वास्तविक कार्य कतार का उपयोग करते हैं: **Celery** (स्थापित मानक) या **ARQ** (आधुनिक async-native कतार)। ये Redis जैसे ब्रोकर द्वारा समर्थित अलग कार्य प्रक्रियाओं में भारी, पुनः प्रयास्य, अनुसूचित कार्य चलाते हैं।

## यह महत्वपूर्ण क्यों है

```text
BackgroundTasks runs in the web process → NO persistence (lost on crash), NO retries,
NO scheduling, and heavy work ties up the worker. Fine only for quick fire-and-forget.
For durable/critical/heavy/scheduled jobs → use a real task queue (Celery / ARQ).
```

## Celery — कार्यों को परिभाषित और कतार में रखें

```python
# tasks.py
from celery import Celery
celery_app = Celery("tasks", broker="redis://localhost:6379")

@celery_app.task(bind=True, max_retries=3)
def process_video(self, video_id: int):
    try:
        do_heavy_processing(video_id)        # runs in a WORKER, not the web process
    except Exception as exc:
        raise self.retry(exc=exc, countdown=60)   # automatic retry on failure
```

```python
# in a FastAPI endpoint — QUEUE the task, return immediately
@app.post("/videos/{id}/process")
def process(id: int):
    process_video.delay(id)                  # enqueue → returns at once (doesn't block)
    return {"status": "processing started"}
# run workers separately: celery -A tasks worker
```

एंडपॉइंट कार्य को कतार में रखता है और तुरंत प्रतिक्रिया देता है; एक अलग **कार्यकर्ता** प्रक्रिया इसे दृढ़ता और पुनः प्रयासों के साथ निष्पादित करती है।

## ARQ — async-native (FastAPI के async मॉडल के अनुसार)

```python
# ARQ is built on asyncio — a natural fit for async FastAPI codebases
async def process_video(ctx, video_id: int):
    await do_async_processing(video_id)

# enqueue from an endpoint
await redis.enqueue_job("process_video", video_id)
```

ARQ एक हल्का, async-पहले विकल्प है — आकर्षक जब आपका कोडबेस पहले से ही async हो।

## वास्तविक कार्य कतार क्या प्रदान करती है

```text
✓ Persistence — jobs survive crashes/restarts (stored in the broker)
✓ Retries with backoff — resilience against transient failures
✓ Scheduling — periodic/cron-like jobs (Celery Beat)
✓ Distribution & scaling — workers scale independently of the web servers
✓ Concurrency & rate limiting, task routing/priorities, result tracking
```

## यह महत्वपूर्ण क्यों है

मजबूत पार्श्वभूमी कार्यों को चलाना उत्पादन-ग्रेड FastAPI अनुप्रयोगों के निर्माण के लिए आवश्यक है जो भारी या स्थगित कार्य को विश्वसनीय रूप से संभालते हैं — और यह समझना कि वास्तविक कार्य कतार कब और कैसे उपयोग करें, महत्वपूर्ण वरिष्ठ-स्तर का ज्ञान है।

मुख्य निर्णय **`BackgroundTasks` की सीमाओं** (कोई दृढ़ता, पुनः प्रयास, या शेड्यूलिंग नहीं — केवल तेजी से, गैर-महत्वपूर्ण कार्य के लिए ठीक है) को स्वीकार करना और **Celery या ARQ** की ओर रुख करना है जब कार्य टिकाऊ, पुनः प्रयास्य, अनुसूचित, भारी, या वितरित होना चाहिए (फाइलें/वीडियो प्रसंस्करण, बल्क ईमेल भेजना, डेटा सिंक्रोनाइज़ेशन, रिपोर्ट जनरेशन)।

ये कतारें महत्वपूर्ण उत्पादन क्षमताएं प्रदान करती हैं: **दृढ़ता** (ब्रोकर के माध्यम से कार्य दुर्घटनाओं से बचते हैं, इसलिए कार्य खो नहीं जाता है), **स्वचालित पुनः प्रयास** (क्षणिक विफलताओं के खिलाफ लचीलापन), **शेड्यूलिंग** (आवधिक कार्य), और **वेब सर्वर से कार्यकर्ताओं का स्वतंत्र स्केलिंग**।

कार्यों को परिभाषित और कतार में रखने का तरीका (Celery की `.delay()`, ARQ का async-native API), आर्किटेक्चर (ब्रोकर + कार्यकर्ता), और विशेष रूप से **वास्तविक कतार बनाम `BackgroundTasks` का उपयोग करने का निर्णय**, विश्वसनीय अनुप्रयोगों को तैयार करने के लिए मूल्यवान है जो भारी कार्य को बिना खोए ऑफलोड करते हैं — एक सामान्य, महत्वपूर्ण आवश्यकता जो मजबूत उत्पादन प्रणालियों को नाजुक प्रणालियों से अलग करती है।