Constructions en plusieurs étapes pour gagner en efficacité

Bienvenue dans l’optimisation avancée des Dockerfile ! Aujourd’hui, nous allons découvrir les compilations en plusieurs étapes, une technique puissante pour créer des images Docker plus petites et plus efficaces.

Des images plus petites permettent des téléchargements plus rapides, une sécurité renforcée et une meilleure utilisation des ressources.

Lorsque vous construisez une image Docker, elle contient souvent des outils et des dépendances nécessaires uniquement pendant le processus de compilation, et non lors de l’exécution finale de l’application.

• Téléchargements plus rapides : les images plus petites se téléchargent plus rapidement.
• Moins d’espace disque : cela économise de l’espace de stockage sur les registres et les hôtes.
• Surface d’attaque réduite : moins de composants signifie moins de vulnérabilités potentielles.
• Sécurité renforcée : votre image de production ne contient que les éléments essentiels.

Prenons le cas d’une application compilée, comme une application écrite en Go. Un Dockerfile traditionnel à étape unique inclurait l’intégralité du compilateur Go et des dépendances de développement dans l’image finale.

L’image finale serait ainsi beaucoup plus volumineuse que nécessaire, car le compilateur n’est pas requis pour exécuter le fichier binaire compilé.

Voici une application Go simple et un Dockerfile qui la construit en une seule étape. Remarquez que l’environnement de compilation est inclus dans l’image finale.

main.go :

Ce Dockerfile utilise `golang:1.21-alpine` comme base. Après la compilation de l’application, cette image de base volumineuse, ainsi que tous ses outils de compilation, reste dans l’image finale.

Les compilations en plusieurs étapes résolvent ce problème en vous permettant de définir plusieurs instructions `FROM` dans un seul Dockerfile. Chaque `FROM` démarre une nouvelle étape de compilation.

• Utilisez le mot-clé AS pour nommer une étape (par exemple, FROM golang:1.21-alpine AS builder).
• Vous pouvez ensuite copier des artefacts depuis une étape précédente à l’aide de COPY --from=<stage_name>.

Seule l’étape finale est enregistrée comme image.

Un Dockerfile classique en plusieurs étapes comporte au moins deux étapes :

• Étape de compilation : elle contient tous les outils et le code source nécessaires pour compiler votre application.
• Étape d’exécution : une image de base minimale qui contient uniquement l’application compilée et ses dépendances d’exécution.

L’image intermédiaire de l’étape de compilation est supprimée, ce qui laisse une image finale légère.

Réécrivons le Dockerfile de notre application Go en utilisant une approche en plusieurs étapes. Nous construirons l’application lors de la première étape, puis nous copierons uniquement le fichier binaire compilé dans une image de base `alpine` beaucoup plus petite.

Lorsque vous construisez ce Dockerfile, Docker exécute chaque étape. Toutefois, seul le contenu de la dernière instruction `FROM`, associé aux fichiers copiés depuis les étapes précédentes, constitue l’image finale.

Le résultat est une image nettement plus petite que celle issue d’une compilation à étape unique, car le compilateur Go et les outils de compilation restent dans les étapes précédentes.

Les compilations en plusieurs étapes sont particulièrement utiles pour :

• Les langages compilés : Go, Java, C++ et Rust.
• Les infrastructures frontales : construire des applications React/Angular et servir des ressources statiques avec Nginx.
• Les applications Node.js : installer `node_modules` dans une étape de compilation, puis copier uniquement `package.json`, `package-lock.json` et l’application construite dans une image d’exécution légère.

Quels sont les principaux avantages de l’utilisation de compilations Docker en plusieurs étapes ?

Vous avez découvert les compilations Docker en plusieurs étapes !

• Elles utilisent plusieurs instructions FROM dans un seul Dockerfile.
• Le mot-clé AS nomme les étapes, et COPY --from= transfère les artefacts.
• Le principal avantage réside dans des images finales nettement plus petites, plus sécurisées et plus efficaces.

Cette technique est essentielle pour optimiser vos applications conteneurisées. Ensuite, nous verrons comment exploiter la mise en cache des compilations !