તમે 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 દ્વારા અસિંક્રોનસલી પ્રક્રિયા કરવા માટે કતારમાં આવે છે — view રાહ જોતું નથી।

## આર્કિટેક્ચર

```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** કાર્યને અસિંક્રોનસલી અને વિશ્વસનીય રીતે પ્રક્રિયા કરે છે।

સરળ async આગાહીથી આગળ, Celery મહત્વપૂર્ણ ઉત્પાદન ક્ષમતા પ્રદાન કરે છે: **શેડ્યુલ્ડ/સામયિક કાર્યો** (Celery Beat દ્વારા, cron ને બદલીને એપ્લિકેશન-સ્તર શેડ્યુલિંગ — દૈનિક અહેવાલો, સાફાઈ કાર્યો, આવર્તક સિંક્સ), **આપોઆપ પુનઃપ્રયાસ બેકઓફ સાથે** (અસ્થાયી નિષ્ફળતાઓ સામે સ્થિતિસ્થાપકતા), **કાર્ય સ્થાયિત્વ** (કતારબદ્ધ કાર્યો બ્રોકર દ્વારા પુનર્શરૂ થાય છે, તેથી કાર્ય હરાવે નહીં), અને **workers ને web servers થી સ્વતંત્ર માપન**।

Celery આર્કિટેક્ચર (Redis/RabbitMQ જેવું બ્રોકર કતાર ધરી રાખતું, workers કાર્યો પ્રક્રિયા કરતા, પરિણામ બેકએન્ડ), કાર્યો કેવી રીતે વ્યાખ્યાયિત અને કતારમાં આવે છે (`@shared_task`, `.delay()`), સામયિક કાર્ય શેડ્યુલ કરવા, અને વિશ્વસનીયતા વૈશિષ્ટ્યો ગોઠવવા સમજવું ઉત્પાદન Django પ્રણાલીઓ બનાવવા માટે મૂલ્યવાન સિનિયર-સ્તરનું જ્ઞાન છે જે ભારે અથવા સ્થગિત કાર્યને સુંદર રીતે સંભાળે છે।

કારણ કે બેકગ્રાઉન્ડ પ્રક્રિયા પ્રતિક્રિયાશીલ, મજબૂત એપ્લિકેશનો માટે સામાન્ય, મહત્વપૂર્ણ જરૂરિયાત છે — અને Celery Django ઇકોસિસ્ટમમાં વાસ્તવ માનક સમાધાન છે — તેમાં નિપુણતા એક વ્યવહારુ, વારંવાર-સંબંધિત કૌશલ્ય છે જે સરળ સમવર્તી વિનંતી સંભાળણીથી આગળ વાસ્તવિક-વિશ્વ Django એપ્લિકેશનોને આર્કિટેક્ચર કરવાની ક્ષમતા પ્રતિબિંબિત કરે છે।