# Docker Deployment Guide **Last Updated**: 2025-10-22 **Target Environment**: Development, Staging, Production **Prerequisites**: Docker 24.0+, Docker Compose 2.20+ **Deployment Time**: 15-20 minutes --- ## Table of Contents 1. [Overview](#overview) 2. [Prerequisites](#prerequisites) 3. [Pre-Deployment Checklist](#pre-deployment-checklist) 4. [Deployment Steps](#deployment-steps) 5. [Service Health Verification](#service-health-verification) 6. [Post-Deployment Validation](#post-deployment-validation) 7. [Common Issues](#common-issues) 8. [Rollback Procedures](#rollback-procedures) --- ## Overview This guide covers deploying the Foxhunt HFT trading system using Docker Compose. The system consists of 9 services: ### Core Services - **API Gateway** (Port 50051): Authentication, routing, rate limiting - **Trading Service** (Port 50052): Order execution, position management - **Backtesting Service** (Port 50053): Strategy testing with historical data - **ML Training Service** (Port 50054): Model training and optimization - **Trading Agent Service** (Port 50055): Trading decision orchestration ### Infrastructure Services - **PostgreSQL** (Port 5432): TimescaleDB for market data and metrics - **Redis** (Port 6379): Caching and session management - **Vault** (Port 8200): Secrets management - **Grafana** (Port 3000): Monitoring dashboards ### Architecture Diagram ```mermaid graph TB subgraph "External Clients" TLI[TLI Terminal Client] API_CLIENT[API Clients] end subgraph "API Layer" GATEWAY[API Gateway
:50051] end subgraph "Core Services" TRADING[Trading Service
:50052] BACKTEST[Backtesting Service
:50053] ML_TRAIN[ML Training Service
:50054] AGENT[Trading Agent Service
:50055] end subgraph "Infrastructure" POSTGRES[(PostgreSQL
:5432)] REDIS[(Redis
:6379)] VAULT[Vault
:8200] GRAFANA[Grafana
:3000] end TLI --> GATEWAY API_CLIENT --> GATEWAY GATEWAY --> TRADING GATEWAY --> BACKTEST GATEWAY --> ML_TRAIN GATEWAY --> AGENT TRADING --> POSTGRES BACKTEST --> POSTGRES ML_TRAIN --> POSTGRES AGENT --> POSTGRES TRADING --> REDIS AGENT --> REDIS TRADING --> VAULT BACKTEST --> VAULT ML_TRAIN --> VAULT AGENT --> VAULT ``` --- ## Prerequisites ### System Requirements **Minimum** (Development): - **CPU**: 4 cores (8 threads recommended) - **RAM**: 16 GB - **Disk**: 50 GB SSD - **GPU**: Optional (CUDA 12.1+ for ML training) **Recommended** (Production): - **CPU**: 8 cores (16 threads) - **RAM**: 32 GB - **Disk**: 100 GB NVMe SSD - **GPU**: NVIDIA RTX 3050 Ti or better (4GB+ VRAM) ### Software Requirements ```bash # Verify Docker version docker --version # Required: 24.0+ # Docker version 24.0.7, build afdd53b # Verify Docker Compose version docker-compose --version # Required: 2.20+ # Docker Compose version v2.20.2 # Check disk space df -h /var/lib/docker # Filesystem Size Used Avail Use% Mounted on # /dev/sda1 100G 20G 80G 20% / # Check available memory free -h # total used free shared buff/cache available # Mem: 31Gi 2.0Gi 25Gi 100Mi 4.0Gi 28Gi # Optional: Verify GPU availability nvidia-smi # +-----------------------------------------------------------------------------+ # | NVIDIA-SMI 525.147.05 Driver Version: 525.147.05 CUDA Version: 12.1 | ``` ### Network Requirements **Required Ports** (must be available): - **50051**: API Gateway (gRPC) - **50052**: Trading Service (gRPC) - **50053**: Backtesting Service (gRPC) - **50054**: ML Training Service (gRPC) - **50055**: Trading Agent Service (gRPC) - **5432**: PostgreSQL - **6379**: Redis - **8200**: Vault - **3000**: Grafana - **9090**: Prometheus - **8086**: InfluxDB **Check port availability**: ```bash # Check if ports are already in use for port in 50051 50052 50053 50054 50055 5432 6379 8200 3000 9090 8086; do if lsof -i :$port > /dev/null 2>&1; then echo "ERROR: Port $port is already in use" lsof -i :$port else echo "OK: Port $port is available" fi done ``` --- ## Pre-Deployment Checklist Use this checklist before every deployment: ### 1. Infrastructure Validation - [ ] Docker daemon is running: `systemctl status docker` - [ ] Docker Compose is installed: `docker-compose --version` - [ ] Sufficient disk space (50+ GB): `df -h /var/lib/docker` - [ ] Sufficient memory (16+ GB): `free -h` - [ ] All required ports are available (see Network Requirements) - [ ] GPU is detected (if applicable): `nvidia-smi` ### 2. Configuration Validation - [ ] `.env` file exists in project root - [ ] Database credentials are set: `POSTGRES_PASSWORD` - [ ] Vault token is set: `VAULT_TOKEN` - [ ] Redis password is set (if applicable) - [ ] TLS certificates are present (production only) - [ ] Backup strategy is configured ### 3. Code Validation - [ ] Latest code is pulled: `git pull origin main` - [ ] All tests pass: `cargo test --workspace` - [ ] Code compiles cleanly: `cargo build --release --workspace` - [ ] No pending database migrations: `cargo sqlx migrate info` - [ ] Docker images build successfully: `docker-compose build` ### 4. Data Validation - [ ] Market data files are available in `test_data/` - [ ] ML models are trained and saved in `ml/trained_models/` - [ ] Database backup is recent (< 24 hours old) - [ ] S3 buckets are accessible (production only) --- ## Deployment Steps ### Step 1: Clone Repository and Configure Environment ```bash # Clone repository cd /opt sudo git clone https://github.com/your-org/foxhunt.git cd foxhunt # Create .env file from template cp .env.example .env # Edit .env with production values nano .env ``` **Required `.env` Variables**: ```bash # Database POSTGRES_USER=foxhunt POSTGRES_PASSWORD= POSTGRES_DB=foxhunt DATABASE_URL=postgresql://foxhunt:@postgres:5432/foxhunt # Redis REDIS_URL=redis://redis:6379 REDIS_PASSWORD= # Vault VAULT_ADDR=http://vault:8200 VAULT_TOKEN= # Environment ENVIRONMENT=production RUST_LOG=info # GPU (optional) CUDA_VISIBLE_DEVICES=0 ``` ### Step 2: Build Docker Images ```bash # Build all services (5-10 minutes) docker-compose build --parallel # Verify images are created docker images | grep foxhunt # foxhunt_api_gateway latest 1.2GB # foxhunt_trading_service latest 1.1GB # foxhunt_backtesting_service latest 1.0GB # foxhunt_ml_training_service latest 1.5GB # foxhunt_trading_agent latest 1.1GB ``` **Build Performance Optimization**: ```bash # Use BuildKit for faster builds export DOCKER_BUILDKIT=1 export COMPOSE_DOCKER_CLI_BUILD=1 # Build with cache from registry (production) docker-compose build --build-arg BUILDKIT_INLINE_CACHE=1 --pull ``` ### Step 3: Initialize Infrastructure Services **Start infrastructure services first** (PostgreSQL, Redis, Vault): ```bash # Start infrastructure only docker-compose up -d postgres redis vault # Wait for services to be healthy (30-60 seconds) docker-compose ps # NAME COMMAND SERVICE STATUS PORTS # foxhunt-postgres-1 "docker-entrypoint.s…" postgres Up 30 seconds 0.0.0.0:5432->5432/tcp # foxhunt-redis-1 "docker-entrypoint.s…" redis Up 30 seconds 0.0.0.0:6379->6379/tcp # foxhunt-vault-1 "docker-entrypoint.s…" vault Up 30 seconds 0.0.0.0:8200->8200/tcp # Verify PostgreSQL is ready docker-compose exec postgres pg_isready -U foxhunt # /var/run/postgresql:5432 - accepting connections # Verify Redis is ready docker-compose exec redis redis-cli ping # PONG ``` ### Step 4: Apply Database Migrations ```bash # Run migrations (uses sqlx-cli in Docker container) docker-compose run --rm api_gateway sqlx migrate run # Verify migrations applied docker-compose exec postgres psql -U foxhunt -d foxhunt -c "\dt" # List of relations # Schema | Name | Type | Owner # --------+-----------------------------+-------+--------- # public | _sqlx_migrations | table | foxhunt # public | orders | table | foxhunt # public | positions | table | foxhunt # public | regime_states | table | foxhunt # public | regime_transitions | table | foxhunt # public | adaptive_strategy_metrics | table | foxhunt # (45 rows) # Verify migration version docker-compose exec postgres psql -U foxhunt -d foxhunt -c \ "SELECT version, description FROM _sqlx_migrations ORDER BY version DESC LIMIT 5;" # version | description # ---------+---------------------------------------------------- # 045 | Add regime detection tables # 044 | Add adaptive strategy metrics # 043 | Add feature extraction metadata # (45 rows) ``` ### Step 5: Initialize Vault ```bash # Unseal Vault (development mode - auto-unsealed) # Production: Manually unseal with 3 of 5 keys docker-compose exec vault vault status # Sealed: false # Version: 1.15.2 # Load secrets into Vault docker-compose exec vault vault kv put secret/foxhunt/database \ url=postgresql://foxhunt:@postgres:5432/foxhunt \ username=foxhunt \ password= docker-compose exec vault vault kv put secret/foxhunt/redis \ url=redis://redis:6379 \ password= docker-compose exec vault vault kv put secret/foxhunt/jwt \ secret= # Verify secrets are stored docker-compose exec vault vault kv list secret/foxhunt # Keys # ---- # database # jwt # redis ``` ### Step 6: Start Application Services ```bash # Start all application services docker-compose up -d api_gateway trading_service backtesting_service \ ml_training_service trading_agent # Wait for services to be healthy (60-90 seconds) watch -n 5 'docker-compose ps' # Verify all services are running docker-compose ps # NAME STATUS PORTS # foxhunt-api_gateway-1 Up 60 seconds 0.0.0.0:50051->50051/tcp # foxhunt-trading_service-1 Up 60 seconds 0.0.0.0:50052->50052/tcp # foxhunt-backtesting_service-1 Up 60 seconds 0.0.0.0:50053->50053/tcp # foxhunt-ml_training_service-1 Up 60 seconds 0.0.0.0:50054->50054/tcp # foxhunt-trading_agent-1 Up 60 seconds 0.0.0.0:50055->50055/tcp ``` ### Step 7: Start Monitoring Services ```bash # Start Grafana and Prometheus docker-compose up -d grafana prometheus influxdb # Verify monitoring stack docker-compose ps grafana prometheus influxdb # NAME STATUS PORTS # foxhunt-grafana-1 Up 30 seconds 0.0.0.0:3000->3000/tcp # foxhunt-prometheus-1 Up 30 seconds 0.0.0.0:9090->9090/tcp # foxhunt-influxdb-1 Up 30 seconds 0.0.0.0:8086->8086/tcp ``` --- ## Service Health Verification ### 1. Infrastructure Health Checks ```bash # PostgreSQL health check docker-compose exec postgres pg_isready -U foxhunt # Expected: /var/run/postgresql:5432 - accepting connections # Redis health check docker-compose exec redis redis-cli ping # Expected: PONG # Vault health check docker-compose exec vault vault status | grep Sealed # Expected: Sealed: false ``` ### 2. Application Health Checks **gRPC Health Probes** (requires `grpc_health_probe`): ```bash # Install grpc_health_probe (first time only) wget -qO /usr/local/bin/grpc_health_probe \ https://github.com/grpc-ecosystem/grpc-health-probe/releases/download/v0.4.19/grpc_health_probe-linux-amd64 chmod +x /usr/local/bin/grpc_health_probe # API Gateway health grpc_health_probe -addr=localhost:50051 # status: SERVING # Trading Service health grpc_health_probe -addr=localhost:50052 # status: SERVING # Backtesting Service health grpc_health_probe -addr=localhost:50053 # status: SERVING # ML Training Service health grpc_health_probe -addr=localhost:50054 # status: SERVING # Trading Agent Service health grpc_health_probe -addr=localhost:50055 # status: SERVING ``` **HTTP Health Endpoints**: ```bash # API Gateway curl -f http://localhost:8080/health # {"status":"healthy","timestamp":"2025-10-22T10:00:00Z","version":"0.1.0"} # Trading Service curl -f http://localhost:8081/health # {"status":"healthy","uptime_seconds":120} # Backtesting Service curl -f http://localhost:8082/health # {"status":"healthy","uptime_seconds":120} # ML Training Service curl -f http://localhost:8095/health # {"status":"healthy","gpu_available":true} ``` ### 3. Metrics Health Checks ```bash # Verify Prometheus scraping curl -s http://localhost:9090/api/v1/targets | jq '.data.activeTargets[] | {job: .labels.job, health: .health}' # Expected output: # {"job":"api_gateway","health":"up"} # {"job":"trading_service","health":"up"} # {"job":"backtesting_service","health":"up"} # {"job":"ml_training_service","health":"up"} # {"job":"trading_agent","health":"up"} # Verify Grafana is accessible curl -f http://localhost:3000/api/health # {"database":"ok","version":"10.1.5"} ``` --- ## Post-Deployment Validation ### 1. Database Connectivity Test ```bash # Test database connection from each service for service in api_gateway trading_service backtesting_service ml_training_service trading_agent; do echo "Testing $service database connection..." docker-compose exec $service sh -c \ 'psql $DATABASE_URL -c "SELECT 1 as connection_test;" 2>&1' | grep -q "connection_test" if [ $? -eq 0 ]; then echo "✓ $service: Database connection OK" else echo "✗ $service: Database connection FAILED" fi done ``` ### 2. Redis Connectivity Test ```bash # Test Redis connection for service in trading_service trading_agent; do echo "Testing $service Redis connection..." docker-compose exec $service sh -c \ 'redis-cli -u $REDIS_URL ping 2>&1' | grep -q "PONG" if [ $? -eq 0 ]; then echo "✓ $service: Redis connection OK" else echo "✗ $service: Redis connection FAILED" fi done ``` ### 3. Vault Connectivity Test ```bash # Test Vault connection from each service for service in api_gateway trading_service backtesting_service ml_training_service trading_agent; do echo "Testing $service Vault connection..." docker-compose exec $service sh -c \ 'vault status 2>&1' | grep -q "Sealed.*false" if [ $? -eq 0 ]; then echo "✓ $service: Vault connection OK" else echo "✗ $service: Vault connection FAILED" fi done ``` ### 4. End-to-End Smoke Test ```bash # Test TLI authentication tli auth login --username admin --password # Expected: Login successful. Token saved to ~/.foxhunt/token # Test trading command tli trade order submit --symbol ES.FUT --action BUY --quantity 1 --order-type MARKET # Expected: Order submitted successfully. Order ID: # Test backtesting command tli backtest run --strategy ml --start-date 2025-01-01 --end-date 2025-10-01 # Expected: Backtest started. Job ID: # Test ML prediction tli trade ml predictions --symbol ES.FUT --limit 1 # Expected: [{symbol: "ES.FUT", prediction: 0.65, confidence: 0.82, timestamp: "..."}] ``` ### 5. Performance Baseline Test ```bash # Measure API Gateway latency (P50, P95, P99) for i in {1..1000}; do curl -w "@curl-format.txt" -o /dev/null -s http://localhost:8080/health done | awk '{sum+=$1; sumsq+=($1)^2} END { print "P50: " sum/NR " ms" print "P95: " (sqrt(sumsq/NR - (sum/NR)^2) * 1.645 + sum/NR) " ms" print "P99: " (sqrt(sumsq/NR - (sum/NR)^2) * 2.326 + sum/NR) " ms" }' # Expected: # P50: 0.5 ms # P95: 2.0 ms # P99: 5.0 ms # curl-format.txt: # %{time_total} ``` --- ## Common Issues ### Issue 1: Port Already in Use **Symptom**: ``` Error starting userland proxy: listen tcp4 0.0.0.0:50051: bind: address already in use ``` **Diagnosis**: ```bash # Find process using port 50051 lsof -i :50051 # COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME # api_gatew 12345 foxhunt 10u IPv4 123456 0t0 TCP *:50051 (LISTEN) ``` **Solution**: ```bash # Option 1: Stop the conflicting process kill -9 12345 # Option 2: Change port in docker-compose.yml # Edit docker-compose.yml and change: # ports: # - "50051:50051" # Change to "50052:50051" # Option 3: Stop old containers docker-compose down docker-compose up -d ``` ### Issue 2: Database Migration Failed **Symptom**: ``` ERROR: relation "orders" already exists ``` **Diagnosis**: ```bash # Check migration status docker-compose exec postgres psql -U foxhunt -d foxhunt -c \ "SELECT version, success FROM _sqlx_migrations ORDER BY version DESC LIMIT 5;" ``` **Solution**: ```bash # Option 1: Rollback failed migration docker-compose run --rm api_gateway sqlx migrate revert # Option 2: Reset database (DESTRUCTIVE - development only) docker-compose down -v docker-compose up -d postgres sleep 10 docker-compose run --rm api_gateway sqlx migrate run # Option 3: Manual fix docker-compose exec postgres psql -U foxhunt -d foxhunt # foxhunt=# DROP TABLE IF EXISTS orders CASCADE; # foxhunt=# \q docker-compose run --rm api_gateway sqlx migrate run ``` ### Issue 3: Vault Sealed **Symptom**: ``` Error reading secret: Error making API request. Code: 503. Errors: * Vault is sealed ``` **Diagnosis**: ```bash docker-compose exec vault vault status # Sealed: true ``` **Solution**: ```bash # Development mode: Restart Vault docker-compose restart vault # Production mode: Unseal with keys docker-compose exec vault vault operator unseal docker-compose exec vault vault operator unseal docker-compose exec vault vault operator unseal # (Requires 3 of 5 unseal keys) ``` ### Issue 4: GPU Not Available **Symptom**: ``` CUDA error: no kernel image is available for execution on the device ``` **Diagnosis**: ```bash # Check GPU visibility in container docker-compose exec ml_training_service nvidia-smi # If "nvidia-smi: command not found": GPU passthrough not configured # Check NVIDIA runtime docker info | grep -i runtime # Runtimes: nvidia runc ``` **Solution**: ```bash # Install NVIDIA Container Toolkit distribution=$(. /etc/os-release;echo $ID$VERSION_ID) curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \ sudo tee /etc/apt/sources.list.d/nvidia-docker.list sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit # Restart Docker daemon sudo systemctl restart docker # Update docker-compose.yml to use nvidia runtime # ml_training_service: # runtime: nvidia # environment: # - NVIDIA_VISIBLE_DEVICES=all # Restart services docker-compose down docker-compose up -d ``` ### Issue 5: Out of Memory (OOM) **Symptom**: ``` Container exited with code 137 (OOM killed) ``` **Diagnosis**: ```bash # Check container memory usage docker stats --no-stream # CONTAINER CPU % MEM USAGE / LIMIT MEM % # foxhunt-ml_train-1 150% 2.5GiB / 4GiB 62.5% # Check system memory free -h # total used free # Mem: 16Gi 15Gi 500Mi # <-- Insufficient free memory ``` **Solution**: ```bash # Option 1: Increase Docker memory limit # Edit /etc/docker/daemon.json: # { # "default-ulimits": { # "memlock": {"Name": "memlock", "Hard": -1, "Soft": -1} # }, # "memory": "8g" # Increase from default # } sudo systemctl restart docker # Option 2: Add memory limits to docker-compose.yml # ml_training_service: # deploy: # resources: # limits: # memory: 8G # reservations: # memory: 4G # Option 3: Enable swap (not recommended for production) sudo swapon -s sudo fallocate -l 8G /swapfile sudo chmod 600 /swapfile sudo mkswap /swapfile sudo swapon /swapfile ``` --- ## Rollback Procedures See [rollback-procedures.md](rollback-procedures.md) for detailed rollback steps. **Quick Rollback** (5 minutes): ```bash # 1. Stop all services docker-compose down # 2. Restore database from backup docker-compose up -d postgres sleep 10 docker-compose exec postgres psql -U foxhunt -d foxhunt < /backup/foxhunt_backup_2025-10-22.sql # 3. Checkout previous version git checkout # 4. Rebuild and restart docker-compose build --parallel docker-compose up -d # 5. Verify health grpc_health_probe -addr=localhost:50051 ``` --- ## Appendix ### A. Docker Compose Configuration **File**: `docker-compose.yml` ```yaml version: '3.8' services: # Infrastructure Services postgres: image: timescale/timescaledb:latest-pg15 container_name: foxhunt-postgres environment: POSTGRES_USER: ${POSTGRES_USER} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} POSTGRES_DB: ${POSTGRES_DB} ports: - "5432:5432" volumes: - postgres_data:/var/lib/postgresql/data healthcheck: test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"] interval: 10s timeout: 5s retries: 5 networks: - foxhunt_network redis: image: redis:7-alpine container_name: foxhunt-redis command: redis-server --requirepass ${REDIS_PASSWORD} ports: - "6379:6379" volumes: - redis_data:/data healthcheck: test: ["CMD", "redis-cli", "ping"] interval: 10s timeout: 5s retries: 5 networks: - foxhunt_network vault: image: vault:1.15 container_name: foxhunt-vault environment: VAULT_DEV_ROOT_TOKEN_ID: ${VAULT_TOKEN} VAULT_DEV_LISTEN_ADDRESS: 0.0.0.0:8200 ports: - "8200:8200" cap_add: - IPC_LOCK networks: - foxhunt_network # Application Services api_gateway: build: context: . dockerfile: services/api_gateway/Dockerfile container_name: foxhunt-api-gateway environment: DATABASE_URL: ${DATABASE_URL} REDIS_URL: ${REDIS_URL} VAULT_ADDR: ${VAULT_ADDR} VAULT_TOKEN: ${VAULT_TOKEN} RUST_LOG: ${RUST_LOG} ports: - "50051:50051" # gRPC - "8080:8080" # Health - "9091:9091" # Metrics depends_on: - postgres - redis - vault networks: - foxhunt_network trading_service: build: context: . dockerfile: services/trading_service/Dockerfile container_name: foxhunt-trading-service environment: DATABASE_URL: ${DATABASE_URL} REDIS_URL: ${REDIS_URL} VAULT_ADDR: ${VAULT_ADDR} VAULT_TOKEN: ${VAULT_TOKEN} RUST_LOG: ${RUST_LOG} ports: - "50052:50052" # gRPC - "8081:8081" # Health - "9092:9092" # Metrics depends_on: - postgres - redis - vault networks: - foxhunt_network backtesting_service: build: context: . dockerfile: services/backtesting_service/Dockerfile container_name: foxhunt-backtesting-service environment: DATABASE_URL: ${DATABASE_URL} VAULT_ADDR: ${VAULT_ADDR} VAULT_TOKEN: ${VAULT_TOKEN} RUST_LOG: ${RUST_LOG} ports: - "50053:50053" # gRPC - "8082:8082" # Health - "9093:9093" # Metrics depends_on: - postgres - vault volumes: - ./test_data:/app/test_data:ro networks: - foxhunt_network ml_training_service: build: context: . dockerfile: services/ml_training_service/Dockerfile container_name: foxhunt-ml-training-service runtime: nvidia # Requires NVIDIA Container Toolkit environment: DATABASE_URL: ${DATABASE_URL} VAULT_ADDR: ${VAULT_ADDR} VAULT_TOKEN: ${VAULT_TOKEN} RUST_LOG: ${RUST_LOG} CUDA_VISIBLE_DEVICES: ${CUDA_VISIBLE_DEVICES} ports: - "50054:50054" # gRPC - "8095:8095" # Health - "9094:9094" # Metrics depends_on: - postgres - vault volumes: - ./test_data:/app/test_data:ro - ./ml/trained_models:/app/ml/trained_models networks: - foxhunt_network trading_agent: build: context: . dockerfile: services/trading_agent/Dockerfile container_name: foxhunt-trading-agent environment: DATABASE_URL: ${DATABASE_URL} REDIS_URL: ${REDIS_URL} VAULT_ADDR: ${VAULT_ADDR} VAULT_TOKEN: ${VAULT_TOKEN} RUST_LOG: ${RUST_LOG} ports: - "50055:50055" # gRPC - "8083:8083" # Health - "9095:9095" # Metrics depends_on: - postgres - redis - vault networks: - foxhunt_network # Monitoring Services prometheus: image: prom/prometheus:latest container_name: foxhunt-prometheus ports: - "9090:9090" volumes: - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro - prometheus_data:/prometheus command: - '--config.file=/etc/prometheus/prometheus.yml' - '--storage.tsdb.path=/prometheus' - '--storage.tsdb.retention.time=30d' networks: - foxhunt_network grafana: image: grafana/grafana:latest container_name: foxhunt-grafana environment: GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_PASSWORD} GF_USERS_ALLOW_SIGN_UP: "false" ports: - "3000:3000" volumes: - grafana_data:/var/lib/grafana - ./monitoring/grafana/dashboards:/etc/grafana/provisioning/dashboards:ro - ./monitoring/grafana/datasources:/etc/grafana/provisioning/datasources:ro depends_on: - prometheus networks: - foxhunt_network influxdb: image: influxdb:2.7-alpine container_name: foxhunt-influxdb environment: DOCKER_INFLUXDB_INIT_MODE: setup DOCKER_INFLUXDB_INIT_USERNAME: ${INFLUXDB_USER} DOCKER_INFLUXDB_INIT_PASSWORD: ${INFLUXDB_PASSWORD} DOCKER_INFLUXDB_INIT_ORG: foxhunt DOCKER_INFLUXDB_INIT_BUCKET: metrics ports: - "8086:8086" volumes: - influxdb_data:/var/lib/influxdb2 networks: - foxhunt_network volumes: postgres_data: redis_data: prometheus_data: grafana_data: influxdb_data: networks: foxhunt_network: driver: bridge ``` ### B. Resource Limits Reference | Service | CPU Limit | Memory Limit | GPU Memory | |---------|-----------|--------------|------------| | API Gateway | 2 cores | 512 MB | N/A | | Trading Service | 2 cores | 1 GB | N/A | | Backtesting Service | 4 cores | 2 GB | N/A | | ML Training Service | 8 cores | 8 GB | 440 MB | | Trading Agent | 2 cores | 1 GB | N/A | | PostgreSQL | 4 cores | 4 GB | N/A | | Redis | 1 core | 512 MB | N/A | ### C. Deployment Timeline Reference | Phase | Duration | Critical Path | |-------|----------|---------------| | Pre-deployment checks | 5 min | Yes | | Build Docker images | 10 min | Yes | | Start infrastructure | 2 min | Yes | | Apply migrations | 1 min | Yes | | Start app services | 3 min | Yes | | Health verification | 2 min | Yes | | Post-deployment validation | 5 min | No | | **Total** | **15-20 min** | - | --- **End of Docker Deployment Guide**