Couches d’images et optimisation

Les images Docker ne sont pas constituées d’un fichier unique et gigantesque. Elles sont plutôt construites à partir d’une série de couches en lecture seule. Imaginez ces couches comme des transparents empilés.

Chaque couche représente une modification apportée à l’image, ce qui rend les images efficaces et flexibles. Ce système de couches est fondamental dans le fonctionnement de Docker.

Lorsque vous écrivez un Dockerfile, presque chaque instruction crée une nouvelle couche au-dessus de la précédente. Les instructions telles que FROM, RUN, COPY et ADD contribuent toutes à créer de nouvelles couches.

Docker exécute ces instructions séquentiellement, en construisant chaque nouvelle couche à partir de l’état de la précédente.

Vous pouvez afficher les couches qui composent une image avec la commande docker history. Cette commande affiche chaque instruction, sa taille et sa date de création, ce qui vous aide à comprendre comment l’image s’est développée.

C’est un outil puissant pour résoudre les problèmes liés à la taille des images.

Docker utilise un cache de création intelligent. Si une instruction de votre Dockerfile et son contexte (par exemple, les fichiers copiés) n’ont pas changé depuis la dernière création, Docker réutilise la couche existante.

Cette réutilisation accélère considérablement les créations suivantes, car Docker n’a pas besoin de réexécuter les étapes inchangées.

L’ordre des instructions dans votre Dockerfile est essentiel pour utiliser efficacement le cache. Placez en haut les instructions qui changent rarement (comme l’installation des dépendances système).

Les instructions qui changent souvent (comme la copie du code de votre application) doivent être placées plus bas. Ainsi, si seul votre code change, Docker peut réutiliser les couches mises en cache correspondant aux dépendances stables.

Comparez ces deux extraits de Dockerfile. Le bon ordre place d’abord les dépendances stables, ce qui permet à Docker de les mettre en cache et de ne recréer que les couches correspondant au code de l’application qui change.

Chaque commande RUN crée généralement une nouvelle couche. Vous pouvez réduire le nombre de couches et souvent la taille finale de l’image en combinant plusieurs commandes dans une seule instruction RUN.

Utilisez l’opérateur && \ pour enchaîner les commandes et les intégrer à une seule couche atomique.

Au lieu d’utiliser plusieurs commandes RUN, enchaînez-les avec && \. Cela crée une seule couche plus efficace pour l’ensemble de ces opérations.

Nettoyez toujours les fichiers qui ne sont nécessaires que pendant le processus de création. Par exemple, les caches des gestionnaires de paquets (comme apt-get clean) ou les artefacts temporaires de création peuvent augmenter considérablement la taille des couches de votre image.

Les nettoyer dans la même commande RUN que celle qui les a créés garantit qu’ils ne persistent pas dans une couche précédente.

Examinez l’extrait de Dockerfile suivant :

FROM alpine:latest
COPY . /app
RUN apk add --no-cache git
RUN apk add --no-cache make
CMD ["sh"]

Quelle modification optimiserait le mieux ce Dockerfile afin de réduire la taille de l’image et d’accélérer potentiellement les recréations ?

Vous avez appris que les images Docker sont construites en couches, chaque instruction en créant souvent une nouvelle. Comprendre cela est essentiel pour les optimiser !

• Ordonnez soigneusement les instructions afin de maximiser les réutilisations du cache de création.
• Regroupez plusieurs commandes RUN en une seule pour réduire le nombre de couches.
• Nettoyez les fichiers temporaires dans les commandes RUN correspondantes afin de conserver des couches peu volumineuses.

Ces techniques permettent de créer des images Docker plus petites et plus rapides à construire, essentielles pour des déploiements efficaces.