Comment utiliser la commande docker compose push pour pousser des images de service

Introduction

Dans ce lab, vous apprendrez à utiliser la commande docker compose push pour envoyer (push) les images de service définies dans un fichier docker-compose.yaml vers un registre (registry). Vous commencerez par préparer un fichier docker-compose.yaml avec des images de service, puis vous construirez ces images. Enfin, vous vous exercerez à envoyer ces images de service vers un registre, y compris la gestion des éventuelles défaillances lors du processus d'envoi.

Skills Graph

Préparer un fichier docker-compose.yaml avec des images de service

Dans cette étape, vous apprendrez à créer un fichier docker-compose.yaml pour définir et gérer des applications multi-conteneurs Docker. Docker Compose est un outil qui permet de définir et 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, accédez au répertoire du projet :

cd ~/project

Maintenant, créons un fichier docker-compose.yaml en utilisant l'éditeur nano. Ce fichier définira deux services : un service web et un service de base de données.

nano docker-compose.yaml

Collez le contenu suivant dans le fichier docker-compose.yaml :

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
  db:
    image: postgres:latest
    environment:
      POSTGRES_PASSWORD: mysecretpassword

Analysons ce fichier :

• version: '3.8' spécifie la version du format de fichier Docker Compose.
• services: définit les différents services qui composent votre application.
• web: définit un service nommé web.
• image: nginx:latest indique que le service web utilisera l'image Docker nginx:latest. Si l'image n'est pas disponible localement, Docker la récupérera depuis Docker Hub.
• ports: mappe le port 80 de la machine hôte vers le port 80 du conteneur.
• db: définit un service nommé db.
• image: postgres:latest indique que le service db utilisera l'image Docker postgres:latest.
• environment: configure les variables d'environnement à l'intérieur du conteneur. Ici, nous définissons le POSTGRES_PASSWORD pour la base de données PostgreSQL.

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

Vous pouvez visualiser le contenu du fichier créé en utilisant la commande cat :

cat docker-compose.yaml

Cette commande affichera le contenu du fichier docker-compose.yaml que vous venez de créer, vous permettant ainsi d'en vérifier le contenu.

Construire les images de service

Dans l'étape précédente, vous avez défini vos services en utilisant des images Docker existantes dans le fichier docker-compose.yaml. Dans cette étape, vous apprendrez à construire des images Docker personnalisées pour vos services en utilisant des Dockerfiles, puis à les intégrer dans votre fichier docker-compose.yaml.

Commencez par créer un répertoire simple pour notre service web et un Dockerfile à l'intérieur. Accédez au répertoire du projet si vous n'y êtes pas déjà :

cd ~/project

Créez un répertoire nommé web et accédez-y :

mkdir web
cd web

Maintenant, créez un Dockerfile nommé Dockerfile dans le répertoire web en utilisant l'éditeur nano :

nano Dockerfile

Collez le contenu suivant dans le Dockerfile :

FROM ubuntu:latest
RUN apt-get update && apt-get install -y nginx
COPY index.html /var/www/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Ce Dockerfile effectue les opérations suivantes :

• FROM ubuntu:latest : Part de l'image de base Ubuntu la plus récente.
• RUN apt-get update && apt-get install -y nginx : Met à jour la liste des paquets et installe Nginx.
• COPY index.html /var/www/html/ : Copie un fichier index.html (que nous créerons ensuite) dans le répertoire racine web de Nginx.
• EXPOSE 80 : Expose le port 80 sur le conteneur.
• CMD ["nginx", "-g", "daemon off;"] : Spécifie la commande à exécuter au démarrage du conteneur, qui consiste à démarrer Nginx en premier plan.

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

Maintenant, créons le fichier index.html que le Dockerfile copie. Restez dans le répertoire ~/project/web et créez le fichier :

nano index.html

Collez le contenu HTML simple suivant dans index.html :

<!doctype html>
<html>
  <head>
    <title>Hello from Docker!</title>
  </head>
  <body>
    <h1>Welcome to my Dockerized Nginx!</h1>
    <p>This page is served from a custom Docker image.</p>
  </body>
</html>

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

Maintenant, retournez au répertoire racine du projet où se trouve votre fichier docker-compose.yaml :

cd ~/project

