Comment utiliser la commande docker compose build pour construire des services

Introduction

Dans ce labo, vous apprendrez à utiliser efficacement la commande docker compose build pour construire les services définis dans un fichier Docker Compose. Vous commencerez par préparer un fichier Docker Compose simple pour définir une application multi-conteneurs.

Après la configuration, vous construirez les services en utilisant la commande docker compose build. Vous explorerez ensuite comment reconstruire les services après avoir apporté des modifications à leurs Dockerfiles correspondants. Enfin, vous apprendrez à construire des services avec des arguments de build (build arguments) et comment utiliser l'option --no-cache pour une construction propre (clean build).

Skills Graph

Préparer un fichier Docker Compose simple

Dans cette étape, vous apprendrez à créer un fichier Docker Compose basique pour définir et gérer des applications Docker multi-conteneurs. Docker Compose est un outil permettant de définir et d'exécuter des applications Docker multi-conteneurs. Avec Compose, vous utilisez un fichier YAML pour configurer les services de votre application. Ensuite, avec une seule commande, vous créez et démarrez tous les services à partir de votre configuration.

Tout d'abord, installons Docker Compose. Comme il n'est pas préinstallé dans l'environnement LabEx, nous devons télécharger le binaire.

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

Cette commande télécharge le binaire Docker Compose depuis la page officielle des releases GitHub et l'enregistre dans /usr/local/bin/docker-compose. Les parties $(uname -s) et $(uname -m) détectent automatiquement votre système d'exploitation et votre architecture pour télécharger le bon binaire.

Ensuite, nous devons donner les permissions d'exécution au binaire téléchargé.

sudo chmod +x /usr/local/bin/docker-compose

Cette commande rend la commande docker-compose exécutable.

Maintenant, vérifions l'installation en consultant la version.

docker-compose --version

Vous devriez voir une sortie similaire à Docker Compose version v2.20.2, confirmant que Docker Compose est correctement installé.

Maintenant, créons un fichier Docker Compose simple. Nous allons définir un service utilisant l'image nginx.

Accédez à votre répertoire de projet.

cd ~/project

Créez un nouveau fichier nommé docker-compose.yml avec l'éditeur nano.

nano docker-compose.yml

Ajoutez le contenu suivant au fichier :

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Décomposons ce fichier :

• version: '3.8' spécifie la version du format de fichier Docker Compose.
• services: définit les différents services composant votre application.
• web: est le nom de notre service. Vous pouvez choisir n'importe quel nom.
• image: nginx:latest spécifie l'image Docker à utiliser pour ce service. Ici, nous utilisons la dernière version de l'image officielle Nginx.
• ports: mappe les ports entre la machine hôte et le conteneur. "80:80" mappe le port 80 de l'hôte vers le port 80 du conteneur.

Enregistrez le fichier en appuyant sur Ctrl + X, puis Y, et Entrée.

Maintenant, téléchargeons l'image nginx:latest que nous avons spécifiée dans notre fichier docker-compose.yml. Bien que Docker Compose puisse télécharger automatiquement les images lorsque vous exécutez docker-compose up, il est recommandé de les télécharger explicitement au préalable, surtout dans un environnement de labo, pour s'assurer de leur disponibilité.

docker pull nginx:latest

Cette commande télécharge l'image nginx:latest depuis Docker Hub. Vous verrez une sortie indiquant la progression du téléchargement.

Construire des services avec docker compose build

Dans l'étape précédente, nous avons créé un fichier docker-compose.yml simple utilisant une image Docker existante (nginx). Docker Compose peut également construire des images à partir d'un Dockerfile. Ceci est utile lorsque vous devez personnaliser une image ou construire une image pour votre propre application.

Dans cette étape, nous allons modifier notre fichier docker-compose.yml pour construire une image à partir d'un Dockerfile au lieu d'utiliser une image pré-construite.

Commencez par créer un Dockerfile simple dans le répertoire ~/project.

nano ~/project/Dockerfile

