WordPress com Docker: Guia de Instalação e Deploy

WordPress com Docker é a abordagem moderna para desenvolvimento e deployment de aplicações WordPress em 2026. Se você quer aprender como instalar wordpress docker e dominar containerização para seus projetos, este guia técnico cobrirá desde conceitos básicos até deploy em produção com best practices DevOps.

Docker transforma a forma como você desenvolve, testa e deploya WordPress. Com docker compose wordpress, você consegue replicar ambiente de produção localmente, compartilhar setup com sua equipe, e escalar infraestrutura sem dores de cabeça. Este artigo foi feito para desenvolvedores e DevOps engineers que buscam profissionalizar seu stack de WordPress.

O Que é Docker? Conceitos Fundamentais

Docker vs Máquina Virtual

• VM: Sistema operacional completo virtualizado (2-4GB RAM)
• Docker: Container leve compartilha kernel do host (~100MB)
• Resultado: Docker é mais rápido, usa menos recurso, ideal para microserviços

Conceitos Principais

• Image: Template/blueprint do container (como class em OOP)
• Container: Instância rodando da image (como objeto)
• Volume: Persiste dados entre container reinicializações
• Network: Conecta containers para comunicação (WordPress → MySQL)

Passo 1: Instalar Docker

MacOS

1. Acesse https://www.docker.com/products/docker-desktop
2. Clique “Download for Mac”
3. Abra DMG e arraste Docker.app para Applications
4. Abra Docker.app (menu superior)
5. Terminal: docker --version (verificar instalação)

Linux (Ubuntu/Debian)

# Instalar Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Adicionar seu usuário ao grupo docker
sudo usermod -aG docker $USER
newgrp docker

# Instalar 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

# Verificar
docker --version
docker-compose --version
  

Windows

1. Baixe Docker Desktop para Windows
2. Execute instalador (.exe)
3. Ative WSL 2 (Windows Subsystem for Linux)
4. Reinicie computador
5. Abra PowerShell: docker --version

Passo 2: Estrutura de Pastas e Arquivos

Organize seu projeto antes de escrever código:

wordpress-docker/
├── docker-compose.yml
├── .env
├── nginx/
│   └── default.conf
├── wordpress/
│   └── Dockerfile
├── mysql/
│   └── my.cnf
└── README.md
  

Criar Diretório

mkdir wordpress-docker
cd wordpress-docker
mkdir -p nginx mysql wordpress
  

Passo 3: Docker Compose Completo

O arquivo mais importante. Crie docker-compose.yml:

version: '3.9'

services:
  # Serviço MySQL - Banco de Dados
  db:
    image: mysql:8.0
    container_name: wordpress-db
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: ${DB_NAME}
      MYSQL_USER: ${DB_USER}
      MYSQL_PASSWORD: ${DB_PASSWORD}
    volumes:
      - db_data:/var/lib/mysql
      - ./mysql/my.cnf:/etc/mysql/my.cnf
    networks:
      - wordpress-network
    ports:
      - "3306:3306"
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      timeout: 20s
      retries: 10

  # Serviço PHP-FPM - Processador PHP
  wordpress:
    build:
      context: ./wordpress
      dockerfile: Dockerfile
    container_name: wordpress-app
    restart: always
    depends_on:
      db:
        condition: service_healthy
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_NAME: ${DB_NAME}
      WORDPRESS_DB_USER: ${DB_USER}
      WORDPRESS_DB_PASSWORD: ${DB_PASSWORD}
      WORDPRESS_TABLE_PREFIX: ${WP_TABLE_PREFIX}
      WORDPRESS_CONFIG_EXTRA: |
        define('WP_MEMORY_LIMIT', '256M');
        define('WP_MAX_MEMORY_LIMIT', '512M');
        define('FS_METHOD', 'direct');
        define('DISALLOW_FILE_MODS', false);
        define('WP_DEBUG', false);
    volumes:
      - wordpress_data:/var/www/html
      - ./wordpress/php.ini:/usr/local/etc/php/conf.d/uploads.ini
    networks:
      - wordpress-network
    expose:
      - "9000"
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost"]
      timeout: 10s
      retries: 5

  # Serviço Nginx - Web Server
  nginx:
    image: nginx:alpine
    container_name: wordpress-nginx
    restart: always
    depends_on:
      wordpress:
        condition: service_healthy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - wordpress_data:/var/www/html:ro
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
    networks:
      - wordpress-network
    environment:
      - NGINX_HOST=${NGINX_HOST}
      - NGINX_PORT=80

