PHP Academy · Aula

Conteinerização de uma aplicação PHP

Crie uma imagem Docker para PHP + Nginx e orquestre-a com Docker Compose.

Conteinerização de uma aplicação PHP é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

Por que usar Docker para PHP?

Docker empacota sua aplicação com as dependências em uma imagem de contêiner portátil. A mesma imagem é executada de forma idêntica no desenvolvimento, na integração contínua e em produção, eliminando o problema de “funciona na minha máquina”.

Dockerfile básico para PHP

Um Dockerfile mínimo para uma aplicação PHP + Nginx.

# Dockerfile
FROM php:8.3-fpm-alpine

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

# Install Composer
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer

WORKDIR /app
COPY composer.json composer.lock ./
RUN composer install --no-dev --optimize-autoloader

COPY . .

RUN chown -R www-data:www-data /app/storage /app/bootstrap/cache

Compilação em várias etapas

Use compilações em várias etapas para manter a imagem final pequena: instale as ferramentas de compilação em uma etapa e copie apenas os artefatos para a imagem final.

# Stage 1: builder
FROM composer:2 AS builder
WORKDIR /app
COPY composer.json composer.lock ./
RUN composer install --no-dev --optimize-autoloader

# Stage 2: runtime
FROM php:8.3-fpm-alpine
WORKDIR /app
COPY --from=builder /app/vendor ./vendor
COPY . .

docker-compose.yml

Orquestre vários serviços, como PHP-FPM, Nginx, MySQL e Redis, com o Docker Compose.

# docker-compose.yml
services:
  app:
    build: .
    volumes:
      - .:/app
  nginx:
    image: nginx:alpine
    ports: ["80:80"]
    volumes:
      - .:/app
      - ./docker/nginx.conf:/etc/nginx/conf.d/default.conf
  mysql:
    image: mysql:8
    environment:
      MYSQL_DATABASE: myapp
      MYSQL_ROOT_PASSWORD: secret
    volumes:
      - db_data:/var/lib/mysql
  redis:
    image: redis:alpine
volumes:
  db_data:

Configuração do contêiner Nginx

Monte uma configuração personalizada do Nginx para encaminhar as requisições do PHP-FPM.

# docker/nginx.conf
server {
    listen 80;
    root /app/public;
    index index.php;
    location / { try_files $uri /index.php?$query_string; }
    location ~ \.php$ {
        fastcgi_pass app:9000;  # service name from docker-compose
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

Variáveis de ambiente

Passe as variáveis de ambiente para os contêineres; nunca inclua segredos diretamente nas imagens.

# docker-compose.yml:
services:
  app:
    env_file: .env
    # or explicit:
    environment:
      - APP_ENV=production
      - DB_HOST=mysql

Comandos do Laravel Artisan

Execute comandos do Artisan dentro do contêiner.

$ docker compose exec app php artisan migrate
$ docker compose exec app php artisan config:cache
$ docker compose exec app php artisan queue:work

Verificações de integridade

Adicione verificações de integridade para que os orquestradores, como Kubernetes e ECS, saibam quando o contêiner está pronto.

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

Compilação e envio de imagens

Compile e envie sua imagem para um registro, como Docker Hub, ECR ou GHCR.

$ docker build -t myorg/myapp:1.0.0 .
$ docker push myorg/myapp:1.0.0

Implantação no Kubernetes

No Kubernetes, defina um recurso de implantação e um recurso de serviço usando sua imagem. Lance novas versões com kubectl set image ou atualize o YAML e aplique as alterações.

Reforço para produção

Práticas do Docker para produção: use um usuário sem privilégios administrativos, um sistema de arquivos raiz somente leitura, uma imagem base mínima (Alpine), nenhuma dependência de desenvolvimento, fixe as etiquetas das imagens e procure vulnerabilidades CVE com docker scout.

Resumo

Crie um Dockerfile para PHP-FPM + Composer. Use o Docker Compose no desenvolvimento local com serviços Nginx, MySQL e Redis. Em produção, use compilações em várias etapas, injete as variáveis de ambiente e execute com Kubernetes ou ECS.

Verificação rápida

Qual é o principal benefício das compilações do Docker em várias etapas?

Perguntas Frequentes

A aula “Conteinerização de uma aplicação PHP” é grátis?

Sim — o texto completo de “Conteinerização de uma aplicação PHP” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “Conteinerização de uma aplicação PHP”?

Crie uma imagem Docker para PHP + Nginx e orquestre-a com Docker Compose. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Conteinerização de uma aplicação PHP”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para PHP Academy