तपाई FastAPI app लाई production मा कसरी deploy गर्नुहुन्छ?

Question

Accepted Answer

FastAPI एक **ASGI** application हो, त्यसैले production deployment एक ASGI server प्रयोग गर्छ — सामान्यतः **Uvicorn** (अक्सर **Gunicorn** द्वारा multiple workers को लागि व्यवस्थापित), nginx जस्तो reverse proxy को पछाडि। Containerization (Docker) आधुनिक सामान्य दृष्टिकोण हो।

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

## App को Dockerizing गर्नुहोस् (सामान्य)

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

एक container app र यसका dependencies लाई प्याकेज गर्छ consistent deployment को लागि environments मा (त्यपछि Kubernetes, ECS, वा PaaS जस्तै Railway/Render/Fly मा चलाउनुहोस्)।

## Production checklist

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

## Async र statelessness

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

## किन यो महत्त्वपूर्ण छ

FastAPI लाई सही तरिकाले deploy गर्नु applications लाई production मा लैजान आवश्यक छ, र यसमा यसको **ASGI** प्रकृति को लागि विशेष विचारहरु समावेश छन् जो development setup भन्दा फरक छ।

Production server stack बुझ्नु आधारभूत छ: development server (`uvicorn --reload`) production को लागि छैन, त्यसैले तपाई app लाई एक ASGI server को माध्यमबाट चलाउनुहुन्छ — **Gunicorn द्वारा व्यवस्थापित Uvicorn workers** multiple processes को लागि (सबै CPU cores को उपयोग गर्दै, किनकि प्रत्येक worker आफ्नो event loop चलाउँछ), सामान्यतः nginx को पछाडि TLS र load balancing को लागि। **Containerization (Docker)** consistent, portable deployments को लागि आधुनिक सामान्य दृष्टिकोण हो।

Server setup बाहेक, production checklist ले security- र reliability-critical विचारहरु कभर गर्छ: configuration र secrets environment variables को माध्यमबाट (कोडमा कहिले पनि होइन), HTTPS, एक real database migrations र pooling को साथ, proper CORS, logging र monitoring, background jobs को लागि अलग worker services, र — scaling को लागि — एक load balancer को पछाडि **multiple stateless instances** चलाउनु (state लाई Redis मा राख्नु, process memory मा होइन)।

FastAPI लाई सही ASGI server stack, containerization, multiple workers, र production hardening को साथ कसरी deploy गर्ने भनी जान्नु महत्त्वपूर्ण senior-level ज्ञान हो, किनकि हरेक real FastAPI application लाई performant, secure, र scalable हुन सही तरिकाले deploy गरिनु आवश्यक छ — यो एक frequently-relevant, professionally-essential विषय बनाउँदै production APIs को लागि।