Docker não é pesado: um MySQL e phpMyAdmin por projeto

Fui ajudar um amigo numa operação. Ele é dev PHP com mais de dez anos de estrada, gente boa e que entrega. Cloneei o projeto dele pra rodar na minha máquina, e foi aí que eu vi como o ambiente estava montado.

MySQL instalado direto no Debian. Duas versões de MySQL, na verdade, uma delas só pra dar conta do legado. Todos os projetos morando dentro do public_html. Um phpMyAdmin único servindo a máquina inteira, o mesmo banco atendendo tudo.

Perguntei por que ele não containerizava cada projeto. A resposta foi honesta: "acho Docker muito pesado". Nisso o colega dele, da mesa do lado, soltou: "usa XAMPP que resolve". Era brincadeira, eu ri. Mas ficou a ficha.

Ele não fazia isso por preguiça, nem por não ser bom. Fazia porque ninguém tinha mostrado pra ele o quanto é simples ter um banco por projeto. E não é só ele. Tem muita gente experiente rodando serviço direto na máquina, catando conflito de versão, porque a fama do Docker é de ser complicado e pesado. Não é.

Pra mostrar pra ele, montei um repositório pequeno: um MySQL e um phpMyAdmin que sobem juntos, isolados, com um comando. É esse que eu vou destrinchar aqui. É mais desmistificação do que tutorial.

O que você ganha com isso

A ideia é uma só: cada projeto traz o próprio banco. Quando você para de mexer nele, o banco para junto. Precisa de uma versão do MySQL num projeto e outra no seguinte? Cada um sobe a sua, sem as duas brigando na mesma máquina. Quer jogar tudo fora e começar do zero? Apaga uma pasta. Não é mágica, é isolamento.

Docker empacota um serviço num container isolado. Docker Compose é um arquivo que descreve os containers que sobem juntos, num YAML só. Aqui são dois: o banco e o phpMyAdmin.

Instalando o Docker (Debian ou Ubuntu)

Primeiro atualiza a lista de pacotes:

sudo apt update

Depois instala o Docker com o Compose v2 já embutido:

sudo apt install docker-compose-v2

Leva alguns segundos, ou minutos dependendo da sua conexão. É a parte mais "pesada" do processo, e ela acontece uma vez só.

Clonando o repositório

Já deixei o arquivo pronto num repositório. Pra agilizar, clona:

git clone https://github.com/oalexandre/mysql-phpmyadmin-docker.git

Entra na pasta, mas antes de rodar vale entender o docker-compose.yml. É ele que faz todo o trabalho.

Entendendo o docker-compose.yml

services:
  db:
    image: mysql:latest
    ports:
      - "3306:3306"
    volumes:
      - ./db_persist:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=password
      - MYSQL_DATABASE=app_development
  app:
    image: phpmyadmin/phpmyadmin:latest
    links:
      - db
    ports:
      - 8081:80
    environment:
      - PMA_ARBITRARY=1
      - UPLOAD_LIMIT=300M

São dois serviços. O db é o banco:

• Usa a imagem mysql:latest.
• Expõe a porta 3306, a porta padrão do MySQL.
• Guarda os dados num volume local (db_persist), pra eles não sumirem quando o container parar.
• Sobe já com um banco app_development criado e a senha de root definida.

O app é o phpMyAdmin:

• Usa a imagem phpmyadmin/phpmyadmin:latest.
• Se conecta ao container db.
• Expõe a porta 8081 no seu navegador.
• PMA_ARBITRARY deixa você apontar pra qualquer servidor, e UPLOAD_LIMIT aumenta o tamanho de import permitido.

Um detalhe honesto: a senha aqui é password de propósito. Isso é ambiente local, na sua máquina. Não é assim que se configura banco em produção.

Subindo os containers

Na pasta do projeto:

sudo docker compose up -d --build

O Docker constrói e sobe os dois containers. Pra confirmar que estão de pé:

sudo docker ps

E pra derrubar tudo, no mesmo diretório:

sudo docker compose down

Acessando o phpMyAdmin

O phpMyAdmin está na porta 8081. Abre no navegador: http://localhost:8081.

Entra com:

• Servidor: db (o nome do banco dentro da rede do Docker)
• Usuário: root
• Senha: password

Conectando sua aplicação

Na sua aplicação, aponta pro banco com:

• Host: localhost
• Porta: 3306
• Usuário: root
• Senha: password

Os dados não somem

Como o db_persist é uma pasta na sua máquina mapeada pra dentro do container, os dados do MySQL ficam ali mesmo depois de parar ou reiniciar tudo. Você derruba o container sem perder o banco, e ainda consegue olhar os arquivos direto na pasta se precisar.

O código completo está no repositório no GitHub.

O pulo do gato não é o YAML

O ponto não é decorar esse arquivo. É parar de tratar o ambiente como parte da máquina. O banco passa a ser parte do projeto: nasce com ele, para com ele, e a versão vira problema de cada projeto, não uma coleção de coisas instaladas que você tem medo de mexer. As duas versões de MySQL do meu amigo deixariam de existir como dor: cada projeto traria a sua.

Era isso que eu queria que ele visse. Se você ainda roda tudo direto no sistema porque "Docker é pesado", clona esse repositório, sobe com um comando e decide depois.