Spaces:

prathameshv07
/

DanceDynamics

Paused

App Files Files Community

DanceDynamics / docs /DEPLOYMENT.md

Prathamesh Sarjerao Vaidya

made changes

66e45b5 3 months ago

preview code

raw

history blame contribute delete

11.9 kB

Deployment Guide - DanceDynamics

🚀 Deployment Options

This guide covers multiple deployment strategies for the DanceDynamics.

Option 1: Docker Deployment (Recommended)

Prerequisites

Docker 20.10+
Docker Compose 1.29+
4GB RAM minimum
10GB disk space

Quick Start

# 1. Clone repository
git clone https://github.com/Prathameshv07/DanceDynamics
cd DanceDynamics

# 2. Build Docker image
docker-compose build

# 3. Run container
docker-compose up -d

# 4. Check status
docker-compose ps
docker-compose logs -f

Access Application

Frontend: http://localhost:7860
API Docs: http://localhost:7860/api/docs
Health Check: http://localhost:7860/health

Docker Commands

# Start services
docker-compose up -d

# Stop services
docker-compose down

# View logs
docker-compose logs -f dance-analyzer

# Restart service
docker-compose restart

# Rebuild after code changes
docker-compose build --no-cache
docker-compose up -d

# Clean up
docker-compose down -v  # Removes volumes
docker system prune -a  # Clean unused images

Option 2: Hugging Face Spaces

Setup

Create Space
- Go to https://huggingface.co/spaces
- Click "Create new Space"
- Choose Docker SDK
- Name: DanceDynamics
Prepare Files

Create Dockerfile in root:

