तपाईं कसरी मजबूत पृष्ठभूमि कार्य (Celery/ARQ) चलाउनुहुन्छ?

Question

Accepted Answer

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

## BackgroundTasks किन मात्र नहीं?

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

अन्तबिन्दु कार्यलाई कतारबद्ध गरी तत्काल प्रतिक्रिया दिन्छ; एक अलग **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-first विकल्प हो — आकर्षक जब तपाईंको कोडबेस पहिले नै 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 कहिले प्रयोग गर्ने को निर्णय**, विश्वसनीय अनुप्रयोग आर्किटेक्चर गर्नको लागि मूल्यवान छ जो भारी कार्यलाई अलग गर्छ बिना यो हराइएको — एक सामान्य, महत्त्वपूर्ण आवश्यकता जो मजबूत उत्पादन प्रणालीहरूलाई नाजुक प्रणालीहरूबाट अलग गर्छ।