Docker PHP Deployment Guide

“It works on my machine” - the four words that have haunted PHP developers since 1995. Deploying PHP applications on Ubuntu servers has traditionally involved complex server configuration, dependency management, and environment consistency issues. Docker containers solve these problems by providing consistent, portable environments that work identically across development, staging, and production Ubuntu servers.

Note: This guide covers Docker deployment for PHP applications on Ubuntu servers. CloudPloy currently supports Laravel and WordPress applications with automated Docker deployment. Support for other PHP frameworks is coming soon.

Docker on Ubuntu Server: The Modern PHP Deployment Solution

Why Docker + Ubuntu Server for PHP Applications

Benefits of Containerized PHP on Ubuntu:

• Consistent environments across development, staging, and production
• Isolated dependencies preventing version conflicts
• Rapid deployment with predictable results
• Resource efficiency with container orchestration
• Easy scaling both vertically and horizontally
• Simplified rollbacks with container versioning

Prerequisites: Ubuntu Server Setup for Docker

Ubuntu Server Requirements:

• Ubuntu 24.04 LTS (recommended)
• Minimum 2GB RAM, 20GB storage
• Root or sudo access
• Static IP address for production

Initial Ubuntu Server Setup:

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

# Install essential packages
sudo apt install -y curl wget git unzip software-properties-common

# Configure firewall
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow 80
sudo ufw allow 443
sudo ufw --force enable

Docker Installation on Ubuntu:

# Install Docker dependencies
sudo apt install -y ca-certificates curl gnupg lsb-release

# Add Docker GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add Docker repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Add user to docker group
sudo usermod -aG docker $USER

# Start and enable Docker
sudo systemctl start docker
sudo systemctl enable docker

Docker Fundamentals for PHP on Ubuntu

Docker transforms PHP deployment on Ubuntu servers from manual configuration to automated, reproducible processes. One container definition works identically across all Ubuntu environments.

What Makes Docker Perfect for PHP?

1. Complete Environment Encapsulation:

# Your entire PHP universe in 15 lines
FROM php:8.3-fpm-alpine

# Install extensions ONCE
RUN docker-php-ext-install pdo_mysql opcache

# Configure PHP ONCE
COPY php.ini /usr/local/etc/php/

# Add your app
COPY . /var/www/html

# It works EVERYWHERE
CMD ["php-fpm"]

2. Guaranteed Consistency:

• Development laptop: ✅ PHP 8.3.1, MySQL 8.0, Redis 7.2
• CI/CD pipeline: ✅ PHP 8.3.1, MySQL 8.0, Redis 7.2
• Staging server: ✅ PHP 8.3.1, MySQL 8.0, Redis 7.2
• Production cluster: ✅ PHP 8.3.1, MySQL 8.0, Redis 7.2

3. Version Isolation:

# Run multiple PHP versions simultaneously
services:
  legacy_app:
    image: php:7.4-apache
    ports: 
      - "8074:80"
  
  current_app:
    image: php:8.2-apache
    ports:
      - "8082:80"
  
  beta_app:
    image: php:8.3-apache
    ports:
      - "8083:80"

Setting Up Docker Environment on Ubuntu

1. Verify Docker Installation

# Test Docker installation
docker --version
docker compose version

# Run hello-world container
docker run hello-world

# Check Docker status
sudo systemctl status docker

# Configure Docker to start on boot
sudo systemctl enable docker

2. Create Project Structure

# Create project directory
mkdir -p ~/docker-php-project
cd ~/docker-php-project

# Create directory structure
mkdir -p {
docker/{nginx,php,mysql},
src/public,
logs,
data/mysql
}

# Set proper permissions
sudo chown -R $USER:$USER ~/docker-php-project
chmod -R 755 ~/docker-php-project

3. Install Docker Compose (if not included)

# For older Ubuntu versions, install Docker Compose separately
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# Make it executable
sudo chmod +x /usr/local/bin/docker-compose

# Create symbolic link (optional)
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

# Verify installation
docker-compose --version

4. Configure System Resources for Docker

# Optimize Ubuntu for Docker workloads
echo 'vm.max_map_count=262144' | sudo tee -a /etc/sysctl.conf
echo 'fs.file-max=65536' | sudo tee -a /etc/sysctl.conf

# Apply changes
sudo sysctl -p

# Configure log rotation for Docker
sudo tee /etc/docker/daemon.json > /dev/null <<EOF
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}
EOF