volumes:
  db_data:
    driver: local
  wordpress_data:
    driver: local

networks:
  wordpress-network:
    driver: bridge
  

Passo 4: Arquivo .env (Variáveis de Ambiente)

Crie .env na raiz (não commitar ao Git):

# MySQL Configuration
DB_ROOT_PASSWORD=wordpress_root_secure_password_2026
DB_NAME=wordpress_db
DB_USER=wordpress_user
DB_PASSWORD=wordpress_secure_password_2026

# WordPress Configuration
WP_TABLE_PREFIX=wp_
WORDPRESS_ADMIN_USER=admin
WORDPRESS_ADMIN_PASSWORD=admin_secure_password_2026
WORDPRESS_ADMIN_EMAIL=seu@email.com.br

# Nginx Configuration
NGINX_HOST=localhost
NGINX_PORT=80

# Timezone
TZ=America/Sao_Paulo
  

Segurança .env

1. Adicione .env ao .gitignore
2. Gere senhas fortes: openssl rand -base64 32
3. Mude padrão “wordpress” em produção
4. Armazene .env em secret manager (AWS Secrets, Vault)

Passo 5: Dockerfile Customizado para WordPress

Crie wordpress/Dockerfile:

FROM php:8.3-fpm-alpine

# Instalar extensões PHP necessárias
RUN apk add --no-cache \
    curl \
    libpng-dev \
    libjpeg-turbo-dev \
    libzip-dev \
    libxml2-dev \
    freetype-dev \
    imagemagick-dev \
    mysql-client

# Compilar extensões PHP
RUN docker-php-ext-configure gd \
    --with-freetype \
    --with-jpeg && \
    docker-php-ext-install \
    gd \
    mysqli \
    zip \
    xml \
    curl \
    mbstring \
    bcmath

# Instalar Imagick
RUN apk add --no-cache imagemagick-dev && \
    pecl install imagick && \
    docker-php-ext-enable imagick

# Instalar Composer
RUN curl -sS https://getcomposer.org/installer | php -- \
    --install-dir=/usr/local/bin --filename=composer

# Instalar 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

# Configurar diretório
WORKDIR /var/www/html

# Download WordPress latest
RUN curl -O https://wordpress.org/latest.tar.gz && \
    tar -xzf latest.tar.gz --strip-components=1 && \
    rm latest.tar.gz && \
    chown -R www-data:www-data /var/www/html

# Copiar configuração PHP
COPY php.ini /usr/local/etc/php/conf.d/uploads.ini

EXPOSE 9000

CMD ["php-fpm"]
  

Arquivo php.ini Customizado

Crie wordpress/php.ini:

upload_max_filesize = 256M
post_max_size = 256M
max_execution_time = 300
max_input_time = 300
memory_limit = 512M
display_errors = Off
log_errors = On
error_log = /var/log/php-errors.log
disable_functions = exec, passthru, shell_exec, system, proc_open
  

Passo 6: Configuração Nginx

Crie nginx/default.conf:

upstream wordpress {
    server wordpress:9000;
}

server {
    listen 80;
    server_name localhost *.localhost;
    root /var/www/html;
    index index.php index.html;

    # Logging
    access_log /var/log/nginx/wordpress.access.log;
    error_log /var/log/nginx/wordpress.error.log;

    # Gzip compression
    gzip on;
    gzip_vary on;
    gzip_min_length 1000;
    gzip_types text/plain text/css text/xml text/javascript
               application/x-javascript application/xml+rss
               application/javascript;

    # 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 Referrer-Policy "strict-origin-when-cross-origin" always;

    # WordPress rewrite rules
    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    # PHP handling
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass wordpress;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
        fastcgi_param HTTP_PROXY "";
    }

    # Cache estático
    location ~* \.(jpg|jpeg|png|gif|ico|css|js|svg|woff|woff2|ttf)$ {
        expires 365d;
        add_header Cache-Control "public, immutable";
    }

    # Bloquear acesso a arquivos sensíveis
    location ~ /\. {
        deny all;
        access_log off;
        log_not_found off;
    }

    location ~ ~$ {
        deny all;
        access_log off;
        log_not_found off;
    }

    location ~ wp-config.php$ {
        deny all;
    }
}
  

Passo 7: Arquivo MySQL Customizado

Crie mysql/my.cnf:

[mysqld]
# Character set
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
default_character_set=utf8mb4

