Conas a ritheann tú tasc sa chúlra le Celery?

Question

Accepted Answer

**Celery** is the standard tool for running **background and scheduled tasks** in Django — work that shouldn't block the HTTP request (sending emails, processing files, calling slow APIs) or that runs on a schedule. Tasks are queued and processed asynchronously by separate **worker** processes.

## An fhadhb a réitíonn 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
```

Déanann obair dhian a bheith ar siúl go seamhach na fiontraithe a bheith ag feitheamh agus baol ann go gcaillfi a bhreacadh. Tugann Celery an obair ar shiúl chuig oibrithe sa chúlra ionas go bhfillfidh an t-iarratas ar an toirt.

## Tasc Celery a shainiú agus a ghlaoch

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

Saineann an taifeadóir `@shared_task` tasc; tugann `.delay()` (nó `.apply_async()`) fhilíochán dó do oibrí a dhéileáil leis go neamhshéalaíoch — ní fheitheann an radharc.

## An ailtireacht

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

## Tasc fochéimeanna / tréimhseacha (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
    },
}
```

## Gnéithe iontaobhais

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

## Cén fáth a bhíonn sé i gceist

Tá próiseáil thasc cúlra le Celery i riachtanas ar bhealach go bhfuil eolas ar leith ag teastáil maidir le feidhmchlár Django a bhith freagarthach agus inscálaithe a thógáil, ós rud é go bhfuil go leor riachtanas an domhain fíor-fhéadfaidh gur gá obair nach dtarlaíonn ar líne i gcaitheamh iarratas.

Tá sé tábhachtach go dtuigeann tú é toisc go bhfuil an fhadhb bhunúsach ann — obair dhian nó fhonnraichte (ríomhphost a sheoladh, íomhánna/comhaid a phróiseáil, tuarascálacha a ghiniúint, APIanna seachtracha mall a ghlaoch, sioncronú sonraí) a bhogadh ar fhad an timthriall freagairt-iarratas — coitianta i feidhmchláir dhíolúnta.

Déanann a leithéid d'obair a bheith ar siúl go seamhach na fiontraithe a bheith ag feitheamh, baol ann go gcaillfi a bhreacadh agus cailltear an obair más éigeantach, agus tugann **Celery** ar an úsáideoir a bhreacadh ar an toirt agus ag próiseáil oibrithe neamhspleácha an obair go neamhshéalaíoch agus go hiontaofa.

I bhfad ó oiriúint shimplí neamhshéalaíoch, soláthraíonn Celery cumais thábhachtach gairm: **tasc fochéimeanna/tréimhseacha** (trí Celery Beat, a athchur ar leataobh chun cron maidir le sceidealú leibhéal feidhmchlár — tuarascálacha laethúla, poist ghlanadh, sioncronú athfhillte), **atrialtaí uathoibríoch le cúltaca** (friotaíochta i gcoinne fhailltí neamhbhuan), **seasmhachta tasc** (fianáin oibrithe sa bhróicéir, ionas nach gcailltear obair), agus **scálú neamhspleách** oibrithe ó dhréim-fheidhmchláraí.

Is eolas ar leibhéal sinsir a bhíonn i gceist maidir le tuiscint ar ailtireacht Celery (an bróicéir cosúil le Redis/RabbitMQ a bhíonn ann an fhilíochán, oibrithe ag próiseáil tasc, an torthaí siar), conas tasc a shainiú agus a fhilíochán (`@shared_task`, `.delay()`), obair tréimhseach a sceidealú, agus gnéithe iontaobhais a chur i bhfeidhm, tá sé baileach do bhealach feidhmchláir Django geirm a thógáil a dhéileálann le hobair throm nó fhonnraichte go deas.

Toisc gur riachtanas coitianta, tábhachtach é próiseáil chúlra maidir le feidhmchlár freagarthach, docht — agus is Celery an réiteach caighdeánaithe de facto san spásúchán Django — is scil phraiticiúil, inchuimhneoirí rialta a bhíonn ann maidir le rialúchán, a fhreagraíonn don spéis go bhíonn ann maidir le bealach feidhmchláir Django a ailtireachta taobh amuigh de láimhseáil neamhshéalaíoch shimplí.