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

மெதுவான வேலையை உள்நுழைவில் செய்வது பயனர்களை காத்திருக்க வைக்கிறது மற்றும் கோரிக்கை timeout ஐயின் ஆபத்து ஏற்படுத்துகிறது. 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` decorator ஒரு பணியை வரையறுக்கிறது; `.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 பயன்பாடுகளை கட்டமைப்பதற்கு அপরिहार்य அறிவாகும், ஏனெனில் பல நட்பு பயன்பாடுகளுக்கு கோரிக்கையின் போது உள்நுழைவில் நிகழக்கூடாத வேலை தேவைப்படுகிறது.

এটি புரிந்துகொள்வது முக்கியமாகும் என்பதன் காரணம் — மெதுவான அல்லது ஒতுக்கப்பட்ட வேலை (மின்னஞ்சல்களை அனுப்புதல், படங்கள்/கோப்புகளை செயல்படுத்துதல், அறிக்கைகளை உৎপন்നம் செய்தல், மெதுவான வெளிப்புற API களை அழைப்பது, தரவு ஒத்திசைவாக்குதல்) கோரிக்கை-பதில் சுழற்சியிலிருந்து மாற்றுவதாகும் — இது உৎபாদன பயன்பாடுகளில் எங்கும் இருக்கிறது.

தத்போஜ்னாய வேலை உள்நுழைவில் பயனர்களை காத்திருக்க வைக்கிறது, கோரிக்கை timeout ஐயின் ஆபத்து ஏற்படுத்துகிறது, மற்றும் அது தோல்வியடைந்தால் வேலை இழக்கப்படுகிறது, அதேசமயம் **Celery** உங்களை உடனடியாக பயனரிடம் பதிலளிக்க அனுமதிக்கிறது அதே சமயம் தனி **workers** பணிகளை ஒத்திசைவற்ற மற்றும் நம்பகமாக செயல்படுத்துகிறது.

சாধாரண ஒத்திசைவற்ற ஆஃப்லோடிங்குக்கு அப்பால், Celery முக்கியமான உৎபாദன திறன்களை வழங்குகிறது: **திட்டமிடப்பட்ட/குறிப்பிடப்பட்ட பணிகள்** (Celery Beat மூலம், வேண்டப்பட்ட cron ஐ பயன்பாட்டு-மட்ட திட்டமிடலுக்கு மாற்றுதல் — தினசரி அறிக்கைகள், পরிசுத்தத்திறப் பணிகள், மறுபடி ஒத்திசைவாக்குதல்கள்), **தற்காலிக தோல்விகளுக்கு எதிரான தானியங்கி retry உடன் backoff** (স্থிতিস்থாപकமை), **பணி நிலைத்தன்மை** (வரிசைப்படுத்தப்பட்ட பணிகள் broker மூலம் மீண்டும் தொடக்கத்திற்கு பிந்தியும், எனவே வேலை இழக்கப்படாது), மற்றும் **independent scaling** வலை சேவையகங்களிலிருந்து workers.

Celery இன் கட்டிடக்கலை (Redis/RabbitMQ போன்ற broker வரிசை வைத்திருக்கிறது, workers பணிகளை செயல்படுத்தుகிறது, விளைவு backend), பணிகளை வரையறுக்க மற்றும் வரிசையில் நிற்றுக (`@shared_task`, `.delay()`), குறிப்பிடப்பட்ட வேலைக்கு ஒட்டுசெய்தல், மற்றும் நம்பகத்தன்மை அம்சங்களை மாற்றுவது எவ்வாறு தெரிந்துகொள்வது என்பது உৎপாദன Django அமைப்புகளை உருவாக்குவதற்கான மதிப்பான senior-level அறிவாகும், இது கனமான அல்லது ஒতுக்கப்பட்ட வேலையை gracefully கையாள்கிறது.

பின்னணி செயல்முறை வினைத்திறன்மிக்க, வலுவான பயன்பாடுகளுக்கான பொதுவான, முக்கியமான தேவை என்பதாலும் — மற்றும் Celery Django சுற்றுச்சூழலில் உண்மைக்குரியமான நிலையான தீர்வு — இதை தொழிற்படுத்துவது நடைமுறை, அடிக்கடி-பொருந்தக்கூடிய திறன் யாதாகிறது, இது எளிய ஒத்திசைவான கோரிக்கை கையாளலுக்கு அப்பால் நிஜ-உலக Django பயன்பாடுகளை கட்டிடக்கலை செய்வதற்கான திறனை பிரதிபலிக்கிறது.