Deployment Guide

Production Checklist

• Set debug=False in production
• Use environment variables for secrets
• Configure proper CORS origins
• Enable HTTPS/TLS
• Set up logging and monitoring
• Configure database connection pooling
• Implement rate limiting
• Set up error tracking (Sentry, etc.)
• Configure backups
• Test on staging environment
• Set up CI/CD pipeline

ASGI Servers

Uvicorn (Recommended)

Basic

uvicorn main:app --host 0.0.0.0 --port 8000

Production with Workers

uvicorn main:app \
  --host 0.0.0.0 \
  --port 8000 \
  --workers 4 \
  --loop uvloop \
  --log-level warning

With SSL/TLS

uvicorn main:app \
  --host 0.0.0.0 \
  --port 443 \
  --ssl-keyfile key.pem \
  --ssl-certfile cert.pem \
  --workers 4

Gunicorn with Uvicorn Workers

pip install gunicorn

gunicorn main:app \
  --workers 4 \
  --worker-class uvicorn.workers.UvicornWorker \
  --bind 0.0.0.0:8000

Docker Deployment

Dockerfile

FROM python:3.12-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application
COPY . .

# Expose port
EXPOSE 8000

# Run the application
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Docker Compose

version: '3.8'

services:
  app:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/vayuapi
      - DEBUG=false
    depends_on:
      - db
  
  db:
    image: postgres:15
    environment:
      - POSTGRES_DB=vayuapi
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Cloud Platforms

AWS (Elastic Beanstalk)

eb create vayuapi-env
eb deploy
eb open

Heroku

heroku create vayuapi-app
git push heroku main
heroku open

DigitalOcean App Platform

1. Connect your GitHub repository
2. Configure build and runtime settings
3. Deploy

Google Cloud Run

gcloud run deploy vayuapi \
  --source . \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated

Azure App Service

az webapp up --name vayuapi --runtime PYTHON:3.12

Load Balancing with Nginx

upstream vayuapi {
    server 127.0.0.1:8000;
    server 127.0.0.1:8001;
    server 127.0.0.1:8002;
}

server {
    listen 80;
    server_name api.example.com;

    location / {
        proxy_pass http://vayuapi;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Kubernetes Deployment

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vayuapi
spec:
  replicas: 3
  selector:
    matchLabels:
      app: vayuapi
  template:
    metadata:
      labels:
        app: vayuapi
    spec:
      containers:
      - name: vayuapi
        image: vayuapi:latest
        ports:
        - containerPort: 8000
        env:
        - name: DEBUG
          value: "false"

Monitoring & Logging

Structured Logging

import logging
import json

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@app.get("/")
async def home():
    logger.info(json.dumps({"event": "home_accessed"}))
    return {"message": "Hello"}

Error Tracking with Sentry

import sentry_sdk

sentry_sdk.init(
    dsn="YOUR_SENTRY_DSN",
    traces_sample_rate=1.0
)

Scaling to 145K+ RPS

Multi-Server Architecture

• Load Balancer: AWS ALB or Nginx distributing traffic
• API Servers: 10-20 VayuAPI instances (14.5K RPS each)
• Database: Primary + read replicas
• Cache: Redis cluster for distributed caching
• CDN: CloudFlare for static assets (100K RPS)

Per-Server Configuration (14.5K RPS target)

uvicorn main:app \
  --workers 8 \
  --loop uvloop \
  --host 0.0.0.0 \
  --port 8000 \
  --log-level warning

Database Optimization for Scale

• Connection pooling: pool_size=50, max_overflow=100
• Read replicas for scaling reads
• Redis for hot data caching
• Redis Sentinel for high availability (3 nodes)

Performance Monitoring Checklist

• CPU and memory usage per server
• Request latency (p50, p95, p99)
• Error rates and error types
• Database query performance
• Redis cache hit rate
• Active connections
• Disk I/O and throughput
• Network bandwidth usage

Performance Optimization

• Use connection pooling for databases
• Enable HTTP/2 and HTTP/3
• Use CDN for static assets
• Implement caching strategies
• Monitor and optimize database queries
• Use async operations where possible

Next Steps

After deploying, consider:

• Setting up continuous monitoring
• Implementing automated backups
• Configuring alerting and notifications
• Planning for scaling and high availability