FROM python:3.10-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    libgl1-mesa-glx libglib2.0-0 libsm6 \
    libxext6 libxrender-dev libgomp1 ffmpeg \
    && rm -rf /var/lib/apt/lists/*

# Copy and install Python dependencies
COPY backend/requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application
COPY backend/app /app/app
COPY frontend /app/frontend

# Create directories
RUN mkdir -p /app/uploads /app/outputs

EXPOSE 7860

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

Push to Space

git init
git remote add space https://huggingface.co/spaces/prathameshv07/DanceDynamics
git add .
git commit -m "Initial deployment"
git push --force space main

Configure Space
- Set visibility (Public/Private)
- Add README with usage instructions
- Configure hardware (CPU/GPU)

Option 3: AWS EC2

Launch Instance

Choose AMI: Ubuntu 22.04 LTS
Instance Type: t3.medium (2 vCPU, 4GB RAM) minimum
Storage: 20GB EBS volume
Security Group:
- SSH (22) from your IP
- HTTP (80) from anywhere
- Custom TCP (7860) from anywhere

Setup Script

SSH into instance and run:

#!/bin/bash

# Update system
sudo apt-get update && sudo apt-get upgrade -y

# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker ubuntu

# Install Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Clone repository
git clone https://github.com/Prathameshv07/DanceDynamics
cd DanceDynamics

# Start services
docker-compose up -d

# Setup nginx reverse proxy (optional)
sudo apt-get install -y nginx
sudo tee /etc/nginx/sites-available/dance-analyzer << EOF
server {
    listen 80;
    server_name _;
    
    location / {
        proxy_pass http://localhost:7860;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
    }
    
    location /ws {
        proxy_pass http://localhost:7860;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}
EOF

sudo ln -s /etc/nginx/sites-available/dance-analyzer /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

SSL Certificate (Let's Encrypt)

sudo apt-get install -y certbot python3-certbot-nginx
sudo certbot --nginx -d yourdomain.com

Option 4: Google Cloud Run

Prerequisites

Google Cloud account
gcloud CLI installed

Deployment

# 1. Set project
gcloud config set project YOUR_PROJECT_ID

# 2. Build and push image
gcloud builds submit --tag gcr.io/YOUR_PROJECT_ID/dance-analyzer

# 3. Deploy to Cloud Run
gcloud run deploy dance-analyzer \
  --image gcr.io/YOUR_PROJECT_ID/dance-analyzer \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated \
  --memory 2Gi \
  --timeout 300s \
  --max-instances 10

Option 5: DigitalOcean App Platform

Setup

Create App
- Go to DigitalOcean App Platform
- Connect GitHub repository
- Select branch
Configure Build
- Build Command: docker build -t dance-analyzer .
- Run Command: uvicorn app.main:app --host 0.0.0.0 --port 8080
Environment Variables

API_HOST=0.0.0.0
API_PORT=8080
MAX_FILE_SIZE=104857600

Resources
- Basic: 1 GB RAM, 1 vCPU
- Pro: 2 GB RAM, 2 vCPU (recommended)

Environment Variables

Production Configuration

# API Settings
API_HOST=0.0.0.0
API_PORT=7860
DEBUG=false

# Security
CORS_ORIGINS=https://yourdomain.com,https://www.yourdomain.com

# File Limits
MAX_FILE_SIZE=104857600
MAX_VIDEO_DURATION=60

# Processing
MEDIAPIPE_MODEL_COMPLEXITY=1
MEDIAPIPE_MIN_DETECTION_CONFIDENCE=0.5
MAX_WORKERS=2

# Storage
UPLOAD_DIR=/app/uploads
OUTPUT_DIR=/app/outputs
LOG_DIR=/app/logs

# Session Management
SESSION_CLEANUP_INTERVAL=3600
MAX_SESSIONS=50

Performance Optimization

1. Increase Workers

# docker-compose.yml
environment:
  - MAX_WORKERS=4  # Increase for more concurrent processing

2. Use GPU (if available)

# Dockerfile
FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04

# Install TensorFlow GPU
RUN pip install tensorflow-gpu mediapipe-gpu

3. Enable Caching

# app/config.py
CACHE_ENABLED = True
CACHE_DIR = "/app/cache"
CACHE_MAX_SIZE = 10737418240  # 10GB

4. CDN for Static Files

# nginx.conf
location /static/ {
    alias /app/frontend/;
    expires 30d;
    add_header Cache-Control "public, immutable";
}

Monitoring & Logging

1. Health Checks

# Check application health
curl http://localhost:7860/health

# Monitor logs
docker-compose logs -f --tail=100

2. Prometheus Metrics

Add to main.py:

from prometheus_fastapi_instrumentator import Instrumentator

Instrumentator().instrument(app).expose(app)

3. Log Aggregation

# docker-compose.yml
logging:
  driver: "json-file"
  options:
    max-size: "10m"
    max-file: "3"

Backup & Recovery

Backup Data

# Backup uploads and outputs
docker run --rm \
  -v DanceDynamics_uploads:/uploads \
  -v DanceDynamics_outputs:/outputs \
  -v $(pwd)/backup:/backup \
  alpine \
  tar czf /backup/data-$(date +%Y%m%d).tar.gz /uploads /outputs

Restore Data

# Restore from backup
docker run --rm \
  -v DanceDynamics_uploads:/uploads \
  -v DanceDynamics_outputs:/outputs \
  -v $(pwd)/backup:/backup \
  alpine \
  tar xzf /backup/data-YYYYMMDD.tar.gz -C /

Security Best Practices

1. Use Secrets

# docker-compose.yml
secrets:
  api_key:
    file: ./secrets/api_key.txt

services:
  dance-analyzer:
    secrets:
      - api_key

2. Enable HTTPS

# main.py
from fastapi.middleware.httpsredirect import HTTPSRedirectMiddleware

app.add_middleware(HTTPSRedirectMiddleware)

3. Rate Limiting

from slowapi import Limiter
from slowapi.util import get_remote_address

limiter = Limiter(key_func=get_remote_address)
app.state.limiter = limiter

@app.post("/api/upload")
@limiter.limit("5/minute")
async def upload_video():
    pass

4. Input Validation

All inputs are validated. Ensure:

File size limits enforced
File types restricted
Path traversal prevented
SQL injection not applicable (no DB)

Troubleshooting

Container Won't Start

# Check logs
docker-compose logs dance-analyzer

# Common issues:
# 1. Port already in use
docker ps -a
sudo lsof -i :7860

# 2. Permission denied
sudo chown -R 1000:1000 uploads outputs logs

# 3. Out of memory
docker stats
# Increase memory limit in docker-compose.yml

High CPU Usage

# Check resource usage
docker stats dance-analyzer

# Reduce model complexity
# Edit docker-compose.yml
environment:
  - MEDIAPIPE_MODEL_COMPLEXITY=0

Slow Processing

# Increase workers
environment:
  - MAX_WORKERS=4

# Use GPU if available
# Requires nvidia-docker

Scaling

Horizontal Scaling

# docker-compose.yml
services:
  dance-analyzer:
    deploy:
      replicas: 3
    
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    depends_on:
      - dance-analyzer
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf

Load Balancer Configuration

upstream dance_analyzer {
    least_conn;
    server dance-analyzer-1:7860;
    server dance-analyzer-2:7860;
    server dance-analyzer-3:7860;
}

server {
    listen 80;
    
    location / {
        proxy_pass http://dance_analyzer;
    }
}

Cost Optimization

Cloud Costs

Platform	Cost/Month	Notes
Hugging Face Spaces	Free - $15	Good for demos
AWS EC2 t3.medium	$30 - $35	Pay for compute
Google Cloud Run	$10 - $50	Pay per use
DigitalOcean App	$12 - $24	Fixed pricing

Optimization Tips

Use spot instances (AWS, GCP)
Auto-scaling based on demand
Session cleanup to free resources
Caching to reduce processing
CDN for static files

CI/CD Pipeline

GitHub Actions

Create .github/workflows/deploy.yml:

name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Build and push Docker image
        run: |
          docker build -t dance-analyzer .
          echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
          docker tag dance-analyzer ${{ secrets.DOCKER_USERNAME }}/dance-analyzer:latest
          docker push ${{ secrets.DOCKER_USERNAME }}/dance-analyzer:latest
      
      - name: Deploy to server
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SSH_KEY }}
          script: |
            cd /app/DanceDynamics
            docker-compose pull
            docker-compose up -d

Maintenance

Regular Tasks

# Weekly: Clean old sessions
docker exec dance-analyzer python -c "
from app.utils import cleanup_old_sessions
cleanup_old_sessions(max_age_hours=168)
"

# Monthly: Update dependencies
docker-compose build --no-cache
docker-compose up -d

# As needed: Backup data
./scripts/backup.sh

Support & Monitoring

Set Up Alerts

# docker-compose.yml
services:
  dance-analyzer:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:7860/health"]
      interval: 30s
      timeout: 10s
      retries: 3

Monitor Metrics

Response time
Error rate
Active sessions
Memory usage
Disk space

Success Checklist

Application builds successfully
Docker container runs
Health check passes
Can upload video
Processing works
Can download result
HTTPS configured (production)
Monitoring set up
Backups configured
Documentation updated

Next Steps

Test deployment thoroughly
Set up monitoring
Configure backups
Optimize performance
Scale as needed