FastAPI Deployment Configuration

Purpose: Autonomously configure and deploy FastAPI applications across multiple platforms with production-ready configurations.

Activation Triggers:

• Deployment setup requests
• Docker containerization needs
• Platform-specific configuration (Railway, DigitalOcean, AWS)
• Health check implementation
• Environment variable management
• Reverse proxy setup (Nginx)
• Production optimization
• Multi-stage build configurations

Key Resources:

• scripts/build-docker.sh - Multi-stage Docker build automation
• scripts/validate-deployment.sh - Pre-deployment validation checks
• scripts/health-check.sh - Application health verification
• templates/ - Production-ready Dockerfile, docker-compose.yml, platform configs
• examples/ - Platform-specific deployment guides (Railway, DigitalOcean, AWS)

Deployment Workflow

1. Pre-Deployment Validation

Run comprehensive checks before deployment:

./scripts/validate-deployment.sh

# Validates:
# - Python dependencies (requirements.txt)
# - Environment variables (.env.example)
# - FastAPI application structure
# - Database migrations (if using Alembic)
# - Static file configuration
# - CORS settings
# - Security configurations

Common issues detected:

• Missing required dependencies
• Unset environment variables
• Database connection configuration
• Missing CORS origins
• Insecure secret key defaults

2. Docker Containerization

Build optimized Docker image using multi-stage builds:

./scripts/build-docker.sh [--platform=linux/amd64] [--tag=myapp:latest]

# Features:
# - Multi-stage build (builder + runtime)
# - Layer caching optimization
# - Non-root user for security
# - Health check integration
# - Minimal production image size

Dockerfile template (templates/Dockerfile):

• Python 3.11+ slim base image
• Virtual environment isolation
• Production dependency separation
• Gunicorn/Uvicorn workers
• Security best practices

3. Platform-Specific Configuration

Railway Deployment

# Railway uses railway.json for configuration
# See: examples/railway_setup.md

# Key features:
# - Automatic HTTPS
# - Environment variable management
# - Auto-deploy from Git
# - Database provisioning
# - Custom domains

Configuration: templates/railway.json

• Build command: pip install -r requirements.txt
• Start command: uvicorn main:app --host 0.0.0.0 --port $PORT
• Health check endpoint: /health

DigitalOcean App Platform

# DigitalOcean uses app.yaml for configuration
# See: examples/digitalocean_setup.md

# Key features:
# - Container registry integration
# - Managed databases
# - Auto-scaling
# - CDN integration
# - Monitoring & alerts

Configuration: templates/digitalocean-app.yaml

• Dockerfile-based deployment
• Health check configuration
• Environment variable secrets
• Database component linking

AWS Deployment Options

ECS (Elastic Container Service):

# See: examples/aws_setup.md#ecs-deployment

# Features:
# - Fargate serverless containers
# - Load balancer integration
# - Auto-scaling policies
# - CloudWatch logging
# - VPC networking

App Runner:

# Simplified container deployment
# Automatic scaling and load balancing
# See: examples/aws_setup.md#app-runner

4. Health Check Implementation

Implement comprehensive health checks:

./scripts/health-check.sh <endpoint-url>

# Checks:
# - HTTP endpoint availability (GET /health)
# - Database connectivity
# - Redis/cache availability
# - External API dependencies
# - Response time monitoring

Health endpoint template:

@app.get("/health")
async def health_check():
    return {
        "status": "healthy",
        "version": "1.0.0",
        "database": check_db(),
        "cache": check_redis()
    }

5. Environment Variable Management

Required environment variables:

• DATABASE_URL - Database connection string
• SECRET_KEY - Application secret key
• CORS_ORIGINS - Allowed CORS origins
• ENVIRONMENT - prod/staging/dev
• LOG_LEVEL - Logging verbosity

Templates provided:

• .env.example - Development template
• .env.production.example - Production template

6. Reverse Proxy Configuration (Nginx)

For self-hosted deployments:

# Nginx configuration: templates/nginx.conf

# Features:
# - SSL/TLS termination
# - Rate limiting
# - Request buffering
# - Gzip compression
# - Static file serving
# - WebSocket support
# - Security headers