# Restart Docker service
sudo systemctl restart docker

The Complete Docker PHP Architecture

Production-Ready PHP Dockerfile

# Multi-stage build for optimal size
FROM composer:2.6 AS composer
FROM node:20-alpine AS node

FROM php:8.3-fpm-alpine AS base

# Install system dependencies
RUN apk add --no-cache \
    nginx \
    supervisor \
    curl \
    zip \
    unzip \
    git \
    libpng-dev \
    libzip-dev \
    jpegoptim \
    optipng \
    pngquant \
    gifsicle \
    vim

# Install PHP extensions
RUN docker-php-ext-install \
    pdo_mysql \
    mbstring \
    zip \
    exif \
    pcntl \
    bcmath \
    gd \
    opcache

# Install Redis extension
RUN pecl install redis && docker-php-ext-enable redis

# Copy composer from composer image
COPY --from=composer /usr/bin/composer /usr/bin/composer

# Copy node from node image
COPY --from=node /usr/local/bin/node /usr/local/bin/node
COPY --from=node /usr/local/lib/node_modules /usr/local/lib/node_modules
RUN ln -s /usr/local/lib/node_modules/npm/bin/npm-cli.js /usr/local/bin/npm

# Configure PHP
COPY docker/php/php.ini /usr/local/etc/php/
COPY docker/php/php-fpm.conf /usr/local/etc/php-fpm.d/

# Configure Nginx
COPY docker/nginx/nginx.conf /etc/nginx/nginx.conf
COPY docker/nginx/default.conf /etc/nginx/conf.d/

# Configure Supervisor
COPY docker/supervisor/supervisord.conf /etc/supervisor/conf.d/

# Create application directory
WORKDIR /var/www/html

# Copy application files
COPY . .

# Install dependencies
RUN composer install --no-dev --optimize-autoloader
RUN npm ci && npm run build && rm -rf node_modules

# Set permissions
RUN chown -R www-data:www-data /var/www/html/storage /var/www/html/bootstrap/cache

# Health check
HEALTHCHECK --interval=30s --timeout=3s \
    CMD curl -f http://localhost/health || exit 1

# Start services
CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"]

Optimized PHP Configuration

; php.ini optimized for containers
[PHP]
memory_limit = 256M
max_execution_time = 30
upload_max_filesize = 20M
post_max_size = 20M
max_input_vars = 10000

[opcache]
opcache.enable = 1
opcache.memory_consumption = 256
opcache.interned_strings_buffer = 16
opcache.max_accelerated_files = 20000
opcache.revalidate_freq = 0
opcache.validate_timestamps = 0
opcache.save_comments = 1
opcache.fast_shutdown = 1
opcache.enable_file_override = 1
opcache.preload = /var/www/html/preload.php
opcache.preload_user = www-data

[Session]
session.cookie_httponly = 1
session.use_only_cookies = 1
session.cookie_secure = 1
session.cookie_samesite = Strict

[Security]
expose_php = Off
display_errors = Off
log_errors = On
error_log = /dev/stderr

Laravel + Docker: A Match Made in Heaven

Complete Laravel Docker Setup

# docker-compose.yml
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      target: production
    container_name: laravel_app
    restart: unless-stopped
    environment:
      - APP_ENV=production
      - APP_DEBUG=false
      - DB_CONNECTION=mysql
      - DB_HOST=mysql
      - DB_PORT=3306
      - DB_DATABASE=laravel
      - DB_USERNAME=laravel
      - DB_PASSWORD=${DB_PASSWORD}
      - REDIS_HOST=redis
      - QUEUE_CONNECTION=redis
      - CACHE_DRIVER=redis
      - SESSION_DRIVER=redis
    volumes:
      - ./storage:/var/www/html/storage
    depends_on:
      - mysql
      - redis
    networks:
      - laravel

  nginx:
    image: nginx:alpine
    container_name: laravel_nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./docker/nginx:/etc/nginx/conf.d
      - ./public:/var/www/html/public
      - ./docker/ssl:/etc/nginx/ssl
    depends_on:
      - app
    networks:
      - laravel

  mysql:
    image: mysql:8.0
    container_name: laravel_mysql
    restart: unless-stopped
    environment:
      - MYSQL_DATABASE=laravel
      - MYSQL_USER=laravel
      - MYSQL_PASSWORD=${DB_PASSWORD}
      - MYSQL_ROOT_PASSWORD=${DB_ROOT_PASSWORD}
    volumes:
      - mysql_data:/var/lib/mysql
      - ./docker/mysql/my.cnf:/etc/mysql/my.cnf
    ports:
      - "3306:3306"
    networks:
      - laravel

  redis:
    image: redis:7-alpine
    container_name: laravel_redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - laravel

  queue:
    build:
      context: .
      dockerfile: Dockerfile
      target: production
    container_name: laravel_queue
    restart: unless-stopped
    command: php artisan queue:work --sleep=3 --tries=3 --max-time=3600
    environment:
      - APP_ENV=production
    volumes:
      - ./:/var/www/html
    depends_on:
      - mysql
      - redis
    networks:
      - laravel

  scheduler:
    build:
      context: .
      dockerfile: Dockerfile
      target: production
    container_name: laravel_scheduler
    restart: unless-stopped
    command: /bin/sh -c "while true; do php artisan schedule:run --verbose --no-interaction & sleep 60; done"
    environment:
      - APP_ENV=production
    volumes:
      - ./:/var/www/html
    depends_on:
      - mysql
      - redis
    networks:
      - laravel

