# Docker Compose na prática: WordPress e MySQL com um arquivo YAML

> Suba aplicação e banco com um único comando: o compose.yml do WordPress com MySQL, como os dois containers se encontram e como zerar o ambiente.

- Autor: Henrylle Maia, consultor AWS
- Publicado em: 2026-10-15
- Assuntos: Containers
- URL: https://pages.formacaoaws.com.br/blog/docker-compose-na-pratica/
- Aula de origem: "O que é e como trabalhar com docker-compose na prática" (https://www.youtube.com/watch?v=PXIGW45vmhc)

Quando a aplicação precisa de mais de um container, rodar cada `docker run` na mão vira bagunça. O Docker Compose resolve isso com um arquivo YAML que descreve todos os containers e o que conversa com o quê. Abaixo eu subo um WordPress com banco MySQL com um comando, derrubo com outro e mostro como voltar ao ponto de partida.

Gravei essa aula em 11 de janeiro de 2022, a pedido de uma pessoa do canal que não entendia onde o Compose entra. Os comandos e a versão do arquivo são os daquela data: antes de copiar, confira a [documentação oficial do Docker Compose](https://docs.docker.com/compose/), porque o formato do arquivo e a forma de chamar o comando podem ter mudado. Se você ainda não sabe o que é Docker, comece por [o que é Docker](https://pages.formacaoaws.com.br/blog/o-que-e-docker/).

## Para que serve o Compose

O Compose cai como uma luva quando você tem vários containers rodando e precisa orquestrar a comunicação entre eles. Meu exemplo é o WordPress: uma aplicação em PHP que fala com um banco MySQL. São dois containers, e o banco precisa se comunicar com a aplicação web.

Duas coisas ele faz por você:

- **Isola o ambiente.** O nome da pasta vira o prefixo do projeto. Se eu criar outra pasta com o mesmo arquivo, sobe um segundo ambiente, separado do primeiro.
- **Gerencia os containers.** Por baixo, são o `run`, o `stop` e o `start` que você já conhece. O Compose vê se precisa criar o container e alterna entre parar e iniciar, sem você pedir cada passo.

## Passo 1: conferir se o Compose está instalado

No terminal (usei Linux, mas serve para Windows e Mac):

```bash
docker-compose -v
```

Na tela da aula, esse comando respondeu `docker-compose version 1.25.5`. Se o seu responder com a versão, está instalado. Se não, pesquise "docker compose install" e abra a página oficial, que tem o passo a passo para Windows e Linux. Parto do princípio de que o Docker também já está instalado.

## Passo 2: criar a pasta e o arquivo

Crie uma pasta para o projeto (a minha chamou `wordpress-compose-2`), abra no editor e crie nela um arquivo chamado `docker-compose.yml`.

O conteúdo eu peguei no Docker Hub: na página da imagem do WordPress, há um exemplo de Docker Compose. É um arquivo YAML, que é declarativo: você diz como o ambiente deve ficar, e os espaços de indentação importam.

```yaml
version: "3.1"

services:
  wordpress:
    image: wordpress
    restart: always
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: exampleuser
      WORDPRESS_DB_PASSWORD: examplepass
      WORDPRESS_DB_NAME: exampledb
    volumes:
      - wordpress:/var/www/html

  db:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_DATABASE: exampledb
      MYSQL_USER: exampleuser
      MYSQL_PASSWORD: examplepass
      MYSQL_RANDOM_ROOT_PASSWORD: "1"
    volumes:
      - db:/var/lib/mysql

volumes:
  wordpress:
  db:
```

> **Importante:** `exampleuser` e `examplepass` são os valores de exemplo do Docker Hub, que usei na aula, na minha máquina. Não são valores para um ambiente de verdade.

## Passo 3: entender o arquivo

Lendo de cima para baixo:

- **`version`:** a versão do Compose. No exemplo é a 3.1.
- **`services`:** tudo que você declara aqui é um container. O primeiro se chama `wordpress`, mas o nome pode ser qualquer um. Eu poderia chamar de `web`.
- **`image`:** a imagem vem do Docker Hub. Pode ser uma imagem local: no lugar de `image`, você usa `build` e aponta onde está o Dockerfile (um ponto usa o Dockerfile da pasta atual).
- **`restart: always`:** se houver problema no servidor ou no container, ele reinicia sozinho.
- **`ports`:** é o `-p` do `docker run`, só que declarado. `8080:80` quer dizer porta 80 do container na porta 8080 da sua máquina. A aplicação vai abrir em `localhost:8080`.
- **`environment`:** as variáveis de ambiente, bem simples de declarar. Veja o `WORDPRESS_DB_HOST: db`.
- **`volumes`:** o mapeamento de volumes. Os nomes `wordpress` e `db` são declarados na seção `volumes` do fim do arquivo.

O serviço `db` repete a mesma estrutura, com a imagem do MySQL (`mysql:5.7`), o mesmo `restart` e as variáveis do banco: nome, usuário e senha. O `MYSQL_RANDOM_ROOT_PASSWORD: "1"` gera uma senha aleatória para o root.

O detalhe que mais gera dúvida é o `DB`. Para a aplicação encontrar o banco, basta dar o mesmo nome: o serviço se chama `db`, e o `WORDPRESS_DB_HOST` aponta para `db`. É isso que liga os dois.

Para saber onde os volumes ficam na sua máquina, use `docker volume` e `docker inspect`, que já mostrei na aula de oito comandos do Docker.

## Passo 4: subir o ambiente

Na pasta do arquivo:

```bash
docker-compose up
```

O Compose lê o arquivo e levanta os dois serviços. Se você não indicar nenhum, ele sobe tudo o que está no arquivo. Também dá para subir só um deles.

Na primeira tentativa, deu erro no meu terminal: a porta 8080 já estava em uso por containers de um teste anterior. O Docker não consegue publicar duas coisas na mesma porta. Rodei `docker ps`, parei os dois containers com `docker stop` e repeti o comando.

Com tudo no ar, abra `localhost:8080`: aparece a página de instalação do WordPress. Escolhi português do Brasil, preenchi o título, o usuário, a senha e o e-mail, instalei e entrei na administração. A aplicação já conversava com o banco, sem eu configurar nada além do arquivo.

Com `docker-compose up` o log fica preso no terminal; o `Ctrl+C` para os containers. A pasta aparece no nome: os containers se chamam `wordpress-compose-2_wordpress_1` e `wordpress-compose-2_db_1`, o prefixo do projeto mais o nome do serviço. Foi isso que isolou o ambiente.

Para rodar em segundo plano e liberar o terminal, use `-d`:

```bash
docker-compose up -d
```

## Passo 5: derrubar o ambiente

```bash
docker-compose down
```

Na pasta do arquivo, o Compose lê os serviços e derruba cada um. Ele para e remove os dois containers e remove a rede que criou para eles se comunicarem. Depois, um novo `docker-compose up -d` levanta tudo de volta.

![O terminal com docker-compose up -d, down e up -d: os dois containers são parados e removidos junto com a rede wordpress-compose-2_default](https://pages.formacaoaws.com.br/blog/assets/posts/docker-compose-na-pratica/compose-up-e-down.webp)

**Fluxo:** Arquivo YAML (serviços declarados) → docker-compose up (lê o arquivo da pasta) → Rede do projeto (wordpress e db se encontram) → WordPress (localhost:8080) → MySQL (volume db)

## Passo 6: voltar ao ponto de partida

Depois do `down`, o WordPress subiu de novo já instalado. Sobrou o volume do banco, que guarda os dados. Isso ajuda no dia a dia, mas atrapalha em um ambiente de teste, em que você quer que tudo recomece do zero (por exemplo, subir o ambiente, rodar a bateria de testes e terminar).

Para apagar também os volumes, acrescente `-v`:

```bash
docker-compose down -v
```

A saída passa a mostrar a remoção dos volumes. Subi de novo com `docker-compose up -d`, que demorou um pouco mais porque o MySQL foi instalado do zero, e o WordPress voltou para a instalação inicial. Refiz o passo com outro usuário e entrei na administração. O banco estava zerado.

![A saída do docker-compose down -v: além dos dois containers e da rede, aparecem Removing volume wordpress-compose-2_wordpress e wordpress-compose-2_db](https://pages.formacaoaws.com.br/blog/assets/posts/docker-compose-na-pratica/compose-down-v.webp)

## Checklist

- Confira com `docker-compose -v` se o Compose está instalado.
- Crie uma pasta por projeto e coloque nela o `docker-compose.yml`.
- Declare cada container em `services`, com imagem (ou `build`), `restart`, `ports` e `environment`.
- Para a aplicação achar o banco, use o nome do serviço do banco como host.
- Se a 8080 estiver ocupada por containers antigos, veja com `docker ps` e pare com `docker stop`.
- Suba com `docker-compose up -d` e derrube com `docker-compose down`.
- Para recomeçar do zero, derrube com `docker-compose down -v`.

Com um arquivo e dois comandos, os dois containers sobem, se encontram pelo nome e somem sem deixar rede nem container para trás. Para levar esse mesmo arquivo para uma instância, veja [WordPress na AWS com Docker](https://pages.formacaoaws.com.br/blog/wordpress-na-aws-com-docker/), que cobre a EC2, o Docker e a porta 80.