Ajoutez le contenu suivant au Dockerfile :

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello, Docker Compose!"]

Explication de ce Dockerfile :

• FROM ubuntu:latest spécifie l'image de base pour notre nouvelle image. Nous utilisons la dernière version de l'image officielle Ubuntu.
• RUN apt-get update && apt-get install -y cowsay met à jour la liste des paquets et installe le package cowsay. La commande cowsay affiche un message dans une bulle dessinée par une vache.
• CMD ["cowsay", "Hello, Docker Compose!"] définit la commande par défaut à exécuter lorsqu'un conteneur est démarré à partir de cette image.

Enregistrez le Dockerfile en appuyant sur Ctrl + X, puis Y, et Entrée.

Maintenant, modifions notre fichier docker-compose.yml pour utiliser ce Dockerfile. Ouvrez le fichier pour édition :

nano ~/project/docker-compose.yml

Remplacez le contenu par :

version: "3.8"
services:
  cow:
    build: .

Dans cette version mise à jour de docker-compose.yml :

• Nous avons changé le nom du service de web à cow pour mieux refléter son objectif.
• Nous avons remplacé la directive image: par build: .. La directive build: . indique à Docker Compose de construire l'image pour ce service en utilisant le Dockerfile situé dans le répertoire courant (.).

Enregistrez le fichier docker-compose.yml en appuyant sur Ctrl + X, puis Y, et Entrée.

Nous pouvons maintenant utiliser la commande docker-compose build pour construire l'image du service cow. Assurez-vous d'être dans le répertoire ~/project.

cd ~/project
docker-compose build

Cette commande lira le fichier docker-compose.yml, trouvera le service cow et construira l'image basée sur le Dockerfile du répertoire courant. Vous verrez la sortie montrant les étapes du processus de construction, incluant le téléchargement de l'image de base Ubuntu, la mise à jour des paquets et l'installation de cowsay.

Une fois la construction terminée, vous pouvez vérifier que l'image a bien été créée en listant vos images Docker locales.

docker images

Vous devriez voir une image nommée similairement à project_cow (Docker Compose nomme automatiquement les images selon le nom du répertoire et du service) avec un tag comme latest.

Reconstruire les services après modification du Dockerfile

Dans l'étape précédente, nous avons construit une image Docker en utilisant un Dockerfile et la commande docker-compose build. Que se passe-t-il si nous modifions le Dockerfile ? Docker utilise un mécanisme de cache pour accélérer le processus de construction. Si une couche dans le Dockerfile n'a pas changé, Docker utilisera la version mise en cache au lieu de la reconstruire. Cependant, si une couche ou toute couche ultérieure est modifiée, Docker reconstruira ces couches.

Dans cette étape, nous allons modifier notre Dockerfile puis reconstruire l'image pour observer comment Docker gère les changements.

Commencez par modifier le Dockerfile pour changer le message affiché par cowsay. Ouvrez le Dockerfile pour édition :

nano ~/project/Dockerfile

Modifiez la ligne CMD comme suit :

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello again, Docker Compose!"]

Nous avons changé le message de "Hello, Docker Compose!" à "Hello again, Docker Compose!".

Enregistrez le Dockerfile en appuyant sur Ctrl + X, puis Y, et Entrée.

Maintenant, reconstruisons l'image en utilisant à nouveau la commande docker-compose build. Assurez-vous d'être dans le répertoire ~/project.

cd ~/project
docker-compose build

Observez la sortie du processus de construction. Vous remarquerez que les deux premières étapes (FROM ubuntu:latest et RUN apt-get update && apt-get install -y cowsay) utiliseront probablement les couches mises en cache de la construction précédente. Cependant, la dernière étape (CMD ["cowsay", "Hello again, Docker Compose!"]) sera reconstruite car nous avons modifié cette ligne dans le Dockerfile.

Une fois la construction terminée, vous pouvez vérifier que l'image a été mise à jour en listant vos images Docker locales.

docker images

