Tirer parti de la mise en cache des constructions

La création d’images Docker peut prendre du temps, en particulier pour les applications complexes. Le cache de construction de Docker est une fonctionnalité intelligente qui permet d’accélérer considérablement le processus !

Il fonctionne en réutilisant les couches des constructions précédentes, afin que Docker n’ait pas à tout reconstruire depuis zéro à chaque fois.

Lorsque vous construisez une image Docker à l’aide d’un Dockerfile, Docker exécute chaque instruction ligne par ligne.

• Chaque instruction, comme FROM, RUN ou COPY, crée une nouvelle « couche » dans votre image.
• Ces couches sont empilées les unes sur les autres pour former l’image finale.

Avant d’exécuter une instruction, Docker vérifie s’il a déjà construit exactement cette couche. Il compare :

• L’instruction elle-même (par exemple, RUN apt update).
• Le « contexte » de certaines instructions (par exemple, les fichiers copiés avec COPY).

Si une couche correspondante est trouvée, Docker la réutilise depuis le cache au lieu d’exécuter à nouveau l’instruction.

Le cache est très utile, mais il n’est pas toujours utilisé. Si Docker détecte une modification dans une instruction ou dans son contexte, le cache de cette couche et de toutes les couches suivantes est invalidé.

Cela signifie que Docker reconstruira l’image à partir de ce point, en ignorant toutes les couches mises en cache qui se trouvent en dessous.

Pour maximiser les utilisations du cache, organisez les instructions de votre Dockerfile de celles qui ont le moins de chances de changer à celles qui ont le plus de chances de changer.

• Dépendances stables en premier : installez les paquets système ou les dépendances de l’application qui changent peu souvent.
• Code de l’application en dernier : copiez le code source de votre application, qui change fréquemment, aussi tard que possible.

Examinons un exemple. En plaçant la commande RUN pip install (qui change généralement moins souvent) avant COPY . . (qui change à chaque mise à jour du code), Docker peut réutiliser la couche des dépendances.

Imaginons que requirements.txt contienne flask et gunicorn, et que app.py soit votre application principale.

Dockerfile :

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
CMD ["python", "app.py"]

Si seul app.py change, Docker ne reconstruit que les dernières couches COPY et CMD, ce qui permet de gagner du temps !

Lorsque vous utilisez COPY . ., Docker vérifie les changements de chaque fichier du contexte de construction. Même de petits fichiers sans importance (comme les dossiers .git ou les données de test locales) peuvent invalider le cache.

Utilisez un fichier .dockerignore pour exclure les fichiers et répertoires inutiles de votre contexte de construction. Vous éviterez ainsi qu’ils ne déclenchent l’invalidation du cache.

Placez un fichier nommé .dockerignore à la racine de votre contexte de construction (à côté de votre Dockerfile).

Exemple de fichier .dockerignore :

.git
.venv
__pycache__
*.log
node_modules

Désormais, lorsque vous utilisez COPY . ., Docker ignore ces fichiers, ce qui permet d’obtenir des utilisations du cache plus fiables !

Parfois, vous voulez vous assurer que tout est construit de nouveau, en ignorant complètement le cache. Cela peut être utile pour le débogage ou pour vous assurer de disposer des toutes dernières versions des dépendances.

Vous pouvez forcer Docker à reconstruire l’image sans utiliser le cache en ajoutant l’option --no-cache à votre commande de construction :

docker build --no-cache -t my-app:latest .

Vous construisez une image Docker pour une application Node.js. Votre Dockerfile se présente actuellement ainsi :

FROM node:16-alpine
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

Quelle modification optimiserait le mieux ce Dockerfile pour la mise en cache de la construction ?

Excellent travail ! Vous avez appris à tirer parti du cache de construction de Docker pour accélérer la création d’images.

• Docker construit les images couche par couche et réutilise les couches mises en cache lorsque c’est possible.
• Les modifications apportées à une instruction ou à son contexte invalident le cache à partir de ce point.
• Optimisez le processus en classant les instructions de celles qui ont le moins de chances de changer à celles qui en ont le plus.
• Utilisez .dockerignore pour exclure les fichiers sans importance du contexte de construction.
• Utilisez --no-cache pour forcer une nouvelle construction lorsque cela est nécessaire.

Une mise en cache efficace accélère les cycles de développement et rend les déploiements plus agiles !