LifeRPG_v2.0/docs/DEPLOYMENT_GUIDE.md

LifeRPG Production Deployment Guide

This comprehensive guide covers deploying LifeRPG to production environments with security, scalability, and cost optimization in mind.

Deployment Options Overview

Free Tier Options (Perfect for Students)

1. Frontend: Vercel/Netlify (Free tier)
2. Backend: Railway/Render (Free tier with limitations)
3. Database: SQLite (file-based, included)
4. Monitoring: Built-in health checks

Low-Cost Options ($5-15/month)

1. VPS: DigitalOcean Droplet, Linode, Vultr
2. Platform: Railway Pro, Render Pro
3. Container: Docker on cloud VPS

Production-Ready Options ($20-50/month)

1. Cloud: AWS/GCP/Azure with proper scaling
2. Database: Managed PostgreSQL
3. CDN: CloudFlare Pro
4. Monitoring: External monitoring services

---

Quick Start: Free Deployment

Option 1: Vercel + Railway (Recommended for Students)

Step 1: Prepare Repository

# Ensure all code is committed and pushed
git add .
git commit -m "Production deployment preparation"
git push origin master

Step 2: Deploy Frontend to Vercel

1. Go to vercel.com
2. Connect your GitHub repository
3. Configure build settings:

   Framework: Create React App
   Root Directory: modern/frontend
   Build Command: npm run build
   Output Directory: build
   

4. Add environment variables:

   REACT_APP_API_URL=https://your-backend.railway.app
   REACT_APP_ENVIRONMENT=production
   

Step 3: Deploy Backend to Railway

1. Go to railway.app
2. Create new project from GitHub
3. Configure:

   Root Directory: modern/backend
   Start Command: uvicorn app:app --host 0.0.0.0 --port $PORT
   

4. Add environment variables:

   ENVIRONMENT=production
   SECRET_KEY=your-secure-secret-key
   DATABASE_URL=sqlite:///production.db
   CORS_ORIGINS=["https://your-app.vercel.app"]
   

Option 2: Netlify + Render

Frontend (Netlify)

1. Go to netlify.com
2. Connect GitHub repository
3. Build settings:

   Publish directory: modern/frontend/build
   Build command: cd modern/frontend && npm install && npm run build
   

Backend (Render)

1. Go to render.com
2. Create Web Service
3. Settings:

   Root Directory: modern/backend
   Build Command: pip install -r requirements.txt
   Start Command: uvicorn app:app --host 0.0.0.0 --port $PORT
   

---

Docker Deployment

Complete Docker Setup

1. Production Dockerfile (Backend)

# modern/backend/Dockerfile.prod
FROM python:3.12-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# Copy requirements first for better caching
COPY requirements.txt requirements_ai.txt ./
RUN pip install --no-cache-dir -r requirements_ai.txt

# Copy application code
COPY . .

# Create non-root user
RUN useradd -m -r appuser && chown appuser:appuser /app
USER appuser

# Health check
HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8000/api/v1/health/ || exit 1

EXPOSE 8000
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

2. Production docker-compose.yml

version: "3.8"

services:
  backend:
    build:
      context: ./modern/backend
      dockerfile: Dockerfile.prod
    ports:
      - "8000:8000"
    environment:
      - ENVIRONMENT=production
      - DATABASE_URL=sqlite:///data/production.db
      - SECRET_KEY=${SECRET_KEY}
    volumes:
      - ./data:/app/data
      - ./ai_models:/app/ai_models
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/api/v1/health/"]
      interval: 30s
      timeout: 10s
      retries: 3

  frontend:
    build:
      context: ./modern/frontend
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      - REACT_APP_API_URL=http://localhost:8000
    depends_on:
      - backend
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - frontend
      - backend
    restart: unless-stopped

3. Nginx Configuration

# nginx.conf
events {
    worker_connections 1024;
}

