Otimizando Tamanho de Imagens Docker para Kubernetes

Imagens Docker gigantes são um problema silencioso em ambientes Kubernetes. Você já parou para pensar quanto tempo e banda estão sendo gastos puxando uma imagem de 2GB para cada novo deployment? Neste post, vou compartilhar estratégias práticas para reduzir o tamanho das suas imagens sem sacrificar funcionalidade.

O que é otimização de imagens de container?

É o processo de reduzir o tamanho do arquivo (layer) de uma imagem Docker mantendo toda a funcionalidade necessária. Uma imagem menor significa pulls mais rápidos, menos consumo de armazenamento no registry e deploys mais eficientes em Kubernetes.

Por que isso importa em Kubernetes?

Em um cluster Kubernetes, você pode ter dezenas ou centenas de nodes. Quando você faz um deploy de uma nova versão, o kubelet precisa fazer o pull da imagem. Uma imagem de 500MB vs. 100MB não parece grande diferença, mas multiplique por 50 nodes e você está falando de 20GB de transferência versus 5GB.

Sem contar que imagens menores consomem menos espaço em disco nos nodes, deixam menos margem para node pressure, e tornam o scaling mais ágil.

Multi-stage builds: o caminho para imagens menores

O truque mais eficiente é usar multi-stage builds. A ideia é separar a etapa de build da etapa de runtime.

# Estágio 1: Build
FROM golang:1.23-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o app .

# Estágio 2: Runtime
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/app .
CMD ["./app"]

No primeiro estágio você tem todo o Go toolchain (300MB+). No segundo estágio, você começa do zero com apenas o binário compilado. Resultado: uma imagem de ~15MB em vez de 400MB.

Reduzindo camadas desnecessárias

Cada instrução RUN no Dockerfile cria uma nova layer. Se você está instalando dependências e limpando cache, faça tudo em um único RUN:

# ❌ Ruim: 3 layers
RUN apk add curl
RUN apk add wget
RUN rm -rf /var/cache/apk/*

# ✅ Bom: 1 layer
RUN apk add --no-cache curl wget

A flag --no-cache já previne o acúmulo de cache do APK. Se você estiver usando apt (Debian), combine com rm -rf /var/lib/apt/lists/*.

Escolha a imagem base certa

Não use imagens gigantes se uma menor serve:

• alpine:latest → ~7MB (Go, Node, Python)
• debian:bookworm-slim → ~80MB (se você precisa de mais ferramentas)
• distroless → ~20-50MB (Google’s distroless images, perfeitas para Go)

Para Go especificamente, considere distroless/base-debian12:

FROM golang:1.23-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o app .

FROM gcr.io/distroless/base-debian12
COPY --from=builder /app/app /
CMD ["/app"]

Você fica com uma imagem de ~30MB contendo apenas o essencial.

Exemplo prático: antes e depois

Aqui está um projeto Go real que otimizei:

Antes:

$ docker images
myapp    latest    455MB    2 hours ago

Dockerfile original:

FROM golang:1.23
WORKDIR /app
COPY . .
RUN go build -o app .
CMD ["./app"]

Depois:

FROM golang:1.23-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o app .

FROM distroless/base-debian12
COPY --from=builder /app/app /
USER nonroot
CMD ["/app"]

Resultado:

$ docker images
myapp    latest    28MB    5 minutes ago

Uma redução de 94% no tamanho da imagem. Em um cluster com 50 nodes, isso significa 21GB menos trafegado por pull. Sem contar com o espaço em disco do node que também irá reduzir.

Verificando o tamanho de suas imagens atuais

Use docker history para ver exatamente qual layer está ocupando espaço:

docker history myapp:latest

Procure por layers gigantes — geralmente são caches de gerenciadores de pacotes ou dependências de build que não foram limpas.

Conclusão

Otimizar imagens Docker é uma daquelas melhorias que parece pequena no isolamento, mas em escala (Kubernetes) faz diferença real. Multi-stage builds, imagens base slim e limpeza de camadas são as três alavancas principais. Comece por aí e você verá deploys mais rápidos, menos consumo de banda, e menos pressão nos nodes.

Gostou do conteúdo?

• ✅ Inscreva-se na newsletter para receber mais dicas práticas sobre Go e Cloud diretamente no seu e-mail!
• 🚀 Conheça a Imersão Golang e leve seus conhecimentos em Go para o próximo nível!

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.