Docker Compose Deployment

Docker Compose provides the simplest way to deploy Probo with all required services on a single server. This deployment method is ideal for:

Small to medium organizations
Development and testing environments
Single-server production deployments
Quick proof-of-concept setups

Prerequisites

Docker 20.10+
Docker Compose 2.0+
4 GB RAM minimum
20 GB storage space

Quick Start

Download the production compose file:

curl -o compose.prod.yaml https://raw.githubusercontent.com/getprobo/probo/main/compose.prod.yaml

Generate required secrets:

export PROBOD_ENCRYPTION_KEY=$(openssl rand -base64 32)
export AUTH_COOKIE_SECRET=$(openssl rand -base64 32)
export AUTH_PASSWORD_PEPPER=$(openssl rand -base64 32)
export TRUST_AUTH_TOKEN_SECRET=$(openssl rand -base64 32)

Create environment file:

cat > .env << EOF
# Required secrets
PROBOD_ENCRYPTION_KEY=${PROBOD_ENCRYPTION_KEY}
AUTH_COOKIE_SECRET=${AUTH_COOKIE_SECRET}
AUTH_PASSWORD_PEPPER=${AUTH_PASSWORD_PEPPER}
TRUST_AUTH_TOKEN_SECRET=${TRUST_AUTH_TOKEN_SECRET}

# Application settings
PROBOD_BASE_URL=https://your-domain.com
API_ADDR=0.0.0.0:8080
API_CORS_ALLOWED_ORIGINS=https://your-domain.com

# Email settings (configure your SMTP)
SMTP_ADDR=smtp.example.com:587
SMTP_TLS_REQUIRED=true
[email protected]
EOF

Start the services:

docker compose -f compose.prod.yaml up -d

Verify deployment:

# Check service health
curl http://localhost:8080/health
# View logs
docker compose -f compose.prod.yaml logs -f probo

Production Configuration

TLS/SSL Setup

For production, configure TLS certificates:

services:
  probo:
    environment:
      PROBOD_BASE_URL: "https://your-domain.com"
    volumes:
      - "/path/to/ssl/cert.pem:/etc/ssl/cert.pem:ro"
      - "/path/to/ssl/key.pem:/etc/ssl/key.pem:ro"

External Database

To use an external PostgreSQL database:

services:
  probo:
    environment:
      PG_ADDR: "your-db-host:5432"
      PG_USERNAME: "probod"
      PG_PASSWORD: "your-secure-password"
      PG_DATABASE: "probod"
    depends_on: []

# Remove the postgres service
postgres:
  deploy:
    replicas: 0

External S3 Storage

To use AWS S3 or another S3-compatible service:

services:
  probo:
    environment:
      AWS_REGION: "us-east-1"
      AWS_BUCKET: "your-probo-bucket"
      AWS_ACCESS_KEY_ID: "your-access-key"
      AWS_SECRET_ACCESS_KEY: "your-secret-key"
      # Remove AWS_ENDPOINT for AWS S3
      # AWS_ENDPOINT: ""

# Remove MinIO service
minio:
  deploy:
    replicas: 0

Service Architecture

The Docker Compose deployment includes:

Core Services

probo - Main application (ports 8080, 8081, 8443)
postgres - PostgreSQL database (port 5432)
minio - S3-compatible storage (ports 9000, 9001)
chrome - PDF generation service (port 9222)

Networking

Services communicate over a dedicated Docker network with automatic service discovery.

Data Persistence

probo-data - Application data and uploads
postgres-data - Database files
minio-data - Object storage files

Load Balancer Setup

For high availability, place Probo behind a load balancer:

Nginx Configuration

upstream probo {
    server 127.0.0.1:8080;
    # Add more servers for HA
    # server 127.0.0.1:8081;
}

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

    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;

    location / {
        proxy_pass http://probo;
        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;
    }
}

HAProxy Configuration

global
    log stdout local0
    chroot /var/lib/haproxy
    stats socket /run/haproxy/admin.sock mode 660

defaults
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms

frontend probo_frontend
    bind *:443 ssl crt /path/to/cert.pem
    redirect scheme https if !{ ssl_fc }
    default_backend probo_backend

backend probo_backend
    balance roundrobin
    server probo1 127.0.0.1:8080 check
    # Add more servers for HA
    # server probo2 127.0.0.1:8081 check

Monitoring

Health Checks

# Application health
curl http://localhost:8080/health

# Metrics endpoint
curl http://localhost:8081/metrics

# Database connectivity
docker compose exec postgres pg_isready -U postgres

# MinIO health
curl http://localhost:9000/minio/health/live

Log Management

# View all service logs
docker compose -f compose.prod.yaml logs -f

# Specific service logs
docker compose -f compose.prod.yaml logs -f probo
docker compose -f compose.prod.yaml logs -f postgres

# Configure log rotation
docker compose -f compose.prod.yaml logs --follow --tail=100

Backup and Recovery

Database Backup

# Create backup
docker compose exec postgres pg_dump -U postgres probod > backup.sql

# Restore backup
docker compose exec -T postgres psql -U postgres probod < backup.sql

File Storage Backup

# Backup MinIO data
docker run --rm -v probo_minio-data:/data -v $(pwd):/backup alpine \
  tar czf /backup/minio-backup.tar.gz -C /data .

# Restore MinIO data
docker run --rm -v probo_minio-data:/data -v $(pwd):/backup alpine \
  tar xzf /backup/minio-backup.tar.gz -C /data

Troubleshooting

Common Issues

Port conflicts:

# Check port usage
netstat -tulpn | grep :8080

# Change ports in compose file
ports:
  - "8081:8080"  # Use different host port

Database connection errors:

# Check database logs
docker compose logs postgres

# Test connection
docker compose exec probo pg_isready -h postgres -U postgres

File permission issues:

# Fix volume permissions
sudo chown -R 999:999 postgres-data/

Performance Tuning

For better performance, adjust resource limits:

services:
  probo:
    deploy:
      resources:
        limits:
          cpus: "2.0"
          memory: 4G
        reservations:
          cpus: "1.0"
          memory: 2G

  postgres:
    deploy:
      resources:
        limits:
          cpus: "2.0"
          memory: 4G

Security Considerations

Use strong secrets - Generate cryptographically secure secrets
Enable TLS - Always use HTTPS in production
Network isolation - Use Docker networks to isolate services
Regular updates - Keep Docker images updated
Backup encryption - Encrypt backups at rest and in transit

Upgrading

# Pull latest images
docker compose -f compose.prod.yaml pull

# Restart services with new images
docker compose -f compose.prod.yaml up -d

# Check logs for any issues
docker compose -f compose.prod.yaml logs -f probo