Gérer le cache de build avec --cache-from et --cache-to
Dans cette étape, vous apprendrez à gérer le cache de build Docker en utilisant les flags --cache-from et --cache-to. Le cache de build peut accélérer considérablement les builds ultérieurs en réutilisant les couches des builds précédents. --cache-from vous permet de spécifier une image à utiliser comme source de cache, et --cache-to vous permet d'exporter le cache de build vers un emplacement spécifié (comme un registry ou un répertoire local).
Commencez par vous assurer que vous êtes dans le répertoire ~/project.
cd ~/project
Modifions légèrement notre Dockerfile pour simuler un changement qui invaliderait normalement le cache. Nous ajouterons une simple instruction RUN.
Ouvrez le Dockerfile avec nano :
nano Dockerfile
Ajoutez la ligne suivante après l'instruction ARG dans l'étape builder :
RUN echo "Adding a new layer"
Le Dockerfile mis à jour devrait ressembler à ceci :
## Stage 1: Builder stage
FROM ubuntu:latest as builder
ARG GREETING="Hello from build argument!"
RUN echo "Adding a new layer"
RUN echo $GREETING > /app/greeting.txt
## Stage 2: Final stage
FROM ubuntu:latest
COPY --from=builder /app/greeting.txt /greeting.txt
CMD ["cat", "/greeting.txt"]
Enregistrez le Dockerfile et quittez nano.
Maintenant, reconstruisons l'image sans utiliser d'options de cache spécifiques. Docker utilisera automatiquement le cache local s'il est disponible.
docker build -t my-cached-image .
Vous devriez voir que certaines couches sont reconstruites à partir de zéro car nous avons ajouté une nouvelle instruction, invalidant le cache pour les instructions suivantes.
Simulons maintenant un scénario où vous souhaiteriez utiliser une image précédemment construite comme source de cache, peut-être depuis un registry ou un autre build. À des fins de démonstration, nous utiliserons l'image my-cached-image que nous venons de construire comme source de cache pour un nouveau build.
D'abord, apportons une autre petite modification au Dockerfile pour simuler un autre changement.
Ouvrez le Dockerfile :
nano Dockerfile
Modifiez le message dans la nouvelle instruction RUN :
RUN echo "Adding another new layer"
Le Dockerfile mis à jour devrait ressembler à ceci :
## Stage 1: Builder stage
FROM ubuntu:latest as builder
ARG GREETING="Hello from build argument!"
RUN echo "Adding another new layer"
RUN echo $GREETING > /app/greeting.txt
## Stage 2: Final stage
FROM ubuntu:latest
COPY --from=builder /app/greeting.txt /greeting.txt
CMD ["cat", "/greeting.txt"]
Enregistrez et quittez nano.
Maintenant, reconstruisons l'image, mais cette fois en utilisant le flag --cache-from pour spécifier my-cached-image comme source de cache.
docker build --cache-from my-cached-image -t my-cached-image-from .
Vous devriez observer que Docker tente d'utiliser les couches de my-cached-image. La couche correspondant à la première instruction RUN sera probablement reconstruite car l'instruction a changé, mais les couches suivantes pourraient être récupérées du cache si elles correspondent.
Le flag --cache-to est utilisé pour exporter le cache de build. Ceci est particulièrement utile dans les pipelines CI/CD pour partager le cache entre les builds. Pour utiliser --cache-to, vous avez généralement besoin d'un driver de build qui prend en charge l'exportation de cache, comme le driver docker-container.
D'abord, installons Docker Compose, souvent utilisé avec buildx.
sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
Maintenant, créons une instance de builder buildx.
docker buildx create --use
Construisons maintenant l'image et exportons le cache vers un répertoire local. Nous utiliserons l'exportateur de cache local.
docker buildx build --cache-to type=local,dest=./build-cache -t my-exported-cache-image . --load
docker buildx build : Utilise l'outil buildx pour la construction--cache-to type=local,dest=./build-cache : Exporte le cache vers un répertoire local nommé build-cache-t my-exported-cache-image : Tagge l'image résultante. : Spécifie le contexte de build (répertoire courant)--load : Charge l'image construite dans le cache d'images Docker local
Vous devriez voir une sortie indiquant la construction et l'exportation du cache. Un répertoire build-cache sera créé dans votre répertoire ~/project.
Simulons maintenant un environnement de build propre et essayons de construire en utilisant le cache exporté. D'abord, supprimons les images que nous avons construites.
docker rmi my-cached-image my-cached-image-from my-exported-cache-image
Maintenant, reconstruisons l'image, cette fois en utilisant le cache exporté comme source.
docker buildx build --cache-from type=local,src=./build-cache -t my-imported-cache-image . --load
--cache-from type=local,src=./build-cache : Importe le cache depuis le répertoire local build-cache
Vous devriez observer que Docker utilise les couches du cache exporté, accélérant considérablement le processus de build par rapport à une construction à partir de zéro.