# Performance
max_connections=100
max_allowed_packet=256M
innodb_buffer_pool_size=512M
innodb_log_file_size=100M

# Logging
log_error=/var/log/mysql/error.log
slow_query_log=1
slow_query_log_file=/var/log/mysql/slow.log
long_query_time=2

# Binlog (backup)
server-id=1
log_bin=mysql-bin
binlog_format=row
expire_logs_days=10

[client]
default-character-set=utf8mb4
  

Passo 8: .gitignore para Segurança

Crie .gitignore:

.env
.env.local
.env.*.local
*.log
.DS_Store
node_modules/
wordpress_data/
db_data/
nginx/ssl/*
!nginx/ssl/.gitkeep
.vscode/
.idea/
*.swp
*.swo
*~
  

Passo 9: Executar Containers

Build e Iniciar

# Build image customizada
docker-compose build

# Iniciar containers
docker-compose up -d

# Verificar status
docker-compose ps
  

Logs

# Ver todos os logs
docker-compose logs -f

# Ver logs específicos
docker-compose logs -f wordpress
docker-compose logs -f db
docker-compose logs -f nginx
  

Passo 10: Configuração Inicial WordPress

Acessar WordPress

Navegue para http://localhost

1. Escolha idioma português
2. Preencha dados de site
3. Username/Password (anote em lugar seguro)
4. Clique “Instalar WordPress”

Alternativa: WP-CLI (Automático)

# Executar comando dentro do container
docker-compose exec wordpress wp core install \
  --url=http://localhost \
  --title="Meu Blog WordPress" \
  --admin_user=admin \
  --admin_password=admin_secure_password \
  --admin_email=seu@email.com.br

# Verificar instalação
docker-compose exec wordpress wp core is-installed
  

Passo 11: Database Backups

Fazer Backup

# Backup completo do MySQL
docker-compose exec db mysqldump -u wordpress_user -pwordpress_password wordpress_db > backup.sql

# Backup com timestamp
docker-compose exec db mysqldump \
  -u ${DB_USER} \
  -p${DB_PASSWORD} \
  ${DB_NAME} > backups/wp_$(date +%Y%m%d_%H%M%S).sql
  

Restaurar Backup

docker-compose exec -T db mysql \
  -u wordpress_user \
  -pwordpress_password \
  wordpress_db < backup.sql
  

Passo 12: Deploy em Produção

Servidores Recomendados

• AWS ECS: Container orchestration (escalável)
• DigitalOcean App Platform: Simples, managed (R$60+/mês)
• Heroku: PaaS, fácil deploy mas caro
• VPS (Linode/AWS EC2): Máximo controle, mais complexo

Deploy DigitalOcean (Simplificado)

1. Crie repositório GitHub com seu código
2. No DigitalOcean, crie novo “App”
3. Conecte GitHub e selecione repo
4. Configure variáveis de ambiente (.env)
5. Deploy automático a cada push

Checklist Produção

Passo 13: Otimização Performance Docker

Reduzir Tamanho da Image

# Usar Alpine (mais leve)
FROM php:8.3-fpm-alpine

# Limpar cache após apt
RUN apk add ... && apk cache clean

# Multi-stage builds para produção
FROM php:8.3-fpm-alpine AS builder
# ... build steps

FROM php:8.3-fpm-alpine
COPY --from=builder /app /app
  

Networking Otimizado

# Use nome de host interno (não localhost)
WORDPRESS_DB_HOST: db  # não db:3306 em network bridge
  

Volume Performance

• Use volumes Docker (não bind mounts) em produção
• Bind mounts mais lentos em Mac/Windows (OSXFS issue)
• Volume driver delegated para desenvolvimento rápido

Troubleshooting Comum

Perguntas Frequentes sobre WordPress Docker

Conclusão

WordPress com Docker representa a evolução moderna da infraestrutura de aplicações web. Ao containerizar WordPress, você ganha portabilidade, escalabilidade e garantia de que o site roda igual no seu computador, staging e produção.

O setup apresentado neste artigo é production-ready com Nginx, PHP 8.3, MySQL 8.0, security headers, logging, health checks e otimizações de performance. Use como base para seus projetos.

Próximos passos: (1) adicionar CI/CD com GitHub Actions, (2) fazer deploy em DigitalOcean App Platform, (3) implementar Kubernetes para escala. Para mais sobre infraestrutura, confira nossos recursos sobre otimização de WordPress.