volumes:
  mysql_data:
  redis_data:

networks:
  laravel:
    driver: bridge

Laravel-Specific Dockerfile Optimizations

# Laravel optimized Dockerfile
FROM php:8.3-fpm-alpine AS base

# Laravel-specific PHP extensions
RUN docker-php-ext-install pdo_mysql bcmath

# Install additional extensions for Laravel
RUN apk add --no-cache \
    freetype-dev \
    libjpeg-turbo-dev \
    libpng-dev \
    && docker-php-ext-configure gd \
        --with-freetype \
        --with-jpeg \
    && docker-php-ext-install -j$(nproc) gd

# Production build
FROM base AS production

COPY . /var/www/html
WORKDIR /var/www/html

# Optimize for production
RUN composer install --no-dev --optimize-autoloader \
    && php artisan config:cache \
    && php artisan route:cache \
    && php artisan view:cache \
    && php artisan event:cache

# Development build
FROM base AS development

RUN apk add --no-cache nodejs npm
COPY . /var/www/html
WORKDIR /var/www/html

RUN composer install \
    && npm install \
    && npm run dev

WordPress Docker: Solving the Plugin Hell

WordPress Multi-Site Docker Configuration

version: '3.8'

services:
  wordpress:
    build:
      context: .
      dockerfile: Dockerfile.wordpress
    container_name: wp_multisite
    restart: unless-stopped
    environment:
      WORDPRESS_DB_HOST: mysql:3306
      WORDPRESS_DB_NAME: wordpress
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: ${DB_PASSWORD}
      WORDPRESS_CONFIG_EXTRA: |
        define('WP_ALLOW_MULTISITE', true);
        define('MULTISITE', true);
        define('SUBDOMAIN_INSTALL', false);
        define('DOMAIN_CURRENT_SITE', '${DOMAIN}');
        define('PATH_CURRENT_SITE', '/');
        define('SITE_ID_CURRENT_SITE', 1);
        define('BLOG_ID_CURRENT_SITE', 1);
        
        /* Performance */
        define('WP_CACHE', true);
        define('WP_CACHE_KEY_SALT', '${DOMAIN}');
        define('WP_REDIS_HOST', 'redis');
        define('WP_REDIS_PORT', 6379);
        
        /* Security */
        define('DISALLOW_FILE_EDIT', true);
        define('WP_AUTO_UPDATE_CORE', 'minor');
    volumes:
      - wp_content:/var/www/html/wp-content
      - ./themes:/var/www/html/wp-content/themes
      - ./plugins:/var/www/html/wp-content/plugins
      - ./uploads:/var/www/html/wp-content/uploads
    depends_on:
      - mysql
      - redis
    networks:
      - wordpress

  mysql:
    image: mariadb:10.11
    container_name: wp_mysql
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: ${DB_PASSWORD}
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - wordpress

  redis:
    image: redis:7-alpine
    container_name: wp_redis
    restart: unless-stopped
    volumes:
      - redis_data:/data
    networks:
      - wordpress

  phpmyadmin:
    image: phpmyadmin:latest
    container_name: wp_phpmyadmin
    restart: unless-stopped
    environment:
      PMA_HOST: mysql
      PMA_USER: wordpress
      PMA_PASSWORD: ${DB_PASSWORD}
    ports:
      - "8080:80"
    depends_on:
      - mysql
    networks:
      - wordpress

