Hoe werken BackgroundTasks?

Question

Accepted Answer

De **`BackgroundTasks`** van FastAPI laat je werk uitvoeren **na het retourneren van de response** — dus de client krijgt snel antwoord terwijl licht vervolgwerk (e-mail versturen, logging, opschoning) op de achtergrond gebeurt. Het is ingebouwd en eenvoudig, voor lichte taken.

## BackgroundTasks gebruiken

```python
from fastapi import BackgroundTasks

def send_email(address: str, message: str):
    # slow-ish work that the client shouldn't wait for
    email_client.send(address, message)

@app.post("/signup")
def signup(user: User, background_tasks: BackgroundTasks):   # inject BackgroundTasks
    save_user(user)
    background_tasks.add_task(send_email, user.email, "Welcome!")   # queue it
    return {"message": "User created"}    # RESPONSE returns NOW; email sends AFTER
```

Injecteer een `BackgroundTasks`-parameter en roep `add_task(func, *args)` aan. FastAPI stuurt eerst de response, voert vervolgens de in wachtrij geplaatste taak(en) uit — zodat de gebruiker niet hoeft te wachten op de e-mail.

## Meerdere taken en gebruik met afhankelijkheden

```python
@app.post("/order")
def create_order(order: Order, bg: BackgroundTasks):
    bg.add_task(send_confirmation, order.email)
    bg.add_task(update_analytics, order.id)     # multiple tasks run in order, after the response
    return {"status": "created"}
```

## De cruciale beperking: het is NIET voor zwaar/kritiek werk

```text
BackgroundTasks runs IN THE SAME PROCESS as the web server:
  ✗ NO persistence — if the server crashes/restarts, queued tasks are LOST
  ✗ NO retries, scheduling, or distribution
  ✗ Heavy CPU work would still tie up the worker process
→ Good for: quick, non-critical, fire-and-forget tasks (emails, logging, light cleanup)
→ For heavy, critical, retryable, or scheduled jobs → use Celery / ARQ (a real task queue)
```

## Wanneer welke gebruiken

```text
BackgroundTasks → simple, lightweight, best-effort work tied to a request (no extra infra)
Celery / ARQ    → durable, retryable, scheduled, distributed jobs (needs a broker/workers)
```

## Waarom het belangrijk is

`BackgroundTasks` is een handig ingebouwd hulpmiddel voor de veelvoorkomende behoefte om vervolgwerk uit te voeren zonder de client te laten wachten — een welkomste-mail versturen, een log schrijven, lichte opschoning — waardoor de reactietijden voor de gebruiker verbeteren.

Het begrijpen is nuttig voor deze alledaagse lichte gevallen, aangezien hiervoor geen extra infrastructuur nodig is.

Maar het **belangrijkste punt** is het kennen van de **beperkingen ervan**: omdat het in hetzelfde proces als de webserver wordt uitgevoerd, biedt het geen persistentie (taken gaan verloren bij crash/herstart), geen herhalingen, geen planning, en is het niet geschikt voor zwaar of kritiek werk.

Dit onderscheid herkennen — `BackgroundTasks` gebruiken voor snelle, niet-kritieke, fire-and-forget taken, en een echte taakwachtrij zoals **Celery/ARQ** voor duurzame, herhaalbare, geplande of zware achtergrondtaken — is het kernoordeelsvermogen dat de veelvoorkomende fout voorkomt van vertrouwen op BackgroundTasks voor werk dat niet verloren mag gaan, waardoor dit belangrijke praktische kennis wordt voor het bouwen van betrouwbare applicaties.