Kaip jūs diegiate FastAPI programą į gamybą?

Question

Accepted Answer

FastAPI yra **ASGI** aplikacija, todėl gamybinis diegimas naudoja ASGI serverį — paprastai **Uvicorn** (dažnai valdomas **Gunicorn** su keliais darbininkais), už atvirkštinio proksi serveriaus, tokio kaip nginx. Kontainerizacija (Docker) yra šiuolaikinis bendras požiūris.

## Gamybinio serverio sąranka

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

## Aplikacijos kontainerizacija (bendras būdas)

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

Kontaineris pakuoja aplikaciją ir jos priklausomybes dėl nuoseklaus diegimo visose aplinkose (tada paleiskite Kubernetes, ECS arba PaaS, pvz., Railway/Render/Fly).

## Gamybos kontrolinis sąrašas

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

## Asinkroniškumas ir būsenos nebuvimas

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

## Kodėl tai svarbu

Teisingas FastAPI diegimas į gamybą yra esminis norint perkelti aplikacijas į gamybą, ir jis apima svarbias apsvarstymus, specifines jo **ASGI** prigimčiai, kurios skiriasi nuo kūrimo sąrankos.

Supratimas apie gamybinio serverio sąrangą yra pagrindinė: kūrimo serveris (`uvicorn --reload`) nėra skirtas gamybai, todėl jūs paleidziate aplikaciją per ASGI serverį — **Uvicorn darbininkus, valdomus Gunicorn** keliems procesams (naudojant visus CPU branduolius, nes kiekvienas darbininkas paleido savąjį įvykių kilpą), paprastai už nginx TLS ir apkrovos subalansavimui. **Kontainerizacija (Docker)** yra šiuolaikinis bendras požiūris dėl nuoseklių, perkeliamų diegimų.

Be serverio sąrankos, gamybos kontrolinis sąrašas apima su saugumu ir patikimumu susijusius aspektus: konfigūracija ir paslapčiai per aplinkos kintamuosius (niekada kode), HTTPS, tikra duomenų bazė su migracijom ir jungimu, tinkama CORS, žurnalų ir stebėjimas, atskiros darbinio paslaugos foninėms užduotims ir — plėtimui — paleidimas **kelių būsenai nepriklauso instancijų** už apkrovos balansuotojo (būsena saugoma Redis, ne proceso atmintyje).

Žinoti, kaip diegti FastAPI naudojant tinkamą ASGI serverio sąrangą, kontainerizaciją, kelis darbininkus ir gamybos sustiprinimą, yra svarbios aukštos kvalifikacijos žinios, nes kiekviena tikra FastAPI aplikacija turi būti diegta teisingai, kad būtų produktyvi, saugi ir masteliojama — tai dažnai aktualus, profesionaliai neatsiejamai svarbus šiuolaikinių gamybos API temą.