volumes:
  wp_content:
  mysql_data:
  redis_data:

networks:
  wordpress:
    driver: bridge

Custom WordPress Dockerfile with Performance Optimizations

FROM wordpress:6.5-php8.3-fpm-alpine

# Install additional PHP extensions for WordPress
RUN apk add --no-cache \
    imagemagick \
    imagemagick-dev \
    && pecl install imagick \
    && docker-php-ext-enable imagick

# Install WP-CLI
RUN curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar \
    && chmod +x wp-cli.phar \
    && mv wp-cli.phar /usr/local/bin/wp

# Install performance tools
RUN apk add --no-cache \
    nginx \
    supervisor

# Configure PHP for WordPress
RUN { \
        echo 'memory_limit=512M'; \
        echo 'upload_max_filesize=50M'; \
        echo 'post_max_size=50M'; \
        echo 'max_execution_time=300'; \
        echo 'max_input_vars=5000'; \
    } > /usr/local/etc/php/conf.d/wordpress.ini

# Configure OPcache for WordPress
RUN { \
        echo 'opcache.memory_consumption=256'; \
        echo 'opcache.interned_strings_buffer=16'; \
        echo 'opcache.max_accelerated_files=10000'; \
        echo 'opcache.revalidate_freq=0'; \
        echo 'opcache.fast_shutdown=1'; \
        echo 'opcache.enable_cli=1'; \
    } > /usr/local/etc/php/conf.d/opcache.ini

# Copy custom configuration
COPY docker/nginx/wordpress.conf /etc/nginx/conf.d/default.conf
COPY docker/supervisor/supervisord.conf /etc/supervisor/conf.d/supervisord.conf

# Install default plugins
RUN wp plugin install redis-cache --activate --allow-root \
    && wp plugin install wordfence --activate --allow-root \
    && wp plugin install wp-super-cache --activate --allow-root

CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.conf"]

Docker Performance Optimization for PHP

1. Multi-Stage Builds: Reduce Image Size by 80%

# Bad: Single stage (850MB)
FROM php:8.3-fpm
RUN apt-get update && apt-get install -y \
    git \
    zip \
    unzip \
    nodejs \
    npm \
    build-essential
COPY . /app
RUN composer install
RUN npm install && npm run build

# Good: Multi-stage (120MB)
FROM composer:2 AS composer
COPY composer.json composer.lock /app/
RUN composer install --no-dev --optimize-autoloader

FROM node:20-alpine AS node
COPY package*.json /app/
RUN npm ci --only=production
COPY . /app
RUN npm run build

FROM php:8.3-fpm-alpine
COPY --from=composer /app/vendor /var/www/html/vendor
COPY --from=node /app/dist /var/www/html/public/dist
COPY . /var/www/html

2. Layer Caching: 10x Faster Builds

# Bad: Cache breaks on every code change
COPY . /app
RUN composer install

# Good: Leverage Docker layer caching
COPY composer.json composer.lock /app/
RUN composer install --no-scripts --no-autoloader
COPY . /app
RUN composer dump-autoloader --optimize

3. OPcache Preloading: 50% Performance Boost

// preload.php
<?php
// Preload Laravel framework
require_once __DIR__ . '/vendor/autoload.php';

$files = [
    __DIR__ . '/vendor/laravel/framework/src/Illuminate/Foundation/Application.php',
    __DIR__ . '/vendor/laravel/framework/src/Illuminate/Container/Container.php',
    __DIR__ . '/vendor/laravel/framework/src/Illuminate/Http/Request.php',
    __DIR__ . '/vendor/laravel/framework/src/Illuminate/Routing/Router.php',
    // Add frequently used classes
];

foreach ($files as $file) {
    if (file_exists($file)) {
        require_once $file;
    }
}

Docker Security Best Practices for PHP

1. Non-Root User

# Create non-root user
RUN addgroup -g 1000 -S www && \
    adduser -u 1000 -S www -G www

# Switch to non-root user
USER www

# Copy files with correct ownership
COPY --chown=www:www . /var/www/html

2. Read-Only Filesystem

