Makefile: Simplifique o seu fluxo Docker com os comandos make dev-up e make dev-down

Chega de decorar comandos gigantes no terminal

Se você trabalha com Docker e Docker Compose no seu dia a dia, sabe muito bem que a rotina envolve digitar (ou caçar no histórico do terminal) comandos parecidos com este:

docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d --build

Isso quando você não precisa lembrar de derrubar tudo limpando os volumes (docker compose down -v), compilar o projeto Java antes para gerar o .jar atualizado ou filtrar os logs de um container específico.

Decorar essa sopa de letrinhas ou deixar um bloco de notas aberto para ficar copiando e colando comandos não é nada produtivo. É aqui que entra o Makefile.

O que é o Makefile e por que você deveria usá-lo?

O make é uma ferramenta nativa do ecossistema Linux/Unix criada na década de 70 para automatizar a compilação de programas complexos (geralmente em C). Porém, a comunidade de desenvolvimento moderno percebeu que ele funciona como um excelente gerenciador de tarefas (task runner) genérico.

Ao criar um arquivo chamado exatamente Makefile (sem extensão) na raiz do seu projeto, você pode mapear rotinas complexas do terminal em apelidos (targets) curtos e fáceis de lembrar.

Em vez de obrigar todo mundo do time a saber de cor quais parâmetros o Docker precisa para rodar o ambiente local, você padroniza o fluxo. O comando para iniciar o projeto sempre será make dev-up. O comando para parar será make dev-down.

Configurando o seu primeiro Makefile (Java + Docker)

Vamos criar um exemplo prático focado na nossa realidade. Imagine um cenário onde, antes de subir os containers do Docker, nós precisamos garantir que o código Java mais recente foi compilado pelo Maven.

Crie um arquivo chamado Makefile na raiz do seu projeto e adicione a seguinte estrutura:

# O .PHONY garante que o make não confunda os comandos com arquivos do sistema
.PHONY: dev-up dev-down dev-logs dev-clean

dev-up:
	@echo "=> Compilando a aplicação Java com Maven..."
	mvn clean package -DskipTests
	@echo "=> Subindo o ambiente de desenvolvimento no Docker..."
	docker compose up -d --build

dev-down:
	@echo "=> Derrubando os serviços do Docker..."
	docker compose down

dev-logs:
	docker compose logs -f

dev-clean:
	@echo "=> Limpando tudo (containers, volumes e pastas de build)..."
	docker compose down -v
	mvn clean

O que está acontecendo aqui?

make dev-up: Com um único comando, o Makefile entra na pasta, roda o build do Maven gerando o novo .jar, e logo em seguida engata o docker compose up reconstruindo a imagem local. Tudo em sequência automática.

make dev-down: Para tudo o que estiver rodando de forma limpa.

make dev-clean: O aliado perfeito para quando o ambiente "engasga". Ele derruba os containers, apaga os volumes do banco de dados local para resetar o estado e limpa a pasta target do Java.

Atenção ao maior erro de quem começa com Makefile

O make é uma ferramenta incrivelmente útil, mas tem uma regra extremamente rígida que costuma derrubar muitos desenvolvedores de primeira viagem: a indentação.

O recuo antes de cada comando executável (como o mvn clean ou docker compose) obrigatoriamente precisa ser feito com a tecla TAB, e nunca com espaços. Se você usar a barra de espaço para alinhar o texto, o terminal vai estourar um erro parecido com: Makefile:6: *** missing separator. Stop..

Fique atento a esse detalhe na hora de salvar o arquivo no seu editor de código!

Conclusão

Adotar o Makefile não muda em nada a arquitetura do seu software, mas muda completamente a sua experiência de desenvolvimento.

Ele atua como uma documentação viva do projeto. Quando um novo desenvolvedor entra no time, ele não precisa passar horas configurando o ambiente ou adivinhando comandos. Ele só precisa rodar o make dev-up e focar no que realmente importa: escrever código.

E você? Já conhecia esse uso do make para simplificar o Docker ou costuma salvar seus comandos em scripts .sh perdidos por aí? Deixe seu comentário abaixo!