O problema antes do Docker

Clássico:

Na minha máquina funciona.

E no servidor?

Morreu.

Docker resolveu exatamente isso.

O que é Docker?

Docker empacota:

• aplicação

• dependências

• runtime

• configuração

Tudo dentro de um container.

Container NÃO é máquina virtual

VM:

• pesado

• sistema operacional completo

Container:

• leve

• rápido

• compartilha kernel

Conceitos fundamentais

Image

Molde do container.

Container

Instância rodando da image.

Dockerfile

Receita da imagem.

Volume

Persistência de dados.

Network

Comunicação entre containers.

Exemplo real Spring Boot

Dockerfile

FROM eclipse-temurin:21

WORKDIR /app

COPY target/api.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java","-jar","app.jar"]

Build da imagem

docker build -t nexu-api .

Rodando container

docker run -p 8080:8080 nexu-api

Docker Compose

Projeto real usa múltiplos containers.

Exemplo:

• API

• PostgreSQL

• Redis

• Kafka

docker-compose.yml

services:

  postgres:
    image: postgres:16
    environment:
      POSTGRES_DB: nexu

  api:
    build: .
    ports:
      - "8080:8080"

Persistência com Volumes

Sem volume: desligou container → perdeu dados.

Exemplo

volumes:
  - postgres_data:/var/lib/postgresql/data

Redes Docker

Containers se comunicam pelo nome.

Exemplo:

jdbc:postgresql://postgres:5432/nexu

Multi-stage build

Reduz tamanho da imagem.

FROM gradle:8-jdk21 AS build

COPY . .

RUN gradle build

FROM eclipse-temurin:21

COPY --from=build app.jar app.jar

Erros clássicos

1. Imagem gigante

Java image de 2GB. Clássico.

2. Rodar tudo como root

Perigoso.

3. Não usar .dockerignore

Build lento.

4. Persistência errada

Banco perde tudo.

Docker em produção

Hoje Docker virou padrão.

Usado com:

• Kubernetes

• ECS

• Azure

• GCP

• CI/CD

Conclusão

Docker mudou desenvolvimento moderno.

Hoje:

• backend

• frontend

• mobile backend

• banco

• fila

• observabilidade

Tudo roda em containers.

Quem domina Docker sobe muito de nível.