Que sont les builds Docker en plusieurs étapes? –
Les builds Docker en plusieurs étapes vous permettent d’écrire des fichiers Docker avec plusieurs FROM déclarations. Cela signifie que vous pouvez créer des images qui dérivent de plusieurs bases, ce qui peut vous aider à réduire la taille de votre construction finale.
Les images Docker sont créées en sélectionnant une image de base à l’aide du FROM déclaration. Vous ajoutez ensuite des couches à cette image en ajoutant des commandes à votre Dockerfile.
Avec les versions en plusieurs étapes, vous pouvez diviser votre Dockerfile en plusieurs sections. Chaque étape a son propre FROM afin que vous puissiez impliquer plus d’une image dans vos builds. Les étapes sont construites séquentiellement et peuvent référencer leurs prédécesseurs, vous pouvez donc copier la sortie d’un calque dans le suivant.
Sommaire
Constructions en plusieurs étapes en action
Voyons comment vous pouvez créer une construction en plusieurs étapes. Nous travaillons avec un projet PHP barebones qui utilise Composer pour ses dépendances et Sass pour ses feuilles de style.
Voici un Dockerfile en plusieurs étapes qui encapsule l’ensemble de notre build:
FROM node:14 AS sass WORKDIR /example RUN npm install -g node-sass COPY example.scss . RUN node-sass example.scss example.css FROM php:8.0-apache COPY --from=composer:2 /usr/bin/composer /usr/bin/composer COPY composer.json . COPY composer.lock . RUN composer install --no-dev COPY --from=sass /example/example.css example.css COPY index.php . COPY src/ src
Tout de suite, vous observerez que nous en avons deux FROM instructions qui divisent notre Dockerfile en deux sections logiques. La première étape est consacrée à la compilation du Sass, tandis que la seconde se concentre sur la combinaison de tout dans le conteneur final.
Nous utilisons le node-sass mise en œuvre de Sass. On part donc d’une image de base Node.JS, dans laquelle on installe node-sass globalement à partir de npm. Nous utilisons ensuite node-sass pour compiler notre feuille de style example.scss dans le CSS pur example.css. Le résumé de haut niveau de cette étape est que nous prenons une image de base, exécutons une commande et obtenons une sortie que nous aimerions utiliser plus tard dans notre build (example.css).
L’étape suivante présente l’image de base de notre application: php8.0-apache. Le dernier FROM L’instruction dans votre Dockerfile définit l’image que vos conteneurs finiront par exécuter. Notre plus tôt node image n’est finalement pas pertinente pour les conteneurs de notre application – elle est utilisée uniquement comme un outil pratique de construction.
Nous utilisons ensuite Composer pour installer nos dépendances PHP. Composer est le gestionnaire de packages de PHP mais il n’est pas inclus avec les images officielles de PHP Docker. Nous copions donc le binaire dans notre conteneur à partir de l’image Composer dédiée.
Nous n’avons pas besoin d’un FROM déclaration pour ce faire. Comme nous n’exécutons aucune commande sur l’image Composer, nous pouvons utiliser le --from drapeau avec COPY pour référencer l’image. Ordinairement, COPY copie les fichiers de votre contexte de construction local dans votre image; avec --from et un nom d’image, il créera un nouveau conteneur en utilisant cette image, puis en copiera le fichier spécifié.
Plus tard, notre Dockerfile utilise COPY --from encore une fois, cette fois sous une forme différente. De retour en haut, nous avons écrit notre premier FROM déclaration comme FROM node:14 AS sass. le AS clause a créé une étape nommée appelée sass.
Nous maintenant référence le conteneur transitoire créé par cette étape en utilisant COPY --from=sass. Cela nous permet de copier notre CSS intégré dans notre image finale. Le reste des étapes est de routine COPY opérations, utilisées pour obtenir notre code source à partir de notre répertoire de travail local.
Avantages des constructions en plusieurs étapes
Les builds en plusieurs étapes vous permettent de créer des routines de build complexes avec un seul Dockerfile. Avant leur introduction, il était courant pour les projets complexes d’utiliser plusieurs Dockerfiles, un pour chaque étape de leur construction. Celles-ci devaient ensuite être orchestrées par des scripts shell écrits manuellement.
Avec les builds en plusieurs étapes, tout notre système de build peut être contenu dans un seul fichier. Vous n’avez pas besoin de scripts wrapper pour faire passer votre projet de la base de code brute à l’image finale de l’application. Un habitué docker build -t my-image:latest . est suffisant.
Cette simplification offre également la possibilité d’améliorer l’efficacité de vos images. Les images Docker peuvent devenir volumineuses, surtout si vous utilisez un environnement d’exécution de langage comme base.
Prenez le fonctionnaire golang image: c’est près de 300 Mo. Traditionnellement, vous pouvez copier votre source Go dans l’image et l’utiliser pour compiler votre binaire. Vous recopieriez ensuite votre binaire sur votre machine hôte avant de démarrer une autre compilation. Celui-ci utiliserait un Dockerfile avec une image de base légère telle que alpine (environ 10 Mo). Vous rajouteriez votre binaire, ce qui donnerait une image beaucoup plus petite que si vous aviez utilisé l’original golang base pour exécuter vos conteneurs.
Avec les versions en plusieurs étapes, ce type de système est beaucoup plus facile à implémenter:
FROM golang:latest WORKDIR /go COPY app.go . RUN go build -o my-binary FROM alpine:latest WORKDIR /app COPY --from=build /go/my-binary . CMD ["./my-binary"]
En huit lignes, nous avons réussi à réaliser une procédure qui aurait auparavant nécessité au moins trois fichiers – un golang Dockerfile, un alpine Dockerfile et un script shell pour gérer les étapes intermédiaires.
Conclusion
Les builds en plusieurs étapes peuvent considérablement simplifier la construction d’images Docker complexes. Ils vous permettent d’impliquer plusieurs étapes de construction interconnectées qui peuvent transmettre des artefacts de sortie.
Le modèle favorise également l’efficacité de la construction. La facilité avec laquelle vous pouvez référencer différentes images de base aide les développeurs à s’assurer que la sortie finale est aussi petite que possible. Vous bénéficierez de coûts de stockage et de bande passante réduits, ce qui peut être important lors de l’utilisation de Docker dans un système CI / CD.