Nous devons modifier le fichier docker-compose.yaml pour construire le service web à partir du Dockerfile que nous venons de créer, au lieu d'utiliser une image pré-construite. Ouvrez le fichier docker-compose.yaml pour le modifier :

nano docker-compose.yaml

Modifiez la définition du service web pour utiliser l'instruction build au lieu de image :

version: "3.8"
services:
  web:
    build: ./web
    ports:
      - "80:80"
  db:
    image: postgres:latest
    environment:
      POSTGRES_PASSWORD: mysecretpassword

Ici, build: ./web indique à Docker Compose de construire l'image pour le service web en utilisant le Dockerfile situé dans le répertoire ./web relatif au fichier docker-compose.yaml.

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

Maintenant, vous pouvez construire les images définies dans votre fichier docker-compose.yaml en utilisant la commande docker-compose build. Comme Docker Compose n'est pas pré-installé, vous devez d'abord l'installer.

sudo apt-get update
sudo apt-get install docker-compose-plugin -y

Après avoir installé le plugin Docker Compose, vous pouvez utiliser la commande docker compose (notez l'espace au lieu d'un trait d'union dans les versions plus récentes).

docker compose build

Cette commande lira votre fichier docker-compose.yaml et construira l'image pour le service web basée sur le Dockerfile dans le répertoire ./web. Elle récupérera également l'image postgres:latest pour le service db si elle n'est pas déjà présente. Vous verrez une sortie indiquant le processus de construction pour l'image web.

Une fois la construction terminée, vous pouvez lister les images Docker sur votre système pour voir la nouvelle image construite.

docker images

Vous devriez voir une image avec un nom lié à votre répertoire de projet et au nom du service (par exemple, project-web) ainsi que l'image postgres.

Pousser les images de service vers un registre

Dans l'étape précédente, vous avez construit une image Docker personnalisée pour votre service web. Maintenant, vous allez apprendre à pousser ces images vers un registre Docker. Un registre Docker est un système de stockage et de distribution pour les images Docker. Docker Hub est un registre public, et vous pouvez également utiliser des registres privés. Pousser des images vers un registre vous permet de les partager avec d'autres ou de les déployer sur différentes machines.

Avant de pousser, vous devez généralement étiqueter (tag) vos images avec l'adresse du registre, votre nom d'utilisateur et le nom de l'image. Pour ce lab, nous simulerons un push vers un registre local ou un registre ne nécessitant pas d'authentification pour simplifier. Dans un scénario réel, vous devriez d'abord vous connecter au registre avec docker login.

D'abord, listons les images que vous avez pour identifier celle que vous avez construite pour le service web. Accédez au répertoire du projet si vous n'y êtes pas déjà :

cd ~/project

Listez les images Docker :

docker images

Vous devriez voir une image nommée similairement à project-web. Le nom exact peut varier légèrement selon le nom de votre répertoire de projet.

Maintenant, étiquetons l'image project-web pour pouvoir la pousser vers un registre. Nous utiliserons une adresse de registre hypothétique your-registry.example.com. Remplacez your-registry.example.com par l'adresse réelle du registre si vous poussiez vers un vrai registre. Pour cet exercice, nous utiliserons localhost:5000 pour simuler un registre local.

docker tag project-web localhost:5000/my-web-app:latest

Cette commande étiquette l'image project-web avec le nom localhost:5000/my-web-app:latest. localhost:5000 est l'adresse du registre, my-web-app est le nom du dépôt, et latest est l'étiquette (tag).

Vous pouvez vérifier la nouvelle étiquette en listant à nouveau les images :

docker images

Vous devriez maintenant voir l'image project-web listée avec deux étiquettes : l'originale et localhost:5000/my-web-app:latest.

Maintenant, poussons l'image étiquetée vers le registre local simulé.

docker push localhost:5000/my-web-app:latest

Comme nous simulons un registre local qui n'est pas réellement en fonctionnement, cette commande échouera probablement avec une erreur de connexion. Ceci est attendu dans cette étape car nous nous concentrons sur la commande docker push elle-même. Dans l'étape suivante, nous verrons comment gérer de tels échecs.

Dans un scénario réel avec un registre en fonctionnement, cette commande téléverserait les couches de l'image vers le registre.

Pousser les images de service en ignorant les échecs

Dans l'étape précédente, vous avez tenté de pousser votre image personnalisée du service web vers un registre simulé, ce qui a probablement échoué car le registre n'était pas en fonctionnement. Dans certains scénarios, vous pourriez vouloir tenter de pousser plusieurs images et continuer même si l'une des tentatives échoue. Cela peut être utile dans des scripts d'automatisation ou lors du push vers plusieurs registres.

Docker Compose offre un moyen de pousser toutes les images de service définies dans votre fichier docker-compose.yaml. Par défaut, si le push d'une image échoue, toute la commande s'arrête. Cependant, vous pouvez utiliser le drapeau --ignore-pull-failures avec la commande docker compose push. Bien que le nom suggère d'ignorer les échecs de pull, dans le contexte de docker compose push, cela affecte également la gestion des échecs de push selon la version de Compose et le contexte. Une méthode plus directe pour gérer les échecs individuels dans un script consiste à itérer à travers les services et tenter de pousser chacun d'eux, en gérant les erreurs pour chaque push.

Listons d'abord les services définis dans votre fichier docker-compose.yaml. Accédez au répertoire du projet si vous n'y êtes pas déjà :

cd ~/project

Vous pouvez voir les noms des services (web et db) dans votre fichier docker-compose.yaml.

cat docker-compose.yaml

Maintenant, tentons de pousser tous les services définis dans le fichier docker-compose.yaml. Rappelez-vous que le service db utilise l'image postgres:latest de Docker Hub, et que le service web est construit localement et étiqueté pour localhost:5000.

docker compose push

Cette commande tentera de pousser à la fois l'image web (vers localhost:5000) et l'image postgres (vers Docker Hub). Le push vers localhost:5000 échouera probablement comme précédemment. Le push vers Docker Hub pour postgres pourrait réussir si vous avez accès à internet et que l'image n'est pas déjà présente sur le registre cible (bien qu'en pratique vous ne pousseriez pas normalement des images officielles comme postgres vers votre propre registre). La commande signalera probablement un échec dû à l'impossibilité de se connecter à localhost:5000.

Pour démontrer l'ignorance des échecs, considérons un scénario où vous pourriez avoir plusieurs services et souhaiter les pousser indépendamment, en continuant même si l'un échoue. Bien que docker compose push n'ait pas de drapeau direct "ignorer les échecs de push" pour tous les services en une seule fois de la même manière qu'il gère les échecs de pull, vous pouvez obtenir un comportement similaire dans un script en itérant à travers les services et en tentant de pousser chacun d'eux.

Par exemple, vous pourriez écrire un script qui tente de pousser chaque service individuellement et continue en cas d'erreur. Cependant, pour les besoins de ce lab et pour démontrer le concept de gestion des échecs potentiels lors des opérations de push, nous nous concentrerons sur le résultat de la commande docker compose push qui mettra en évidence l'échec lorsque le registre cible est inaccessible.

L'élément clé ici est de comprendre que pousser des images est une étape critique dans le pipeline CI/CD, et que la gestion des échecs potentiels (comme les problèmes réseau ou d'authentification) est importante. Bien que docker compose push puisse s'arrêter au premier échec par défaut, dans des scénarios de script ou plus avancés, vous implémenteriez une logique pour gérer les résultats individuels des push.

Vérifions que la commande docker compose push a bien été exécutée.

grep "docker compose push" ~/.zsh_history

Ceci confirme que vous avez tenté de pousser les images en utilisant Docker Compose. Le résultat de la commande elle-même montrerait l'échec pour le push du service web.

Résumé

Dans ce lab, vous avez appris à préparer un fichier docker-compose.yaml pour définir des applications multi-conteneurs Docker, en configurant spécifiquement des services comme un serveur web (nginx) et une base de données (PostgreSQL) avec leurs images respectives, ports et variables d'environnement. Vous avez ensuite pratiqué la construction de ces images de service basées sur les définitions du fichier docker-compose.yaml.

De plus, vous avez exploré comment pousser ces images de service construites vers un registre Docker en utilisant la commande docker compose push. Vous avez également appris à gérer les échecs potentiels lors du processus de push en utilisant le drapeau --ignore-push-failures, permettant à l'opération de push de continuer même si certaines images échouent à être téléversées.