Kako rasporedate FastAPI aplikaciju u produkciju?

Question

Accepted Answer

FastAPI je **ASGI** aplikacija, pa produkcijska implementacija koristi ASGI server — obično **Uvicorn** (često upravljan sa **Gunicorn** za više radnika), iza reverznog proxy-ja poput nginx-a. Kontejnerizacija (Docker) je uobičajeni moderni pristup.

## Produktivni server stack

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

## Kontejnerizacija aplikacije (uobičajeno)

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

Kontejner pakiruje aplikaciju i njezine zavisnosti za konzistentnu implementaciju u različitim okruženjima (zatim pokrenite na Kubernetes, ECS ili PaaS-u poput Railway/Render/Fly).

## Produkcijska kontrolna lista

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

## Asinkrona obrada i bez stanja

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

## Zašto je važno

Ispravan raspored FastAPI aplikacije neophoda je za vođenje aplikacija u produkciju, a uključuje važna razmatranja specifična za njegovu **ASGI** prirodu koja se razlikuju od postavki za razvoj.

Razumijevanje production server stack-a je temeljno: development server (`uvicorn --reload`) nije za produkciju, pa pokrenete aplikaciju putem ASGI servera — **Uvicorn radnici upravljani Gunicorn-om** za više procesa (koristeći sve CPU jezgre, jer svaki radnik pokreće vlastitu event petlju), obično iza nginx-a za TLS i balansiranje opterećenja. **Kontejnerizacija (Docker)** je uobičajeni moderni pristup za konzistentne, prenosive implementacije.

Izvan postavke servera, produkcijska kontrolna lista pokriva sigurnosne i pouzdanosne kritične brige: konfiguracija i tajne kroz varijable okruženja (nikad u kodu), HTTPS, pravi baza podataka s migracijama i pooling-om, pravilni CORS, zapisivanje i monitoring, odvojene worker servise za pozadinske zadatke i — za skaliranje — pokretanje **višestrukih instanci bez stanja** iza balansera opterećenja (čuvanje stanja u Redis-u, ne u memoriji procesa).

Znanje kako rasporedate FastAPI sa pravim ASGI server stack-om, kontejnerizacijom, višestrukim radnicima i production hardening-om je važno znanje za senior razinu, jer svaka prava FastAPI aplikacija mora biti ispravno raspoređena da bi bila performantna, sigurna i skalabilna — čineći ovo često relevantnom, profesionalno neophodnom temom za isporuku production API-ja.