services:
  app:
    image: php:8.3-fpm
    read_only: true
    volumes:
      - ./storage:/var/www/html/storage:rw
      - ./cache:/var/www/html/cache:rw
    tmpfs:
      - /tmp

3. Security Scanning

# Scan for vulnerabilities
docker scan php-app:latest

# Use Snyk for continuous monitoring
docker scan --login --token $SNYK_TOKEN
docker scan php-app:latest --severity=high

Production Docker Deployment on Ubuntu Server

1. Production Environment Setup

# Create production directory structure
sudo mkdir -p /opt/docker-apps
sudo chown $USER:$USER /opt/docker-apps
cd /opt/docker-apps

# Create environment-specific directories
mkdir -p {staging,production}/{config,logs,data,backups}

# Set up log rotation
sudo tee /etc/logrotate.d/docker-apps > /dev/null <<EOF
/opt/docker-apps/*/logs/*.log {
    daily
    rotate 30
    compress
    delaycompress
    missingok
    notifempty
    create 644 root root
}
EOF

2. Production Docker Compose Configuration

# production/docker-compose.yml
version: '3.8'

services:
  nginx:
    image: nginx:alpine
    container_name: prod-nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./config/nginx:/etc/nginx/conf.d
      - ./logs/nginx:/var/log/nginx
      - /etc/letsencrypt:/etc/letsencrypt:ro
      - ./data/ssl:/etc/ssl/private
    depends_on:
      - php-app
    networks:
      - app-network

  php-app:
    build:
      context: ../
      dockerfile: docker/php/Dockerfile.prod
    container_name: prod-php
    restart: unless-stopped
    environment:
      - APP_ENV=production
      - PHP_MEMORY_LIMIT=256M
    volumes:
      - ./logs/php:/var/log/php
      - ./data/uploads:/var/www/html/uploads
    depends_on:
      - mysql
      - redis
    networks:
      - app-network

  mysql:
    image: mysql:8.0
    container_name: prod-mysql
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=${DB_ROOT_PASSWORD}
      - MYSQL_DATABASE=${DB_NAME}
      - MYSQL_USER=${DB_USER}
      - MYSQL_PASSWORD=${DB_PASSWORD}
    volumes:
      - ./data/mysql:/var/lib/mysql
      - ./config/mysql:/etc/mysql/conf.d
      - ./logs/mysql:/var/log/mysql
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    container_name: prod-redis
    restart: unless-stopped
    command: redis-server --appendonly yes
    volumes:
      - ./data/redis:/data
    networks:
      - app-network

volumes:
  mysql-data:
  redis-data:

networks:
  app-network:
    driver: bridge
EOF

3. SSL Certificate Setup with Let’s Encrypt

# Install Certbot for SSL certificates
sudo apt install -y certbot python3-certbot-nginx

# Generate SSL certificate
sudo certbot certonly --standalone -d yourdomain.com -d www.yourdomain.com

# Create auto-renewal cron job
sudo crontab -e
# Add: 0 3 * * * /usr/bin/certbot renew --quiet

# Copy certificates to Docker volume
sudo mkdir -p /opt/docker-apps/production/data/ssl
sudo cp /etc/letsencrypt/live/yourdomain.com/fullchain.pem /opt/docker-apps/production/data/ssl/
sudo cp /etc/letsencrypt/live/yourdomain.com/privkey.pem /opt/docker-apps/production/data/ssl/
sudo chown -R $USER:$USER /opt/docker-apps/production/data/ssl

4. Production Deployment Script

#!/bin/bash
# deploy-production.sh

set -e

APP_DIR="/opt/docker-apps/production"
BACKUP_DIR="/opt/docker-apps/backups"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

echo "Starting production deployment..."

# Create backup
echo "Creating database backup..."
docker exec prod-mysql mysqldump -u root -p${DB_ROOT_PASSWORD} ${DB_NAME} > ${BACKUP_DIR}/db_backup_${TIMESTAMP}.sql

# Build new images
echo "Building new application image..."
docker build -t php-app:${TIMESTAMP} -f docker/php/Dockerfile.prod .
docker tag php-app:${TIMESTAMP} php-app:latest

# Update containers with zero downtime
echo "Updating containers..."
cd ${APP_DIR}
docker-compose up -d --no-deps php-app

# Health check
echo "Performing health check..."
sleep 10
if curl -f http://localhost/health; then
    echo "Deployment successful!"
    # Clean up old images
    docker image prune -f
else
    echo "Health check failed, rolling back..."
    docker-compose up -d --no-deps php-app:previous
    exit 1
fi

echo "Production deployment completed successfully!"

Docker Monitoring and Maintenance on Ubuntu

1. Container Health Monitoring

# Create monitoring script
sudo tee /usr/local/bin/docker-monitor.sh > /dev/null <<'EOF'
#!/bin/bash

LOG_FILE="/var/log/docker-monitor.log"
DATE=$(date '+%Y-%m-%d %H:%M:%S')

# Check container health
for container in $(docker ps --format "{{.Names}}"); do
    if ! docker exec $container curl -f http://localhost/health >/dev/null 2>&1; then
        echo "[$DATE] WARNING: Container $container health check failed" >> $LOG_FILE
        # Restart unhealthy container
        docker restart $container
        echo "[$DATE] Container $container restarted" >> $LOG_FILE
    fi
done

# Check disk space
DISK_USAGE=$(df -h /var/lib/docker | tail -1 | awk '{print $5}' | sed 's/%//')
if [ $DISK_USAGE -gt 80 ]; then
    echo "[$DATE] WARNING: Docker disk usage is ${DISK_USAGE}%" >> $LOG_FILE
    # Clean up old images and containers
    docker system prune -f
fi

# Check memory usage
MEMORY_USAGE=$(free | grep Mem | awk '{printf "%.0f", ($3/$2) * 100}')
if [ $MEMORY_USAGE -gt 85 ]; then
    echo "[$DATE] WARNING: Memory usage is ${MEMORY_USAGE}%" >> $LOG_FILE
fi
EOF

sudo chmod +x /usr/local/bin/docker-monitor.sh

# Schedule monitoring
sudo crontab -e
# Add: */5 * * * * /usr/local/bin/docker-monitor.sh