Configuration highlights:

• Proxy to Uvicorn on port 8000
• Client max body size: 10M
• Connection timeout: 60s
• Rate limiting: 100 req/min per IP

Docker Compose Orchestration

For local development and testing:

docker-compose up -d

# Services configured:
# - FastAPI application
# - PostgreSQL database
# - Redis cache
# - Nginx reverse proxy

Template: templates/docker-compose.yml

• Volume mounts for development
• Network isolation
• Health check dependencies
• Environment variable injection

Production Optimization

Multi-Stage Docker Build

Stage 1: Builder

• Install all dependencies
• Compile Python packages
• Create virtual environment

Stage 2: Runtime

• Copy only runtime dependencies
• Non-root user execution
• Minimal attack surface
• Optimized layer caching

Worker Configuration

Gunicorn + Uvicorn:

# Recommended workers: (2 x CPU cores) + 1
gunicorn main:app \
  --workers 4 \
  --worker-class uvicorn.workers.UvicornWorker \
  --bind 0.0.0.0:8000 \
  --access-logfile - \
  --error-logfile - \
  --log-level info

Database Connection Pooling

# SQLAlchemy configuration
engine = create_engine(
    DATABASE_URL,
    pool_size=10,
    max_overflow=20,
    pool_pre_ping=True
)

Security Configurations

Implemented in templates:

• ✅ Non-root Docker user
• ✅ Read-only root filesystem (where possible)
• ✅ Security headers (HSTS, X-Frame-Options, CSP)
• ✅ CORS configuration
• ✅ Rate limiting
• ✅ Secret management via environment variables
• ✅ SQL injection prevention (SQLAlchemy ORM)
• ✅ Input validation (Pydantic models)

Platform Comparison

Feature	Railway	DigitalOcean	AWS ECS	AWS App Runner
Ease of Setup	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐
Cost (Low Traffic)	$5-10/mo	$12/mo	$20-30/mo	$15-25/mo
Auto-Scaling	Limited	Yes	Yes	Yes
Database Included	Yes (add-on)	Yes (managed)	Separate (RDS)	Separate (RDS)
Custom Domains	Yes	Yes	Yes	Yes
CI/CD	Git-based	Container registry	CodePipeline	Git/ECR

Common Deployment Scenarios

Scenario 1: Simple API (No Database)

Recommended: Railway or AWS App Runner

• Minimal configuration
• Fast deployment
• Auto-scaling included

Scenario 2: API + PostgreSQL

Recommended: Railway or DigitalOcean

• Integrated database provisioning
• Automatic backups
• Connection pooling

Scenario 3: Microservices Architecture

Recommended: AWS ECS or DigitalOcean App Platform

• Service mesh capabilities
• Container orchestration
• Advanced networking

Scenario 4: High-Traffic Production

Recommended: AWS ECS with RDS

• Advanced monitoring
• Multi-AZ deployment
• Enterprise support

Troubleshooting

Build Failures

# Check Docker build logs
./scripts/build-docker.sh --verbose

# Common fixes:
# - Update requirements.txt versions
# - Check Python version compatibility
# - Verify base image availability

Health Check Failures

# Debug health endpoint
./scripts/health-check.sh http://localhost:8000/health --debug

# Common issues:
# - Database connection timeout
# - Missing environment variables
# - Port binding conflicts

Performance Issues

# Monitor worker utilization
# Increase Gunicorn workers
# Enable connection pooling
# Implement caching (Redis)
# Optimize database queries

Resources

Scripts: All scripts are executable and include help documentation (--help)

Templates: Production-ready configurations in templates/ directory

Examples: Detailed platform-specific guides in examples/ directory

• railway_setup.md - Complete Railway deployment walkthrough
• digitalocean_setup.md - DigitalOcean App Platform setup
• aws_setup.md - AWS ECS and App Runner deployment

---

Supported Platforms: Railway, DigitalOcean App Platform, AWS ECS, AWS App Runner, Self-hosted (Docker + Nginx)

FastAPI Version: 0.104.0+ Python Version: 3.11+ Docker Version: 20.10+