Odoo Docker Deployment: Production Guide

services:
  odoo:
    image: odoo:19.0
    depends_on: [db]
    ports:
      - "8069:8069"
    environment:
      - HOST=db
      - USER=odoo
      - PASSWORD=odoo
  db:
    image: postgres:16
    environment:
      - POSTGRES_USER=odoo
      - POSTGRES_PASSWORD=odoo
      - POSTGRES_DB=postgres

odoo-docker/
├── docker-compose.yml          # Main compose file
├── docker-compose.override.yml # Development overrides
├── .env                        # Environment variables
├── nginx/
│   └── odoo.conf              # Nginx configuration
├── addons/
│   └── custom_modules/        # Your custom Odoo modules
├── config/
│   └── odoo.conf              # Odoo configuration file
└── backups/
    └── .gitkeep               # Backup storage directory

mkdir -p odoo-docker/{nginx,addons/custom_modules,config,backups}
cd odoo-docker
touch docker-compose.yml .env
touch nginx/odoo.conf config/odoo.conf

version: '3.8'

services:
  odoo:
    image: odoo:19.0
    container_name: odoo
    depends_on:
      - db
    ports:
      - "8069:8069"
      - "8072:8072"  # Longpolling port
    volumes:
      - odoo-data:/var/lib/odoo
      - ./addons:/mnt/extra-addons
      - ./config:/etc/odoo
    environment:
      - HOST=db
      - USER=odoo
      - PASSWORD=${POSTGRES_PASSWORD}
    command: ["--proxy-mode"]
    restart: unless-stopped
    networks:
      - odoo-network

  db:
    image: postgres:15
    container_name: odoo-db
    environment:
      - POSTGRES_USER=odoo
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=postgres
      - PGDATA=/var/lib/postgresql/data/pgdata
    volumes:
      - postgres-data:/var/lib/postgresql/data/pgdata
    restart: unless-stopped
    networks:
      - odoo-network
    # Uncomment for external access (not recommended for production)
    # ports:
    #   - "5432:5432"

  nginx:
    image: nginx:alpine
    container_name: odoo-nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/odoo.conf:/etc/nginx/conf.d/default.conf:ro
      - ./certbot/conf:/etc/letsencrypt:ro
      - ./certbot/www:/var/www/certbot:ro
    depends_on:
      - odoo
    restart: unless-stopped
    networks:
      - odoo-network

volumes:
  odoo-data:
  postgres-data:

networks:
  odoo-network:
    driver: bridge

# Database Configuration
POSTGRES_PASSWORD=your_secure_password_here

# Odoo Configuration (optional overrides)
ODOO_DB_HOST=db
ODOO_DB_PORT=5432
ODOO_DB_USER=odoo

# Domain Configuration
DOMAIN=erp.yourcompany.com

# Email Configuration (optional)
SMTP_HOST=smtp.yourprovider.com
SMTP_PORT=587
SMTP_USER=your_email@yourcompany.com
SMTP_PASSWORD=your_smtp_password

[options]
addons_path = /mnt/extra-addons
data_dir = /var/lib/odoo

# Database settings
db_host = db
db_port = 5432
db_user = odoo
db_password = False  # Set via environment variable

# Performance tuning
workers = 4
max_cron_threads = 2
limit_memory_hard = 2684354560
limit_memory_soft = 2147483648
limit_time_cpu = 600
limit_time_real = 1200

# Proxy settings
proxy_mode = True

# Logging
logfile = /var/log/odoo/odoo.log
log_level = info

upstream odoo {
    server odoo:8069;
}

upstream odoo-longpolling {
    server odoo:8072;
}

# HTTP - redirect all requests to HTTPS
server {
    listen 80;
    server_name erp.yourcompany.com;

    # Let's Encrypt challenge
    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 301 https://$host$request_uri;
    }
}

