Għal ħidmiet ta' sfond robust u durabbli (lil hinn mill-lightweight BackgroundTasks ta' FastAPI), tuża queue ta' ħidmiet reali: Celery (il-standard stabbilit) jew ARQ (queue async-native moderna). Dawn jitmexxu ħidmiet tqila, li jistgħu jippruvaw mill-ġdid, ippjanati f'proċessi worker separati, appoġġati minn broker bħal Redis.
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).
# 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
# 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
L-endpoint jiddaħħal il-ħidma f'queue u jirrispondi immedjatament; proċess worker separat jitmexxaha bi persistenza u ripruvamenti.
# 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 hija alternattiva ħafifa u async-first — attraenti meta l-kodiċi tiegħek huwa diġà async.
✓ 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
It-teħwieġ ta' ħidmiet ta' sfond robust huwa essenzjali għall-bini ta' applikazzjonijiet FastAPI tal-livell ta' produzzjoni li jitmexxu ħidmiet tqila jew iddifferizzata b'mod affidabbli — u l-għarfien meta u kif tuża queue ta' ħidmiet reali huwa għarfien importanti tal-livell senior.
L-ħakma ewlenija hija l-irrikonoxximent tal-limiti ta' BackgroundTasks (l-ebda persistenza, ripruvamenti, jew skedjuling — tajjeb biss għal ħidmiet mabsuta, mhux kritika) u li tiddevija lejn Celery jew ARQ meta l-ħidma trid tkun durabbli, li tista' tipprova mill-ġdid, ippjanata, tqila, jew distribwita (ipproċessar ta' fajls/vidjos, li jibgħat emails f'ammonti kbar, sincronizzazzjoni tad-dejta, ġenerazzjoni ta' rapporti).
Queues dawn jipprovdu kapaċitajiet ta' produzzjoni kritika: persistenza (il-ħidmiet jissurvjaw il-ħsara permezz tal-broker, allura l-ħidma ma titlefx), ripruvamenti awtomatici (reżistenza kontra fallimenti tranżitorji), skedjuling (ħidmiet perjodiċi), u skalabbilità indipendenti ta' workers mill-web servers.
L-għarfien ta' kif tiffinissi u queue ħidmiet (Celery .delay(), ARQ async-native API), arkitettura (broker + workers), u speċjalment il-deċiżjoni meta tuża queue reali versus BackgroundTasks, huwa valutabbli għall-arkitettura ta' applikazzjonijiet affidabbli li jitmexxu ħidmiet tqila mingħajr ma jitlefhom — rekwiżit komuni u importanti li jiddistingwi sistemi ta' produzzjoni robust minn dawk fraggili.