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

నెమ్మదిగా ఉన్న పని ఇన్‌లైన్‌లో చేయడం వల్ల వినియోగదారులు వేచి ఉండాలి మరియు రిక్వెస్ట్ టైమ్‌అవుట్ రిస్క్ ఉంటుంది. Celery దీన్ని బ్యాకగ్రౌండ్ వర్కర్‌లకు మార్పులు చేస్తుంది కాబట్టి రిక్వెస్ట్ వెంటనే తిరిగి వస్తుంది.

## 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()`) ఒక వర్కర్‌ చే అసమకాలికంగా ప్రాసెస్ చేయడానికి ఇది కాయుగులో చేర్చబడుతుంది — వ్యూ వేచి ఉండదు.

## ఆర్కిటెక్చర్

```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 లను కాల్ చేయడం, డేటా సింకింగ్) రిక్వెస్ట్-రెస్పాన్స్ చక్రం నుండి దూరంగా ఉంచడం — ఉత్పత్తి అనువర్తనాలలో సర్వవ్యాప్తం.

ఇటువంటి పనిని ఇన్‌లైన్‌లో చేయడం వల్ల వినియోగదారులు వేచి ఉండాలి, రిక్వెస్ట్ టైమ్‌అవుట్ రిస్క్ ఉంటుంది, మరియు అది విఫలమైతే పని కోల్పోతుంది, కాని **Celery** వేంటనే వినియోగదారుకు సమాధానం ఇవ్వటానికి మరియు ప్రత్యేక **workers** అసమకాలికంగా మరియు విశ్వస్తతో పనిని ప్రాసెస్ చేయటానికి అనుమతిస్తుంది.

సాధారణ అసమకాలిక ఆఫ్‌లోడింగ్ దాటి, Celery క్రిటికల్ ఉత్పత్తి సామర్థ్యాలను అందిస్తుంది: **షెడ్యూల్‌/ఆవర్తన టాస్క్‌లు** (Celery Beat ద్వారా, cron కు ప్రత్యామ్నాయం అనువర్తనం-స్థర కాలక్రమ సూచన — దైనిక రిపోర్టులు, శుభ్రత పనులు, పునరావృత సింక్‌లు), **బ్యాకాఫ్‌తో స్వయంచాలక పునర్ప్రయత్నాలు** (ఆకస్మిక విఫలతల కు నిరోధకత), **టాస్క్ నిలిపిపెట్టడం** (కాయువ్ చేసిన టాస్క్‌లు బ్రోకర్ ద్వారా రీస్టార్టులను సజీవంగా ఉంచతాయి, కాబట్టి పని కోల్పోదు), మరియు **వర్కర్‌ల నుండి స్వతంత్ర స్కేలింగ్** వెబ్ సర్వర్‌ల నుండి.

Celery ఆర్కిటెక్చర్ (Redis/RabbitMQ వంటి బ్రోకర్ కాయుగు కలిగి ఉండటం, వర్కర్‌లు టాస్క్‌లను ప్రాసెస్ చేయడం, ఫలితం బ్యాకెండ్), టాస్క్‌లను ఎలా నిర్వచించాలి మరియు కాయుగులో చేర్చాలి (`@shared_task`, `.delay()`), ఆవర్తన పని షెడ్యూల్ చేయడం, మరియు విశ్వసనీయత లక్షణాలను ఎలా కాన్ఫిగర్ చేయాలి అని అర్థం చేసుకోవడం ఉత్పత్తి Django సిస్టమ్‌లను నిర్మించటానికి విలువైన సీనియర్-స్థర జ్ఞానం, అవి భారీ లేదా వాయిదా పడిన పనిని సుందరమైనప్పుడు నిర్వహిస్తాయి.

బ్యాకగ్రౌండ్ ప్రాసెసింగ్ రెస్పాన్సివ్, దృఢమైన అనువర్తనాల కోసం సాధారణ, ముఖ్యమైన అవసరం — మరియు Celery Django ఈకోసిస్టమ్‌లో వాస్తవ ప్రమాణ సిద్ధాంతం — దీనిని నైపుణ్యం సాధించడం సరళ సమకాలిక రిక్వెస్ట్ హ్యాండ్‌లింగ్‌కు మించిన వాస్తవ-ప్రపంచ Django అనువర్తనాలను నిర్మించటానికి సామర్థ్యాన్ని ప్రతిబింబిస్తుంది.