Hur distribuerar du en FastAPI-app till produktion?

Question

Accepted Answer

FastAPI är en **ASGI**-applikation, så produktionsdistribution använder en ASGI-server — typiskt **Uvicorn** (ofta hanterad av **Gunicorn** för flera workers), bakom en reverse proxy som nginx. Containerisering (Docker) är den vanliga moderna metoden.

## Produktionsserverstacken

```bash
# ❌ the dev server (with --reload) is NOT for production
uvicorn main:app --reload

# ✅ production: Gunicorn managing multiple Uvicorn workers (uses all CPU cores)
gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
# -w 4 → 4 worker processes (rule of thumb: ~2 × CPU cores)
```

```text
Client → NGINX (reverse proxy: TLS, static files, load balancing)
           → GUNICORN (process manager) → UVICORN workers (run the ASGI app)
Multiple workers let FastAPI use multiple CPU cores (each worker = one process).
```

## Dockerisering av appen (vanligt)

```dockerfile
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["gunicorn", "main:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8000"]
```

En container paketerar appen och dess beroenden för konsistent distribution över miljöer (kör sedan på Kubernetes, ECS eller en PaaS som Railway/Render/Fly).

## Produktionschecklistan

```text
1. Config & secrets via environment variables (not in code); validate at startup
2. Multiple workers (Gunicorn + Uvicorn workers) for CPU utilization
3. HTTPS/TLS (at nginx or the platform/load balancer)
4. A real database (PostgreSQL) + connection pooling; run migrations (Alembic)
5. CORS configured to an allowlist (not "*") for browser clients
6. Logging + error monitoring (Sentry) + health-check endpoint
7. A separate worker service (Celery/ARQ) + broker (Redis) for background jobs
8. Horizontal scaling: multiple instances behind a load balancer — keep app STATELESS
   (sessions/state in Redis, not process memory)
```

## Asynkron och tillståndslös

```text
✓ Each worker runs its own event loop → workers give parallelism, async gives concurrency
✓ Keep the app STATELESS so you can run many instances behind a load balancer
```

## Varför det är viktigt

Att distribuera FastAPI korrekt är väsentligt för att ta applikationer till produktion, och det innefattar viktiga överväganden specifika för dess **ASGI**-natur som skiljer sig från utvecklingsmiljön.

Att förstå produktionsserverstacken är grundläggande: utvecklingsservern (`uvicorn --reload`) är inte för produktion, så du kör appen via en ASGI-server — **Uvicorn-workers hanterade av Gunicorn** för flera processer (utnyttjar alla CPU-kärnor, eftersom varje worker kör sin egen event loop), typiskt bakom nginx för TLS och lastbalansering. **Containerisering (Docker)** är den vanliga moderna metoden för konsistenta, portabla distributioner.

Utöver serverinställningen täcker produktionschecklistan säkerhets- och tillförlitlighetskritiska frågor: konfiguration och hemligheter via miljövariabler (aldrig i kod), HTTPS, en verklig databas med migrationer och pooling, korrekt CORS, loggning och övervakning, separata worker-tjänster för bakgrundsjobb, och — för skalning — att köra **flera tillståndslösa instanser** bakom en lastbalanserare (håll tillstånd i Redis, inte processminne).

Att veta hur man distribuerar FastAPI med rätt ASGI-serverstack, containerisering, flera workers och produktionshärdning är viktig kunskaper på seniornivå, eftersom varje verklig FastAPI-applikation måste distribueras korrekt för att vara prestanda-, säker och skalbar — vilket gör detta till ett ofta relevant, professionellt väsentligt ämne för att leverera produktions-API:er.