http {
    upstream backend {
        server backend:8000;
    }

    upstream frontend {
        server frontend:3000;
    }

    server {
        listen 80;
        server_name your-domain.com;

        # Redirect to HTTPS
        return 301 https://$server_name$request_uri;
    }

    server {
        listen 443 ssl;
        server_name your-domain.com;

        ssl_certificate /etc/nginx/ssl/cert.pem;
        ssl_certificate_key /etc/nginx/ssl/key.pem;

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

        # Backend API
        location /api {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        # Health checks
        location /health {
            proxy_pass http://backend;
        }
    }
}

---

VPS Deployment (DigitalOcean/Linode)

1. Server Setup

# Create and connect to VPS
ssh root@your-server-ip

# Update system
apt update && apt upgrade -y

# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
systemctl start docker
systemctl enable docker

# Install Docker Compose
pip3 install docker-compose

# Install other tools
apt install -y git nginx certbot python3-certbot-nginx

2. Deploy Application

# Clone repository
git clone https://github.com/yourusername/LifeRPG.git
cd LifeRPG

# Create environment file
cat > .env << EOF
SECRET_KEY=$(openssl rand -hex 32)
ENVIRONMENT=production
DATABASE_URL=sqlite:///data/production.db
REACT_APP_API_URL=https://your-domain.com
EOF

# Create data directory
mkdir -p data ai_models

# Start services
docker-compose -f docker-compose.prod.yml up -d

3. SSL Setup with Let's Encrypt

# Get SSL certificate
certbot --nginx -d your-domain.com

# Auto-renewal
crontab -e
# Add: 0 12 * * * /usr/bin/certbot renew --quiet

---

Monitoring and Maintenance

Health Monitoring Script

#!/bin/bash
# monitoring/health-check.sh

BACKEND_URL="https://your-domain.com"
SLACK_WEBHOOK="your-slack-webhook-url"

# Check backend health
if ! curl -f "$BACKEND_URL/api/v1/health/" > /dev/null 2>&1; then
    echo "Backend health check failed"
    curl -X POST -H 'Content-type: application/json' \
        --data '{"text":"🚨 LifeRPG Backend is down!"}' \
        $SLACK_WEBHOOK
fi

# Check disk space
DISK_USAGE=$(df / | grep -vE '^Filesystem' | awk '{print $5}' | sed 's/%//g')
if [ $DISK_USAGE -gt 80 ]; then
    echo "High disk usage: ${DISK_USAGE}%"
fi

Backup Script

#!/bin/bash
# scripts/backup.sh

BACKUP_DIR="/backups"
DB_FILE="data/production.db"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p $BACKUP_DIR

# Backup database
cp $DB_FILE "$BACKUP_DIR/liferpg_db_$DATE.db"

# Backup user uploads (if any)
tar -czf "$BACKUP_DIR/uploads_$DATE.tar.gz" uploads/

# Keep only last 30 days of backups
find $BACKUP_DIR -name "*.db" -mtime +30 -delete
find $BACKUP_DIR -name "*.tar.gz" -mtime +30 -delete

echo "Backup completed: $DATE"

---

Security Checklist

Essential Security Measures

1. Environment Security

• Strong SECRET_KEY in production
• Environment variables for all secrets
• No hardcoded credentials in code
• HTTPS enabled with valid certificates
• CORS properly configured

2. Application Security

• Input validation on all endpoints
• Rate limiting implemented
• Authentication required for sensitive operations
• SQL injection prevention (using parameterized queries)
• XSS prevention in frontend

3. Server Security

• Firewall configured (only necessary ports open)
• SSH key authentication (disable password auth)
• Regular system updates
• Non-root user for application
• Log monitoring set up

4. Database Security

• Database file permissions restricted
• Regular backups
• Backup encryption for sensitive data

---

Performance Optimization

Backend Optimization

1. Enable Compression

   from fastapi.middleware.gzip import GZipMiddleware
   app.add_middleware(GZipMiddleware, minimum_size=1000)
   

2. Response Caching

   from fastapi_cache import FastAPICache
   from fastapi_cache.backends.redis import RedisBackend
   

3. AI Model Optimization

• Pre-load models on startup
• Implement model caching
• Use quantized models for lower memory usage

Frontend Optimization

1. Code Splitting

   const LazyComponent = React.lazy(() => import("./Component"));
   

2. Service Worker for Caching

3. Image Optimization

4. Bundle Analysis

---

Cost Optimization

Free Tier Maximization

• Vercel: 100GB bandwidth, unlimited sites
• Railway: 500 hours/month, $5 credit
• Render: 750 hours/month
• GitHub: Free hosting for static sites

Budget Planning ($10-20/month)

• Domain: $12/year
• VPS: $5-10/month
• SSL: Free (Let's Encrypt)
• CDN: Free (CloudFlare)

Scaling Strategy

1. Start Free: Use free tiers
2. Grow Smart: Upgrade one service at a time
3. Monitor Usage: Use built-in analytics
4. Optimize First: Before upgrading resources

---

Troubleshooting

Common Issues

Build Failures

# Clear caches
npm cache clean --force
pip cache purge

# Rebuild containers
docker-compose down
docker-compose build --no-cache

Memory Issues

# Check memory usage
free -h
docker stats

# Restart services
docker-compose restart

SSL Certificate Issues

# Renew certificates
certbot renew --dry-run
certbot renew

# Check certificate status
certbot certificates

---

Support and Maintenance

Regular Maintenance Tasks

• Weekly: Check application logs
• Weekly: Verify backups
• Monthly: Update dependencies
• Monthly: Review security logs
• Quarterly: Performance review
• Quarterly: Cost optimization review

Emergency Response Plan

1. Monitor alerts (health checks, error rates)
2. Incident response (restart services, check logs)
3. Communication (user notifications if needed)
4. Post-incident (root cause analysis, prevention)

---

Student-Specific Tips

Academic Projects

• Use .edu domain for free services
• GitHub Student Pack benefits
• AWS/GCP/Azure education credits
• Free SSL certificates through GitHub Pages

Portfolio Enhancement

• Custom domain for professionalism
• Performance metrics documentation
• User feedback and testimonials
• Technical blog posts about the project

Learning Opportunities

• Infrastructure as Code (Terraform)
• CI/CD pipeline improvements
• Monitoring and observability
• Security best practices implementation

---

This deployment guide provides multiple pathways from free student hosting to production-ready infrastructure. Choose the approach that matches your current needs and budget, with clear upgrade paths as your project grows.