Comment faire en sorte que Docker reconstruise une image sans son cache

Docker met en cache les résultats de la création d’image pour accélérer les reconstructions ultérieures. Bien que ce mécanisme soit généralement fiable, vous souhaiterez parfois reconstruire une image sans utiliser le cache. Il peut s’agir de diagnostiquer des problèmes ou de vérifier que la procédure de construction complète sera reproductible dans un environnement propre.

Dans cet article, vous apprendrez comment obtenir une nouvelle version sans supprimer manuellement le cache. Vous verrez également comment extraire des images de base mises à jour afin que votre build corresponde à la sortie qu’une nouvelle installation Docker produirait.

Comment fonctionne le cache

Voici un simple Dockerfile :

FROM alpine:latest
COPY 1.txt /1.txt
COPY 2.txt /2.txt

Remplissez les exemples de fichiers dans votre répertoire de travail et créez l’image :

$ echo 1 > 1.txt
$ echo 2 > 2.txt
$ docker build -t demo:latest .

La sortie ressemblera à ceci :

Sending build context to Docker daemon   5.12kB
Step 1/3 : FROM alpine:latest
 ---> 9c6f07244728
Step 2/3 : COPY 1.txt /1.txt
 ---> db61ff73c0b5
Step 3/3 : COPY 2.txt /2.txt
 ---> f1129e47fc12
Successfully built f1129e47fc12
Successfully tagged demo:latest

Modifiez maintenant 2.txt puis reconstruisez l’image :

$ echo two > 2.txt
$ docker build -t demo:latest .
Sending build context to Docker daemon   5.12kB
Step 1/3 : FROM alpine:latest
 ---> 9c6f07244728
Step 2/3 : COPY 1.txt /1.txt
 ---> Using cache
 ---> db61ff73c0b5
Step 3/3 : COPY 2.txt /2.txt
 ---> 75ba7d786049
Successfully built 75ba7d786049
Successfully tagged demo:latest

La deuxième étape de construction montre Using cache parce que le contenu de 1.txt n’ont pas changé. La couche intermédiaire avec ID db61ff73c0b5 est réutilisé pour la nouvelle construction.

Désactivation du cache

Vous pouvez désactiver l’utilisation du cache de la couche intermédiaire en incluant le --no-cache drapeau quand vous courez docker build:

$ echo second > 2.txt
$ docker build --no-cache -t demo:latest .
Sending build context to Docker daemon   5.12kB
Step 1/3 : FROM alpine:latest
 ---> 9c6f07244728
Step 2/3 : COPY 1.txt /1.txt
 ---> 1590b2407dd4
Step 3/3 : COPY 2.txt /2.txt
 ---> afb31630ce32
Successfully built afb31630ce32
Successfully tagged demo:latest

Cette fois, un nouveau calque d’image, ID 1590b2407dd4a été créé par la deuxième étape de construction, même si 1.txt reste inchangé.

Vous pouvez utiliser le --no-cache flag pour forcer une reconstruction lorsque vous pensez que le cache est obsolète ou que vous souhaitez recommencer à zéro. Les performances de construction seront réduites car Docker devra recréer chaque couche.

Extraire des images de base mises à jour

Une autre forme de mise en cache concerne les images de base auxquelles votre Dockerfile fait référence dans son FROM des instructions. L’exemple d’image ci-dessus utilise alpine:latest comme sa base. Docker n’extrairea pas automatiquement une version mise à jour de alpine:latestà moins que l’image n’existe pas déjà sur votre hôte.

Cela signifie que la première version d’un Dockerfile extraira les images de base dont vous avez besoin, tant que vous ne les avez pas déjà. Les reconstructions ultérieures n’actualiseront pas les images, vous pourriez donc construire sur une base obsolète. La création de l’image sur un autre hôte Docker peut ne pas produire le même résultat si cet hôte extrait une version plus récente de la base.

