Recap — Production Deployment Options

# Production Deployment Options Once your FastAPI app works locally, the question is how to run it for real users. Several options span simplicity to control. ## The fundamentals FastAPI itself doesn't include a production server. You need: 1. **ASGI server**: Uvicorn (development), Hypercorn, or Daphne. 2. **Process manager** (for multi-worker production): Gunicorn with uvicorn worker class, OR uvicorn with `--workers`. 3. **Container or host**: Docker (most common), bare metal, or PaaS. ## Uvicorn (development + simple production) ```bash uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4 ``` `--workers 4` = 4 separate Python processes. Each handles requests independently. Useful for multi-CPU. Use Uvicorn directly when: - Small to medium scale. - Simple deployments (one container, one server). - Modern; supports HTTP/2. ## Gunicorn + Uvicorn (production standard) Gunicorn manages workers; uses Uvicorn worker class for ASGI: ```bash gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000 ``` Features: - Process management (restart on crash). - Graceful shutdown. - More config (max requests, timeouts). - Battle-tested for years. Use when: - You want process-supervisor features. - Production-grade reliability. ## Dockerfile (the standard) ```dockerfile FROM python:3.12-slim WORKDIR /app # Install uv (or just use pip) COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv COPY pyproject.toml uv.lock ./ RUN uv sync --frozen --no-dev COPY src ./src ENV PYTHONUNBUFFERED=1 ENV PATH="/app/.venv/bin:$PATH" EXPOSE 8000 CMD ["uvicorn", "my_app.main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"] ``` Build and run: ```bash docker build -t my-app . docker run -p 8000:8000 \ -e DATABASE_URL=postgres://... \ -e SECRET_KEY=... \ my-app ``` ## Multi-stage Dockerfile (smaller image) ```dockerfile # Stage 1: build FROM python:3.12 as builder WORKDIR /app COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv COPY pyproject.toml uv.lock ./ RUN uv sync --frozen --no-dev # Stage 2: runtime (smaller base, no build tools) FROM python:3.12-slim WORKDIR /app COPY --from=builder /app/.venv /app/.venv COPY src ./src ENV PATH="/app/.venv/bin:$PATH" ENV PYTHONUNBUFFERED=1 EXPOSE 8000 CMD ["uvicorn", "my_app.main:app", "--host", "0.0.0.0", "--port", "8000"] ``` Smaller image (no build deps); faster pulls in production. ## docker-compose for local dev ```yaml # docker-compose.yml services: app: build: . ports: ["8000:8000"] environment: DATABASE_URL: postgresql://user:pass@db:5432/myapp REDIS_URL: redis://redis:6379 depends_on: [db, redis] db: image: postgres:16-alpine environment: POSTGRES_USER: user POSTGRES_PASSWORD: pass POSTGRES_DB: myapp volumes: ["pgdata:/var/lib/postgresql/data"] redis: image: redis:7-alpine volumes: pgdata: ``` ```bash docker-compose up ``` Spins up FastAPI + Postgres + Redis with one command. ## Cloud platforms (in 2026) ### Fly.io Deploy globally with `fly deploy`. Affordable; great for hobby and startup. Auto-scaling, free tier. ```bash fly launch fly deploy ``` ### Railway Similar to Fly; one-click DB provisioning. Good DX. ### Render Heroku-like; web service + worker + DB. ### Heroku Still around; pricier than alternatives. ### Vercel / Netlify Optimized for frontend + serverless functions; less ideal for sustained-process FastAPI. ### AWS / GCP / Azure For larger production: - **AWS ECS Fargate**: containers without managing servers. - **AWS Lambda + API Gateway**: serverless FastAPI via Mangum adapter. - **GCP Cloud Run**: fully managed containers. - **AWS EKS / GKE**: Kubernetes (for serious infrastructure). ### Kubernetes For large teams; deploys at scale; not needed for most apps. ## Process count / worker count Rule of thumb: 2 × (CPU cores) + 1 workers. For a 4-core machine: 9 workers. In Docker: each container is a single process tree; usually 1-4 workers per container depending on CPU allocation. ## Environment variables Set production config via env: ```bash DATABASE_URL=postgresql://... SECRET_KEY=... LOG_LEVEL=INFO ``` In Docker: `-e` or `--env-file`. In cloud platforms: their dashboard / secrets management. NEVER hardcode secrets in Dockerfile or code. ## Database Production needs: - Managed Postgres (RDS, Cloud SQL, Supabase, Neon). - Backups (automatic; verify they work). - Connection pooling (PgBouncer or built-in cloud option). For app-side connection pooling: ```python engine = create_engine(DATABASE_URL, pool_size=20, max_overflow=10) ``` ## TLS / HTTPS Don't terminate TLS in FastAPI. Use: - Load balancer (AWS ALB, GCP LB). - Reverse proxy (nginx, Caddy, Traefik). - Platform-managed (Fly, Railway include). FastAPI runs HTTP internally; TLS at the edge. ## CI/CD pipeline ```yaml # .github/workflows/deploy.yml name: Deploy on: push: branches: [main] jobs: deploy: runs-on: ubuntu-latest st