როგორ გაუშვებთ ფონური ამოცანებს 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 ის ფონურ worker-ებზე გადატვირთავს, ამიტომ მოთხოვნა დაუყოვნებლივ უბრუნდება.

## 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-ის ასინქრონული დამუშავებისთვის — ხედი არ ელის.

## არქიტექტურა

```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** გაძლევთ მოთხოვნის დაუყოვნებელი უბრუნებლობის შესაძლებლობას, ხოლო ცალკეულ **worker-ებს** ასინქრონულად და საიმედოდ ამუშავებს სამუშაოს.

მარტივი ასინქრონული გადატვირთვის მიღმა, Celery საწარმო გაწვდის კრიტიკულ შესაძლებლობებს: **დაგეგმილი/პერიოდული ამოცანები** (Celery Beat-ის მეშვეობით, cron-ის ჩანაცვლება აპლიკაციის დონის გეგმაგამკეთებლობისთვის — დღიური ანგარიშები, გაწმენდის ამოცანები, განმეორებადი სინქრონიზაციები), **ავტომატური ხელახლა მცდელობები უკან აღნგრევით** (წინააღმდეგობა ტრანზიენტული წარუმატებლობის წინააღმდეგ), **ამოცანის დაკოპირება** (რიგში დებული ამოცანები გადაცემის მাშინებით გადარჩება, ამიტომ სამუშაო არ იკარგება), და **worker-ების დამოუკიდებელი მასშტაბირება** ვებ-სერვერებიდან.

Celery-ის არქიტექტურის გაგება (ბროკერი როგორიცაა Redis/RabbitMQ რიგის ფლობის საშუალებით, worker-ები ამოცანების დამუშავება, შედეგის ბეკენდი), თუ როგორ განსაზღვროთ და რიგში დაუთეთ ამოცანები (`@shared_task`, `.delay()`), პერიოდული სამუშაოს დაგეგმვა და საიმედოობის მახასიათებლების კონფიგურირება არის ღირებული უფროსი დონის ცოდნა Django სისტემების აგებისთვის, რომელიც მძიმე ან შეფერხებული სამუშაოს შოვნელი.

ვინაიდან ფონური დამუშავება არის ხშირი, მნიშვნელოვანი მოთხოვნა რეაქტიული, მყარი აპლიკაციებისთვის — და Celery არის ფაქტო სტანდარტული გადაწყვეტა Django ეკოსისტემაში — მასში ოსტატობა პრაქტიკული, ხშირად რელევანტური უნარი, რომელიც ფლობს რეალური სამყაროს Django აპლიკაციების არქიტექტურის უნარს გარკვეული სინქრონული მოთხოვნის დამუშავების მიღმა.