L'image project_cow devrait maintenant refléter les changements apportés au Dockerfile. Bien que l'ID de l'image puisse changer, le nom et le tag resteront les mêmes.

Pour confirmer le changement, nous pouvons exécuter un conteneur à partir de cette nouvelle image et observer le résultat.

docker run project_cow

Vous devriez voir la sortie de cowsay avec le message mis à jour : "Hello again, Docker Compose!".

Construire des services avec arguments de build et sans cache

Dans cette étape, nous allons explorer deux options avancées de construction avec Docker Compose : l'utilisation d'arguments de build et la construction sans cache.

Les arguments de build (build arguments) permettent de passer des variables au processus de construction Docker. Ceci est utile pour personnaliser la construction selon différents environnements ou configurations sans modifier le Dockerfile lui-même.

Commencez par modifier notre Dockerfile pour accepter un argument de build. Ouvrez le Dockerfile pour édition :

nano ~/project/Dockerfile

Modifiez le contenu comme suit :

FROM ubuntu:latest
ARG MESSAGE="Hello from build argument!"
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "$MESSAGE"]

Nous avons ajouté une instruction ARG MESSAGE pour définir un argument de build nommé MESSAGE avec une valeur par défaut. Nous avons également modifié l'instruction CMD pour utiliser cet argument.

Enregistrez le Dockerfile en appuyant sur Ctrl + X, puis Y, et Entrée.

Maintenant, modifions notre fichier docker-compose.yml pour passer une valeur à cet argument de build. Ouvrez le fichier pour édition :

nano ~/project/docker-compose.yml

Modifiez le contenu comme suit :

version: "3.8"
services:
  cow:
    build:
      context: .
      args:
        MESSAGE: "Custom message from Compose!"

Nous avons transformé la directive build: en un objet avec context: et args:.

• context: . spécifie le contexte de build, c'est-à-dire le répertoire contenant le Dockerfile.
• args: est un mapping d'arguments de build à passer au Dockerfile. Nous passons la valeur "Custom message from Compose!" à l'argument MESSAGE.

Enregistrez le fichier docker-compose.yml en appuyant sur Ctrl + X, puis Y, et Entrée.

Maintenant, construisons l'image avec l'argument de build. Assurez-vous d'être dans le répertoire ~/project.

cd ~/project
docker-compose build

Observez la sortie de la construction. Vous devriez voir que l'argument de build est utilisé pendant le processus.

Une fois la construction terminée, exécutons un conteneur à partir de cette image pour voir le résultat.

docker run project_cow

Vous devriez voir la sortie de cowsay avec le message "Custom message from Compose!". Ceci confirme que l'argument de build a bien été transmis et utilisé.

Parfois, vous pourriez vouloir forcer Docker à reconstruire toutes les couches, en ignorant le cache. Ceci est utile lorsque vous suspectez des problèmes de cache ou souhaitez garantir une construction propre. Vous pouvez le faire en utilisant le flag --no-cache avec la commande docker-compose build.

Essayons de reconstruire l'image avec le flag --no-cache.

docker-compose build --no-cache

Observez à nouveau la sortie de la construction. Cette fois, vous verrez que Docker n'utilise aucune couche mise en cache et reconstruit chaque étape du Dockerfile. Ce processus prendra plus de temps qu'une construction avec cache.

Une fois la construction terminée, vous pouvez exécuter à nouveau le conteneur pour confirmer que le message est toujours celui passé via l'argument de build.

docker run project_cow

Vous devriez toujours voir "Custom message from Compose!". Le flag --no-cache n'affecte que le processus de construction, pas la configuration définie dans docker-compose.yml.

Résumé

Dans ce lab, vous avez appris à préparer un fichier Docker Compose simple en installant Docker Compose et en créant un fichier docker-compose.yml pour définir un service utilisant l'image nginx. Vous avez ensuite pratiqué la construction de services avec la commande docker compose build, y compris la reconstruction des services après modification du Dockerfile et la construction de services avec arguments de build sans utiliser le cache.