Kako izvajate robustne opravila v ozadju (Celery/ARQ)?

Question

Accepted Answer

Za **robustna, trajno trajdejna opravila v ozadju** (onkraj lahkih `BackgroundTasks` v FastAPI-ju), uporabite pravo čakalno vrsto: **Celery** (uveljavljen standard) ali **ARQ** (moderna asinkrona čakalna vrsta). Ta opravila izvajajo težka, ponovljiva, načrtovana dela v ločenih procesih delavcev, podprta s posrednikom, kot je Redis.

## Zakaj 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 — definirajte in postavite v vrsto opravila

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

Končna točka preusmeri nalogo v vrsto in se takoj odzove; ločen proces **delavca** jo izvršuje s trajnostjo in ponovnimi poskusi.

## ARQ — asinkrona-nativna (ustreza FastAPI 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 lažja, asinkrona-prva alternativa — privlačna, kadar je vaša baza kode že asinkrona.

## Kaj ponuja prava čakalna vrsta

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

## Zakaj je to pomembno

Izvajanje robustnih opravil v ozadju je bistveno za gradnjo proizvodnih FastAPI aplikacij, ki zanesljivo obdelujejo težka ali odložena dela — razumevanje, kdaj in kako uporabiti pravo čakalno vrsto, pa je pomembno znanje na višji ravni.

Srednje sodstvo je zavedanje **omejitev `BackgroundTasks`** (brez trajnosti, ponovnih poskusov ali načrtovanja — ustrezno le za hitra, nekritična dela) in zategnemo se za **Celery ali ARQ**, kadar mora biti delo trajno, ponovljivo, načrtovano, težko ali porazdeljeno (obdelava datotek/videoposnetkov, pošiljanje množičnih e-poštnih sporočil, sinhronizacija podatkov, ustvarjanje poročil).

Te čakalne vrste zagotavljajo kritične proizvodne zmožnosti: **trajnost** (opravila preživijo sesutja prek posrednika, zato dela niso izgubljena), **avtomatični ponovni poskusi** (odpornost na prehitne napake), **načrtovanje** (periodična opravila) in **neodvisno skaliranje** delavcev od spletnih strežnikov.

Znanje, kako definirati in preusmerjati opravila v vrsto (Celery `.delay()`, ARQ asinkrona API), arhitektura (posrednik + delavci) in posebej **odločitev, kdaj uporabiti pravo vrsto v primerjavi s BackgroundTasks**, je dragoceno za arhitekturiranje zanesljivih aplikacij, ki premeščajo težka dela brez izgube — pogosta, pomembna zahteva, ki loči robustne proizvodne sisteme od krhkih.