Como você usa a construção em múltiplas etapas (multistage) para otimizar as imagens Docker?

A construção em múltiplas camadas permite usar várias etapas (layers) em um Dockerfile, onde cada etapa realiza sua própria tarefa. O resultado de uma etapa (por exemplo, um artefato compilado) é passado para a próxima, mas as camadas intermediárias das etapas anteriores não são incluídas na imagem final.

Exemplo de uso para compilar uma aplicação Go:

# Etapa de compilação
FROM golang:1.20-alpine AS builder
WORKDIR /app
COPY . .
RUN go build -o /app/myapp

# Etapa final
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp /app/
CMD ["/app/myapp"]

Vantagens:

• Redução do tamanho da imagem: Na imagem final, apenas a aplicação compilada e suas dependências necessárias são incluídas, não as ferramentas de compilação, o código fonte ou arquivos intermediários.
• Separação de preocupações: A lógica de compilação/desenvolvimento é separada da lógica de implantação.
• Aumento da segurança: A superfície de ataque é reduzida ao excluir ferramentas e bibliotecas desnecessárias da imagem final.
• Aceleração de compilação: O cache de camadas entre etapas pode acelerar recompilações.

Por exemplo, no Dockerfile fornecido, a primeira camada builder é usada para compilar a aplicação Go. A segunda camada, que começa com FROM alpine:latest, copia apenas a aplicação compilada da primeira camada (COPY --from=builder /app/myapp /app/) para uma imagem base limpa. Como resultado, a imagem final contém apenas o arquivo executável e o sistema operacional básico, sem o compilador Go e o código fonte.

Isso reduz significativamente o tamanho da imagem em comparação com a abordagem tradicional, onde a compilação e a execução ocorrem em um único contêiner.