Docker no Dia a Dia: Do "Na Minha Máquina Funciona" a Deploys Otimizados

1. O que é o Docker?

O Docker é uma plataforma open-source que facilita a criação, o deploy e a execução de aplicações em ambientes isolados chamados Containers.

Um container empacota o código da sua aplicação junto com todas as suas dependências (bibliotecas, frameworks, runtime), garantindo que ela rode de forma idêntica em qualquer infraestrutura, seja no seu notebook, no servidor de homologação ou na nuvem.

Docker vs. Máquina Virtual (VM)

A principal confusão no início é achar que o Docker é apenas uma "mini VM". A arquitetura deles é fundamentalmente diferente:

2. Como Instalar o Docker

• Windows: Baixe e instale o Docker Desktop. É recomendado ter o WSL 2 (Windows Subsystem for Linux) habilitado na sua máquina para máxima performance.

• Mac: Baixe e instale o Docker Desktop para Mac. Funciona perfeitamente tanto em chips Intel quanto Apple Silicon (M1/M2/M3).

• Linux (Ubuntu/Debian): A instalação via terminal é a mais comum:

  sudo apt-get update
  sudo apt-get install docker.io docker-compose-v2
  sudo systemctl enable --now docker
  

3. Os Principais Comandos do Docker

Aqui está os principais comandos para você usar no terminal:

• docker pull <imagem>: Baixa uma imagem do Docker Hub (ex: docker pull postgres:16).

• docker build -t <nome> .: Constrói uma imagem a partir de um Dockerfile no diretório atual.

• docker run -p 8080:8080 -d <imagem>: Roda um container em background (-d) mapeando a porta local para a porta do container.

• docker ps: Lista os containers que estão em execução. Use docker ps -a para ver os parados também.

• docker stop <id-do-container>: Para a execução de um container de forma graciosa.

• docker rm <id-do-container>: Remove um container (ele precisa estar parado).

• docker logs -f <id-do-container>: Exibe e acompanha os logs do container em tempo real.

• docker exec -it <id-do-container> bash: Entra no terminal de um container em execução.

4. O que é o Dockerfile? (Exemplo com Spring Boot)

O Dockerfile é a "receita de bolo" da sua imagem. É um arquivo de texto com instruções passo a passo de como o Docker deve montar o ambiente da sua aplicação.

Se você tem uma aplicação Spring Boot compilada (app.jar), o Dockerfile usando Java 21 seria assim:

# Usa uma imagem oficial do Java 21 (versão leve baseada em Alpine)
FROM eclipse-temurin:21-jre-alpine

# Define o diretório de trabalho dentro do container
WORKDIR /app

# Copia o arquivo .jar da sua máquina para dentro do container
COPY target/meu-app-spring.jar app.jar

# Expõe a porta que o Spring Boot vai rodar
EXPOSE 8080

# Comando que será executado quando o container iniciar
ENTRYPOINT ["java", "-jar", "app.jar"]

Para rodar:

1. docker build -t meu-app-spring .

2. docker run -p 8080:8080 -d meu-app-spring

5. O que é o Docker Compose?

Enquanto o Dockerfile constrói uma imagem, o Docker Compose orquestra múltiplos containers. Ele usa um arquivo YAML (docker-compose.yml) para configurar serviços, redes e volumes, permitindo subir toda a infraestrutura com um único comando: docker compose up -d.

Exemplo 1: Apenas o PostgreSQL

Precisa de um banco de dados rápido para testes na sua máquina sem "sujar" o seu Windows/Mac com instalações do Postgres? Use o Compose:

services:
  db:
    image: postgres:16-alpine
    container_name: meu_postgres
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: password123
      POSTGRES_DB: meubanco
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata: # Mantém os dados salvos mesmo se o container for apagado

Exemplo 2: Spring Boot + PostgreSQL Juntos

Agora vamos conectar a nossa API construída no passo 4 com o banco de dados. O Compose cria uma rede interna onde os containers se conversam pelos nomes dos serviços (o Spring vai achar o banco na URL jdbc:postgresql://db:5432/meubanco).

services:
  # Serviço da nossa API Spring Boot
  api:
    build: . # Constrói a imagem lendo o Dockerfile da pasta atual
    container_name: spring_api
    ports:
      - "8080:8080"
    environment:
      - SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/meubanco
      - SPRING_DATASOURCE_USERNAME=admin
      - SPRING_DATASOURCE_PASSWORD=password123
    depends_on:
      - db # Garante que a API só inicie DEPOIS do banco de dados

  # Serviço do Banco de Dados
  db:
    image: postgres:16-alpine
    container_name: postgres_db
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: password123
      POSTGRES_DB: meubanco
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Ao rodar docker compose up -d --build, o Docker construirá a imagem do Spring, baixará a do Postgres e subirá ambos conectados na mesma rede!