Docker Completo: do zero ao production-ready

# ❌ RUIM — 3 camadas, 3 passos de cache invalidados por coisas que não deveriam
FROM ubuntu:24.04
RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y git

# ✅ BOM — 1 camada, limpeza de cache do apt no final, menor
FROM ubuntu:24.04
RUN apt-get update \
 && apt-get install -y --no-install-recommends curl git \
 && rm -rf /var/lib/apt/lists/*

# ❌ Reinstala dependências a cada mudança de código
FROM node:20-alpine
WORKDIR /app
COPY . .
RUN npm ci
CMD ["node", "server.js"]

# ✅ Cache-friendly — deps só reinstalam quando package.json muda
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
CMD ["node", "server.js"]

# ─── Node.js / TypeScript ──────────────────────────────────────
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY package*.json ./
RUN npm ci --omit=dev
COPY --from=builder /app/dist ./dist
USER node
EXPOSE 3000
CMD ["node", "dist/server.js"]

# ─── Go (imagem final "scratch" = ~6 MB) ────────────────────────
FROM golang:1.23-alpine AS builder
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /bin/app ./cmd/api

FROM scratch
COPY --from=builder /bin/app /app
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
EXPOSE 8080
ENTRYPOINT ["/app"]

# ─── Python (com distroless — sem shell, sem apt, ~40 MB) ───────
FROM python:3.12-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt

FROM gcr.io/distroless/python3-debian12
WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY . .
ENV PATH=/root/.local/bin:$PATH
CMD ["server.py"]

# Padrão profissional: ENTRYPOINT é o binário, CMD são flags default
ENTRYPOINT ["./myapp"]
CMD ["--port=8080", "--log-level=info"]

# docker run img              → roda: ./myapp --port=8080 --log-level=info
# docker run img --log=debug  → roda: ./myapp --log=debug
# docker run --entrypoint=sh img  → abre shell (útil pra debug)

# compose.yaml — app Node + Postgres + Redis com healthchecks e volumes
services:
  web:
    build: .
    ports: ["3000:3000"]
    environment:
      DATABASE_URL: postgres://app:secret@db:5432/app
      REDIS_URL: redis://cache:6379
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: app
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app"]
      interval: 5s
      retries: 5

  cache:
    image: redis:7-alpine
    volumes:
      - redisdata:/data

volumes:
  pgdata:
  redisdata:

# Criar rede bridge customizada (com DNS entre containers por nome)
docker network create backend

# Subir containers nela
docker run -d --name db --network backend postgres:16-alpine
docker run -d --name api --network backend -p 3000:3000 my-api:1.0

# Dentro do container api, conectar em "db:5432" funciona por DNS.
# O bridge default (sem --network) NÃO tem DNS por nome — sempre crie uma rede.

# Named volume (recomendado em prod)
docker run -d --name db -v pgdata:/var/lib/postgresql/data postgres:16-alpine

# Bind mount (dev — código refletindo no container)
docker run -d --name dev -v "$(pwd):/app" -w /app node:20 npm run dev

# tmpfs (dados sensíveis que não devem tocar o disco)
docker run -d --tmpfs /run/secrets:size=10M my-app:1.0

# Backup de um named volume
docker run --rm -v pgdata:/data -v "$(pwd):/backup" alpine \
  tar czf /backup/pgdata-$(date +%F).tgz -C /data .

# Tag + push pro GHCR
docker build -t ghcr.io/me/app:1.2.0 -t ghcr.io/me/app:latest .
echo "$GH_TOKEN" | docker login ghcr.io -u me --password-stdin
docker push ghcr.io/me/app:1.2.0
docker push ghcr.io/me/app:latest

# Padrão production-hardened (Node)
FROM node:20-alpine AS runner
WORKDIR /app

# Usuário não-root
RUN addgroup -S app && adduser -S app -G app
COPY --chown=app:app . .
RUN npm ci --omit=dev

USER app
EXPOSE 3000

# Healthcheck pra orquestrador reiniciar container travado
HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
  CMD node -e "fetch('http://127.0.0.1:3000/health').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"

ENTRYPOINT ["node"]
CMD ["server.js"]

# Imagens
docker build -t app:1.0 .           # build do diretório atual
docker images                       # lista imagens locais
docker tag app:1.0 ghcr.io/me/app:1.0
docker push ghcr.io/me/app:1.0
docker pull nginx:1.27-alpine
docker rmi app:0.9                  # remove imagem

# Containers
docker run -d --name web -p 80:80 nginx:1.27-alpine
docker ps                           # containers em execução
docker ps -a                        # inclui parados
docker logs -f --tail 100 web       # logs ao vivo
docker exec -it web sh              # shell dentro
docker stop web && docker rm web    # para e remove
docker restart web

# Inspeção / debug
docker inspect web                  # JSON com tudo (rede, mounts, env)
docker stats                        # top de CPU/mem por container
docker top web                      # processos dentro do container
docker diff web                     # o que mudou na camada R/W
docker port web                     # mapa de portas

# Limpeza (cuidado em prod — apaga de verdade)
docker system df                    # quanto disco está sendo usado
docker system prune -a --volumes    # apaga imagens, containers, volumes não usados
docker builder prune                # só o cache do BuildKit

# Cache mount: npm ci fica MUITO mais rápido em rebuilds
# syntax=docker/dockerfile:1.7
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN --mount=type=cache,target=/root/.npm npm ci --omit=dev
COPY . .
CMD ["node", "server.js"]