Kako pokrenuti robusne background poslove (Celery/ARQ)?

Question

Accepted Answer

Za **robusne, trajne background poslove** (izvan FastAPI-jeve lagane `BackgroundTasks`), koristiš pravi task queue: **Celery** (utvrđeni standard) ili **ARQ** (moderan async-nativan queue). Oni izvršavaju teške, pokušive, zakazane poslove u odvojenim worker procesima, poduprte brokerom kao što je Redis.

## Zašto ne samo BackgroundTasks?

```text
BackgroundTasks runs in the web process → NO persistence (lost on crash), NO retries,
NO scheduling, and heavy work ties up the worker. Fine only for quick fire-and-forget.
For durable/critical/heavy/scheduled jobs → use a real task queue (Celery / ARQ).
```

## Celery — definiraj i stavi u red čekanja

```python
# tasks.py
from celery import Celery
celery_app = Celery("tasks", broker="redis://localhost:6379")

@celery_app.task(bind=True, max_retries=3)
def process_video(self, video_id: int):
    try:
        do_heavy_processing(video_id)        # runs in a WORKER, not the web process
    except Exception as exc:
        raise self.retry(exc=exc, countdown=60)   # automatic retry on failure
```

```python
# in a FastAPI endpoint — QUEUE the task, return immediately
@app.post("/videos/{id}/process")
def process(id: int):
    process_video.delay(id)                  # enqueue → returns at once (doesn't block)
    return {"status": "processing started"}
# run workers separately: celery -A tasks worker
```

Endpoint stavlja posao u red čekanja i odmah odgovara; odvojeni **worker** proces ga izvršava s trajnošću i pokušajima.

## ARQ — async-nativan (odgovara FastAPI-jevom async modelu)

```python
# ARQ is built on asyncio — a natural fit for async FastAPI codebases
async def process_video(ctx, video_id: int):
    await do_async_processing(video_id)

# enqueue from an endpoint
await redis.enqueue_job("process_video", video_id)
```

ARQ je lakši, async-first alternativ — privlačan kada je tvoj kod već async.

## Što pravi task queue pruža

```text
✓ Persistence — jobs survive crashes/restarts (stored in the broker)
✓ Retries with backoff — resilience against transient failures
✓ Scheduling — periodic/cron-like jobs (Celery Beat)
✓ Distribution & scaling — workers scale independently of the web servers
✓ Concurrency & rate limiting, task routing/priorities, result tracking
```

## Zašto je važno

Pokretanje robusnih background poslova je bitno za građu production-grade FastAPI aplikacija koje pouzdano rukovode teškim ili odloženim poslovima — i razumijevanje kada i kako koristiti pravi task queue važno je znanje na razini seniora.

Jezgra razmatranja je prepoznavanje **ograničenja `BackgroundTasks`** (nema trajnosti, pokušaja ili planiranja — dobro samo za brze, nekritične poslove) i pribjegavanje **Celery ili ARQ** kada posao mora biti trajan, pokušiv, planiran, teški ili distribuiran (obrada datoteka/videa, slanje masovnih e-poruka, sinkronizacija podataka, generiranje izvještaja).

Ovi queuei pružaju kritične production mogućnosti: **trajnost** (poslovi prežive rušenja kroz broker, tako da se rad ne gubi), **automatski pokušaji** (otpornost prema privremenim neuspjesima), **planiranje** (periodički poslovi) i **neovisno skaliranje** workera od web poslužitelja.

Znati kako definirati i staviti u red čekanja poslove (Celery-jevo `.delay()`, ARQ-ov async-nativan API), arhitekturu (broker + workeri) i posebno **odluku kada koristiti pravi queue naspram BackgroundTasks**, vrijedno je za arhitekturu pouzdanih aplikacija koje prebacuju teške poslove bez gubitka — čestu, važnu zahtjev koji razlikuje robusne production sustave od fragilinih.