Hogyan telepítesz egy FastAPI alkalmazást éles környezetbe?

Question

Accepted Answer

A FastAPI egy **ASGI** alkalmazás, így az éles telepítés egy ASGI szervert használ — tipikusan a **Uvicorn**-t (gyakran a **Gunicorn** által kezelve több worker-hez), egy fordított proxy mögött, mint az nginx. A konténerizáció (Docker) a modern közös megközelítés.

## Az éles szerver 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).
```

## Az alkalmazás Docker-izálása (közös)

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

Egy konténer csomagolva tartalmazza az alkalmazást és annak függőségeit a konzisztens telepítéshez különböző környezetek között (majd futtatható Kubernetes-en, ECS-en vagy egy PaaS-on, mint a Railway/Render/Fly).

## Az éles ellenőrző 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)
```

## Aszinkron és állapotmentesség

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

## Miért fontos

A FastAPI helyes telepítése lényeges az alkalmazások éles környezetbe viételéhez, és fontos megfontolásokat tartalmaz, amelyek az **ASGI** természetére jellemzőek és eltérnek a fejlesztési beállítástól.

Az éles szerver stack megértése alapvető: a fejlesztési szerver (`uvicorn --reload`) nem az éles használatra való, ezért az alkalmazást egy ASGI szerveren futtatod — **Gunicorn által kezelt Uvicorn workerek** több folyamathoz (felhasználva az összes CPU magot, mivel minden worker saját event loop-ot futtat), tipikusan az nginx mögött a TLS és terheléselosztáshoz. A **konténerizáció (Docker)** a közös modern megközelítés a konzisztens, hordozható telepítésekhez.

A szerver beállításán túl az éles ellenőrző lista a biztonsággal és megbízhatósággal kapcsolatos kritikus szempontokat fedezi: konfiguráció és titkok környezeti változókon keresztül (soha nem a kódban), HTTPS, valós adatbázis migrációkkal és connection pooling-gal, megfelelő CORS, naplózás és monitorozás, külön worker-szerverek háttérfeladatokhoz, és — skálázáshoz — **több állapotmentes instancia** futtatása egy terheléselosztó mögött (az állapot Redis-ben tárolva, nem a folyamat memóriájában).

A FastAPI helyes ASGI szerver stack-tel, konténerizációval, több worker-rel és éles teljesítménnyel történő telepítésének tudása fontos senior szintű ismeret, mivel minden valós FastAPI alkalmazást helyesen kell telepíteni ahhoz, hogy teljesítményes, biztonságos és méretezhető legyen — ezzel ezt egy gyakran releváns, szakmailag lényeges témává teszi az éles API-k kiszállításához.