# HTTPS
server {
    listen 443 ssl http2;
    server_name erp.yourcompany.com;

    # SSL certificates
    ssl_certificate /etc/letsencrypt/live/erp.yourcompany.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/erp.yourcompany.com/privkey.pem;

    # SSL settings
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:50m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers off;

    # Security headers
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    # Proxy settings
    proxy_read_timeout 720s;
    proxy_connect_timeout 720s;
    proxy_send_timeout 720s;
    proxy_set_header X-Forwarded-Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Real-IP $remote_addr;

    # Gzip compression
    gzip on;
    gzip_types text/css text/plain text/xml application/xml application/javascript application/json;
    gzip_min_length 1000;

    # Longpolling (real-time features)
    location /longpolling {
        proxy_pass http://odoo-longpolling;
    }

    # WebSocket support
    location /websocket {
        proxy_pass http://odoo-longpolling;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    # Main Odoo application
    location / {
        proxy_pass http://odoo;
        proxy_redirect off;
    }

    # Static files caching
    location ~* /web/static/ {
        proxy_pass http://odoo;
        proxy_cache_valid 200 60m;
        expires 24h;
        add_header Cache-Control "public, immutable";
    }

    # File upload size limit
    client_max_body_size 100M;
}

# Create directories for Certbot
mkdir -p certbot/conf certbot/www

# Start Nginx with a basic config first (HTTP only)
# Create a temporary nginx config that serves HTTP
cat > nginx/odoo.conf << 'EOF'
server {
    listen 80;
    server_name erp.yourcompany.com;

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 200 'OK';
        add_header Content-Type text/plain;
    }
}
EOF

# Start Nginx
docker compose up -d nginx

# Request SSL certificate
docker run -it --rm \
  -v ./certbot/conf:/etc/letsencrypt \
  -v ./certbot/www:/var/www/certbot \
  certbot/certbot certonly \
  --webroot \
  --webroot-path=/var/www/certbot \
  --email your@email.com \
  --agree-tos \
  --no-eff-email \
  -d erp.yourcompany.com

# Replace nginx config with the full SSL version (shown above)
# Then restart Nginx
docker compose restart nginx

# Set up auto-renewal (add to crontab)
0 0 1 * * docker run --rm -v ./certbot/conf:/etc/letsencrypt -v ./certbot/www:/var/www/certbot certbot/certbot renew --quiet && docker compose restart nginx

services:
  odoo:
    # Mount source code for live editing
    volumes:
      - ./custom-addons:/mnt/extra-addons
      - ./odoo.conf:/etc/odoo/odoo.conf
    # Enable developer mode with auto-reload
    command: ["--dev=reload,qweb,xml", "--proxy-mode"]
    # Expose debug port
    ports:
      - "8069:8069"
      - "8072:8072"

  # pgAdmin for database inspection
  pgadmin:
    image: dpage/pgadmin4
    ports:
      - "5050:80"
    environment:
      PGADMIN_DEFAULT_EMAIL: admin@example.com
      PGADMIN_DEFAULT_PASSWORD: admin
    depends_on: [db]

# List Docker volumes
docker volume ls

# Inspect a volume
docker volume inspect odoo-docker_odoo-data

# Find volume location on host
docker volume inspect odoo-docker_postgres-data --format '{{ .Mountpoint }}'

#!/bin/bash

# Configuration
BACKUP_DIR="./backups"
DATE=$(date +%Y%m%d_%H%M%S)
DB_CONTAINER="odoo-db"
DB_USER="odoo"
RETENTION_DAYS=30

# Create backup directory
mkdir -p $BACKUP_DIR

# Backup database
echo "Backing up database..."
docker exec $DB_CONTAINER pg_dumpall -U $DB_USER | gzip > "$BACKUP_DIR/db_backup_$DATE.sql.gz"

# Backup Odoo filestore
echo "Backing up filestore..."
docker run --rm \
  -v odoo-docker_odoo-data:/data:ro \
  -v $(pwd)/$BACKUP_DIR:/backup \
  alpine tar czf /backup/filestore_backup_$DATE.tar.gz -C /data .

# Remove old backups
echo "Removing backups older than $RETENTION_DAYS days..."
find $BACKUP_DIR -name "*.gz" -mtime +$RETENTION_DAYS -delete

echo "Backup completed: $DATE"
echo "Files:"
ls -lh $BACKUP_DIR/*_$DATE.*

# Restore database
gunzip -c backups/db_backup_20241220_030000.sql.gz | docker exec -i odoo-db psql -U odoo

# Restore filestore
docker run --rm \
  -v odoo-docker_odoo-data:/data \
  -v $(pwd)/backups:/backup:ro \
  alpine tar xzf /backup/filestore_backup_20241220_030000.tar.gz -C /data

# Install AWS CLI and configure credentials
# Then add to your backup script:

# Upload to S3
aws s3 cp $BACKUP_DIR/db_backup_$DATE.sql.gz s3://your-bucket/odoo-backups/
aws s3 cp $BACKUP_DIR/filestore_backup_$DATE.tar.gz s3://your-bucket/odoo-backups/

# Or use rclone for other providers (Backblaze B2, Cloudflare R2, etc.)
rclone copy $BACKUP_DIR remote:odoo-backups/