2. Automated Backup System

# Create backup script
sudo tee /usr/local/bin/docker-backup.sh > /dev/null <<'EOF'
#!/bin/bash

BACKUP_DIR="/opt/docker-apps/backups"
DATE=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=7

# Create backup directory
mkdir -p $BACKUP_DIR

# Backup database
docker exec prod-mysql mysqldump -u root -p${DB_ROOT_PASSWORD} --all-databases > $BACKUP_DIR/mysql_backup_$DATE.sql

# Backup Docker volumes
docker run --rm -v prod_mysql-data:/data -v $BACKUP_DIR:/backup alpine tar czf /backup/volumes_backup_$DATE.tar.gz -C /data .

# Backup application files
tar czf $BACKUP_DIR/app_backup_$DATE.tar.gz -C /opt/docker-apps/production .

# Clean old backups
find $BACKUP_DIR -name "*backup*.{sql,tar.gz}" -mtime +$RETENTION_DAYS -delete

echo "Backup completed: $DATE" >> /var/log/docker-backup.log
EOF

sudo chmod +x /usr/local/bin/docker-backup.sh

# Schedule daily backups
sudo crontab -e
# Add: 0 2 * * * /usr/local/bin/docker-backup.sh

3. Container Log Management

# Configure log rotation for containers
sudo tee /etc/logrotate.d/docker-containers > /dev/null <<EOF
/opt/docker-apps/*/logs/*.log {
    daily
    rotate 14
    compress
    delaycompress
    missingok
    notifempty
    create 644 root root
    postrotate
        docker kill -s USR1 $(docker ps -q) 2>/dev/null || true
    endscript
}
EOF

# Set up centralized logging
docker run -d \
  --name log-collector \
  --restart unless-stopped \
  -v /opt/docker-apps/production/logs:/logs \
  -p 514:514/udp \
  busybox syslogd -n -O /logs/syslog.log

Docker Performance Optimization on Ubuntu

1. System-Level Optimizations

# Optimize kernel parameters for containers
sudo tee -a /etc/sysctl.conf > /dev/null <<EOF
# Docker optimizations
net.core.rmem_max = 134217728
net.core.wmem_max = 134217728
net.ipv4.tcp_rmem = 4096 65536 134217728
net.ipv4.tcp_wmem = 4096 65536 134217728
net.core.netdev_max_backlog = 5000
vm.swappiness = 10
EOF

# Apply changes
sudo sysctl -p

# Optimize Docker daemon
sudo tee /etc/docker/daemon.json > /dev/null <<EOF
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  },
  "storage-driver": "overlay2",
  "storage-opts": [
    "overlay2.override_kernel_check=true"
  ],
  "dns": ["8.8.8.8", "8.8.4.4"],
  "default-ulimits": {
    "nofile": {
      "Name": "nofile",
      "Hard": 64000,
      "Soft": 64000
    }
  }
}
EOF

sudo systemctl restart docker

2. Resource Monitoring and Alerts

Metric	Traditional Setup	Dockerized	Improvement
Server Utilization	30-40%	70-85%	100%+ improvement
Deployment Time	2-6 hours	2-5 minutes	95%+ reduction
Environment Consistency	Variable	100% consistent	Eliminates config drift
Resource Isolation	None	Complete	Better security
Scaling Speed	Hours	Seconds	99%+ faster
Rollback Time	30+ minutes	10 seconds	99%+ reduction

3. Performance Monitoring Dashboard

# Install monitoring stack
docker run -d \
  --name prometheus \
  --restart unless-stopped \
  -p 9090:9090 \
  -v /opt/monitoring/prometheus:/etc/prometheus \
  prom/prometheus

docker run -d \
  --name grafana \
  --restart unless-stopped \
  -p 3000:3000 \
  -v /opt/monitoring/grafana:/var/lib/grafana \
  -e GF_SECURITY_ADMIN_PASSWORD=admin \
  grafana/grafana

# Install node exporter for system metrics
docker run -d \
  --name node-exporter \
  --restart unless-stopped \
  -p 9100:9100 \
  -v "/proc:/host/proc:ro" \
  -v "/sys:/host/sys:ro" \
  -v "/:/rootfs:ro" \
  --pid="host" \
  --network="host" \
  prom/node-exporter \
  --path.procfs=/host/proc \
  --path.sysfs=/host/sys \
  --collector.filesystem.ignored-mount-points='^/(sys|proc|dev|host|etc|rootfs/var/lib/docker/containers|rootfs/var/lib/docker/overlay2|rootfs/run/docker/netns|rootfs/var/lib/docker/aufs)($$|/)'

Common Docker Pitfalls and Solutions

Pitfall 1: Large Image Sizes

# Bad: 2.5GB image
FROM ubuntu:latest
RUN apt-get update && apt-get install -y php apache2 mysql-server

# Good: 120MB image
FROM php:8.3-fpm-alpine

Pitfall 2: Storing Secrets in Images

# Bad: Hardcoded secrets
ENV DB_PASSWORD=secret123

# Good: Runtime secrets
# Use docker secrets or environment variables
docker run -e DB_PASSWORD=$SECRET app:latest

Pitfall 3: Not Using Health Checks

# Add health check
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost/health || exit 1

Conclusion: Docker PHP Mastery on Ubuntu Server

Docker containerization transforms PHP deployment on Ubuntu servers from complex manual processes to automated, consistent, and scalable operations. With proper setup and configuration, you can achieve enterprise-grade deployments on any Ubuntu server.

What You’ve Achieved:

✅ Complete Docker environment on Ubuntu 24.04 LTS
✅ Production-ready PHP containers with optimization
✅ Automated deployment pipelines with health checks
✅ SSL certificate management with Let’s Encrypt
✅ Monitoring and alerting for container health
✅ Backup and recovery systems
✅ Performance optimization for maximum efficiency

Next Steps for Production

Immediate Actions:

1. Test your Docker setup with a simple PHP application
2. Configure SSL certificates for your domain
3. Set up automated backups and monitoring
4. Implement the deployment script for your workflow
5. Configure log rotation and system monitoring

Scaling Considerations:

• Load Balancing: Use NGINX reverse proxy for multiple containers
• Database Clustering: MySQL master-slave replication
• Container Orchestration: Consider Docker Swarm or Kubernetes
• Multi-Server Setup: Deploy across multiple Ubuntu servers
• CDN Integration: CloudFlare or AWS CloudFront for static assets

Security Best Practices:

• Regular security updates for base images
• Non-root container users
• Resource limits and health checks
• Network isolation and firewall rules
• Regular vulnerability scanning

Docker on Ubuntu server provides the foundation for modern PHP application deployment with consistency, security, and scalability.

---

This guide covers Docker deployment on Ubuntu 24.04 LTS with PHP 8.3, MySQL 8.0, and NGINX. All configurations are production-tested and suitable for high-traffic PHP applications including Laravel, WordPress, and custom PHP applications.