Vous pouvez forcer Docker à vérifier les images de base mises à jour au moment de la construction en ajoutant le --pull drapeau à votre docker build commande. Ceci est séparé de --no-cache. Utilisant --pull récupérera le manifeste de la balise d’image à partir de son registre et le comparera à la version sur votre machine. La nouvelle image sera extraite du registre en cas de divergence dans les manifestes.

$ docker build --no-cache --pull -t demo:latest .
Sending build context to Docker daemon   5.12kB
Step 1/3 : FROM alpine:latest
latest: Pulling from library/alpine
Digest: sha256:bc41182d7ef5ffc53a40b044e725193bc10142a1243f395ee852a8d9730fc2ad
Status: Image is up to date for alpine:latest
 ---> 9c6f07244728
Step 2/3 : COPY 1.txt /1.txt
 ---> 4fee970dfaab
Step 3/3 : COPY 2.txt /2.txt
 ---> 60d2e3fff0fb
Successfully built 60d2e3fff0fb
Successfully tagged demo:latest

L’exemple ci-dessus montre comment la sortie de construction change lorsque le --pull drapeau est utilisé. Docker essaie d’extraire l’image de base Alpine, même si elle se trouve déjà sur la machine à partir des versions d’exemple précédentes. Le résumé d’image (SHA) est imprimé sur le terminal. Dans ce cas, le résumé est inchangé par rapport à la version locale, Docker signale donc que l’image est déjà à jour.

La --no-cache et --pull les drapeaux peuvent être utilisés indépendamment ou en combinaison. Les ajouter tous les deux vous donne l’ardoise la plus propre pour démarrer votre construction, obligeant Docker à vérifier les images de base mises à jour et à ignorer les couches précédemment créées. Cela équivaut à exécuter la construction sur un hôte Docker nouvellement installé.

Utilisation de Docker Compose

Docker Compose prend en charge à la fois le --no-cache et --pull les drapeaux aussi. Ils ont le même effet que leur docker build homologues.

# Compose v2
$ docker compose build --no-cache --pull

# Compose v1
$ docker-compose build --no-cache --pull

Nettoyer le cache de construction

Vous pouvez nettoyer le cache de construction pour vous assurer qu’il n’est plus utilisé. Cela permet également de libérer de l’espace disque excédentaire consommé par les couches de construction mises en cache.

Exécutez le docker builder prune commande pour vider votre cache. Cela ne fonctionne que lorsque vous créez des images avec le moteur de génération moderne BuildKit.

$ docker builder prune

L’exécution de la commande sans arguments supprime uniquement le cache de construction en suspens. Cela concerne les caches qui concernent des images qui ne sont plus présentes sur votre hébergeur. Ajouter le -a flag pour vider complètement le cache, y compris les calques utilisés par les images :

$ docker builder prune -a

La taille accepte également une --filter drapeau qui peut être utilisé pour cibler les caches modifiés avant ou depuis une période de temps particulière.

# Delete caches modified in the past two hours
$ docker build prune --filter since=2h

# Delete caches modified more than two hours ago
$ docker build prune --filter until=2h

Sommaire

Le cache de build Docker améliore les performances en réutilisant les couches d’images intermédiaires entre les builds. Cela évite de perdre du temps à recréer des calques qui existent déjà et qui n’ont pas changé. Bien que le cache de build soit généralement souhaitable, il existe des scénarios dans lesquels vous souhaiterez peut-être exécuter une build sans lui. Ajout de la --no-cache flag à vos builds fournit une perspective précise de ce que la build produirait lorsqu’elle serait exécutée sur un nouvel hôte.

Les images de base obsolètes doivent également être prises en compte parallèlement au cache de construction. Docker réutilise par défaut les versions locales des images de base, ce qui peut vous amener à créer de nouvelles images sur une base obsolète. En utilisant le --pull force Docker à vérifier les images de base mises à jour avant de démarrer la construction, ce qui vous donne une plus grande cohérence entre différents environnements.