Comment utilisez-vous la construction multi-étages (multistage) pour optimiser les images Docker ?

La construction multi-étapes permet d'utiliser plusieurs étapes (layers) dans un Dockerfile, où chaque étape accomplit sa propre tâche. Le résultat d'une étape (par exemple, un artefact compilé) est transmis à l'étape suivante, mais les couches intermédiaires des étapes précédentes ne sont pas incluses dans l'image finale.

Exemple d'utilisation pour compiler une application Go :

# Étape de compilation
FROM golang:1.20-alpine AS builder
WORKDIR /app
COPY . .
RUN go build -o /app/myapp

# Étape finale
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp /app/
CMD ["/app/myapp"]

Avantages :

• Réduction de la taille de l'image : Seule l'application compilée et ses dépendances nécessaires sont incluses dans l'image finale, pas les outils de compilation, le code source ou les fichiers intermédiaires.
• Séparation des préoccupations : La logique de compilation/déploiement est séparée de la logique de déploiement.
• Augmentation de la sécurité : La surface d'attaque est réduite en excluant les outils et bibliothèques inutiles de l'image finale.
• Accélération des compilations : La mise en cache des couches entre les étapes peut accélérer les recompilations.

Par exemple, dans le Dockerfile fourni, la première couche builder est utilisée pour compiler l'application Go. La deuxième couche, qui commence par FROM alpine:latest, ne copie que l'application compilée depuis la première couche (COPY --from=builder /app/myapp /app/) dans une image de base propre. En fin de compte, l'image finale ne contient que le fichier exécutable et le système d'exploitation de base, sans le compilateur Go ni le code source.

Cela réduit considérablement la taille de l'image par rapport à l'approche traditionnelle où la compilation et l'exécution se produisent dans un seul conteneur.