Présentation

Docker est une plate-forme ouverte permettant de développer, de lancer et d'exécuter des applications dans des conteneurs. Docker vous fait gagner du temps lors des phases de création, de test et de déploiement du code, et raccourcit le cycle entre le développement et l'exécution du code. Pour ce faire, Docker combine des fonctionnalités de conteneurisation de noyau avec des workflows et des outils qui vous aident à gérer et à déployer vos applications.

Docker vous permet d'exprimer le processus de compilation de l'application à l'aide d'un script appelé Dockerfile. Les Dockerfiles offrent une approche de bas niveau qui permet une grande flexibilité, mais qui est complexe. Le Dockerfile est un fichier manifeste qui décrit comment transformer votre code source en image de conteneur.

Les conteneurs Docker peuvent être utilisés directement dans Cloud Run et Kubernetes, ce qui permet de les exécuter facilement sur ces plates-formes. Après avoir découvert les principes de base de Docker, vous disposerez de toutes les compétences requises pour développer des applications conteneurisées.

Objectifs

Dans cet atelier, vous allez apprendre à :

• créer, exécuter et déboguer des conteneurs Docker ;
• transférer des images Docker vers Artifact Registry, le dépôt d'images de conteneurs de Google Cloud ;
• extraire des images Docker à partir d'Artifact Registry.

Préparation

Pour chaque atelier, nous vous attribuons un nouveau projet Google Cloud et un nouvel ensemble de ressources pour une durée déterminée, sans frais.

1. Connectez-vous à Qwiklabs dans une fenêtre de navigation privée.

2. Vérifiez le temps imparti pour l'atelier (par exemple : 01:15:00) : vous devez pouvoir le terminer dans ce délai.
   Une fois l'atelier lancé, vous ne pouvez pas le mettre en pause. Si nécessaire, vous pourrez le redémarrer, mais vous devrez tout reprendre depuis le début.

3. Lorsque vous êtes prêt, cliquez sur Démarrer l'atelier.

4. Notez vos identifiants pour l'atelier (Nom d'utilisateur et Mot de passe). Ils vous serviront à vous connecter à Google Cloud Console.

5. Cliquez sur Ouvrir la console Google.

6. Cliquez sur Utiliser un autre compte, puis copiez-collez les identifiants de cet atelier lorsque vous y êtes invité.
   Si vous utilisez d'autres identifiants, des messages d'erreur s'afficheront ou des frais seront appliqués.

7. Acceptez les conditions d'utilisation et ignorez la page concernant les ressources de récupération des données.

Activer Google Cloud Shell

Google Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud.

Google Cloud Shell vous permet d'accéder à vos ressources Google Cloud grâce à une ligne de commande.

1. Dans la barre d'outils située en haut à droite dans la console Cloud, cliquez sur le bouton "Ouvrir Cloud Shell".

   

2. Cliquez sur Continuer.

Le provisionnement et la connexion à l'environnement prennent quelques instants. Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Par exemple :

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

• Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

Résultat :

Exemple de résultat :

• Vous pouvez lister les ID de projet à l'aide de cette commande :

Résultat :

Exemple de résultat :

Tâche 1. Configurer votre environnement

Dans cet atelier, vous exécutez les commandes shell dans une VM distincte qui a été préprovisionnée pour l'atelier.

1. Pour démarrer une session SSH sur la VM, exécutez la commande suivante dans Cloud Shell :

   gcloud compute ssh lab-vm --zone={{{project_0.default_zone| Zone}}}

2. Lorsque vous y êtes invité, saisissez Y pour continuer.

3. Pour la phrase secrète, appuyez sur Entrée pour n'en utiliser aucune.

4. Appuyez à nouveau sur Entrée.

5. Accordez des autorisations à l'utilisateur "student" sur le socket utilisé par Docker :

   sudo chmod 666 /var/run/docker.sock

6. Pour définir les variables d'environnement pour votre ID de projet et votre région, exécutez les commandes suivantes :

   PROJECT_ID={{{project_0.project_id| Project}}} REGION={{{project_0.default_region| Region}}} Veillez à exécuter toutes les commandes de l'atelier dans la session SSH de Cloud Shell.

Tâche 2 : Créer une image de conteneur

Dans cette tâche, vous allez créer une image de conteneur Docker à l'aide d'un fichier Dockerfile.

Créer un fichier Dockerfile

1. Créez un répertoire de test et modifiez-le comme suit :

   mkdir test && cd test

2. Créez le fichier Dockerfile :

   cat > Dockerfile <<EOF # Use an official Node runtime as the parent image FROM node:lts # Set the working directory in the container to /app WORKDIR /app # Copy the current directory contents into the container at /app COPY . /app # Make the container's port 80 available to the outside world EXPOSE 80 # Run app.js using node when the container launches CMD ["node", "app.js"] EOF Remarque : Dans cette étape, vous assemblez l'image de conteneur en sélectionnant d'abord une image parente ou de base.

   Cela est spécifié avec l'instruction FROM et l'image Docker officielle de la version LTS (support à long terme) du nœud.

   L'instruction WORKDIR définit le répertoire de travail dans le conteneur pour toutes les instructions supplémentaires qui suivent dans le Dockerfile. Pour cet atelier, nous utilisons le répertoire /app comme répertoire de travail du conteneur.

   L'instruction COPY copie des répertoires ou des fichiers de l'emplacement source vers le chemin de destination du système de fichiers de l'image de conteneur. Ici, nous copions les fichiers du répertoire actuel vers /app.

   L'instruction EXPOSE expose le port du conteneur afin qu'il accepte les connexions sur ce port, qui est le port 80 dans cet atelier.

   Enfin, l'instruction CMD fournit la commande Node permettant d'exécuter l'application dans le conteneur en cours d'exécution.

Développer votre application

Ensuite, vous écrivez le code de votre application Node.js. Cette application est un serveur HTTP simple qui écoute les requêtes sur le port 80 et répond avec un message statique.

1. Créez le fichier app.js avec le code source de votre application :

   cat > app.js <<EOF const http = require('http'); const hostname = '0.0.0.0'; const port = 80; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Welcome to your first Docker container!\n'); }); server.listen(port, hostname, () => { console.log('Server running at http://%s:%s/', hostname, port); }); process.on('SIGINT', function() { console.log('Caught interrupt signal and will exit'); process.exit(); }); EOF Remarque : L'application implémente également la fonction de gestionnaire SIGINT pour consigner un message et s'arrêter correctement lorsque le conteneur est arrêté.

2. Vérifiez le contenu du fichier source de l'application :

   cat app.js

Créer l'image de conteneur

Dans cette sous-tâche, vous allez créer l'image de conteneur à partir du Dockerfile à l'aide de la commande docker build.

1. Exécutez la commande docker build :

   docker build -t my-app:0.1 .

   Voici une partie du résultat de la commande :

   => [internal] load dockerignore => => transferring context: 2B => [internal] load build definition from Dockerfile => => transferring dockerfile: 394B => [internal] load metadata for docker.io/library/node:lts => [1/3] FROM docker.io/library/node:lts@sha256:586cdef48f920dea2f47a954b8717601933aa1daa0a08264abf9144789abf8ae => => resolve docker.io/library/node:lts@sha256:586cdef48f920dea2f47a954b8717601933aa1daa0a08264abf9144789abf8ae => => sha256:b7483c70b94e9fbb68e91d64456ee147d120488f876d69efeae815ba164e8b54 2.21kB / 2.21kB ... ... => [internal] load build context => => transferring context: 912B => [2/3] WORKDIR /app => [3/3] COPY . /app => exporting to image => => exporting layers => => writing image sha256:8cf51a1aba351cf505cd6d8eefa966b => => naming to docker.io/library/my-app:0.1 Remarque : Cette commande crée l'image de conteneur à partir des instructions du fichier Dockerfile dans le répertoire actuel et lui attribue le nom et la version spécifiés. Google recommande de spécifier un tag pour distinguer les versions d'image plus récentes des versions plus anciennes.

2. Affichez la liste des images créées :

   docker images REPOSITORY TAG IMAGE ID CREATED SIZE my-app 0.1 8cf51a1aba35 10 minutes ago 997MB Remarque : La commande liste l'image de base node et l'image my-app que vous avez créée. La taille de l'image est relativement petite par rapport aux autres images de machines virtuelles.

   Cliquez sur Vérifier ma progression pour valider l'objectif. Créer une image de conteneur

Tâche 3 : Exécuter et tester l'application

Une fois l'image de conteneur créée, vous pouvez exécuter votre application et la tester pour vous assurer qu'elle se comporte comme prévu.

Exécuter le conteneur

1. Pour exécuter le conteneur, exécutez la commande suivante :

   docker run -p 8080:80 --name my-app -d my-app:0.1 Remarque : La commande docker run démarre le conteneur avec le nom spécifié. L'argument -p mappe le port 8080 de l'hôte au port 80 du conteneur, ce qui permet aux requêtes d'atteindre le serveur à l'adresse http://localhost:8080. L'argument -d exécute le conteneur en arrière-plan.

2. Pour afficher la liste des conteneurs en cours d'exécution, exécutez la commande suivante :

   docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 46c209a1fd87 my-app:0.1 "docker-entrypoint.s…" 19 seconds ago Up 17 seconds 0.0.0.0:8080->80/tcp my-app

Tester l'application

1. Pour tester l'application, envoyez-lui une requête HTTP à l'aide de la commande curl :

   curl http://localhost:8080

2. Vérifiez la réponse de l'application :

   Welcome to your first Docker container!

3. Arrêtez le conteneur en exécutant la commande docker stop :

   docker stop [CONTAINER ID]

   Remplacez [CONTAINER ID] par la valeur de l'ID du conteneur dans le résultat de la commande exécutée lors de la sous-tâche précédente.

Tâche 4 : Modifier le conteneur

Vous pouvez avoir plusieurs versions de vos applications conteneurisées qui partagent des couches communes dans l'image. Dans cette tâche, vous allez créer une autre version de l'application conteneurisée et tester les deux versions.

Modifier le code de l'application

1. Dans le répertoire test, mettez à jour le contenu du fichier app.js :

   cat > app.js <<EOF const http = require('http'); const url = require('url'); const hostname = '0.0.0.0'; const port = 80; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); console.log('Received request with URL: ?%s', req.url); var q = url.parse(req.url, true).query; res.end(q.user + ', Welcome to your first Docker container!\n'); }); server.listen(port, hostname, () => { console.log('Server running at http://%s:%s/', hostname, port); }); process.on('SIGINT', function() { console.log('Caught interrupt signal and will exit'); process.exit(); }); EOF Remarque : Le code d'application modifié ajoute la valeur d'un paramètre de requête user transmis dans la requête HTTP à la réponse de l'application.

2. Vérifiez le contenu du fichier source de l'application modifié à l'aide de la commande cat :

   cat app.js

Recréer l'image de conteneur

1. Recompilez l'image avec un nouveau tag :

   docker build -t my-app:0.2 .

2. Vérifiez le résultat de la commande docker build :

   => [internal] load build definition from Dockerfile => => transferring dockerfile: 394B => [internal] load .dockerignore => => transferring context: 2B => [internal] load metadata for docker.io/library/node:lts => [1/3] FROM docker.io/library/node:lts@sha256:586cdef48f920dea2f47a954b8717601933aa1daa0a08264abf9144789abf8ae => [internal] load build context => => transferring context: 691B => CACHED [2/3] WORKDIR /app => [3/3] COPY . /app => exporting to image => => exporting layers => => writing image sha256:5fc2d7a43c4678da17daf204ef4b071f2da869ead758864622d90d880a40c24b => => naming to docker.io/library/my-app:0.2

   Comme vous pouvez le voir dans le résultat, dans la nouvelle image de conteneur, seules les couches de l'étape 3 et des étapes suivantes sont modifiées, car des changements ont été apportés au fichier source app.js.

Exécuter le nouveau conteneur

1. Pour exécuter le nouveau conteneur, exécutez la commande suivante :

   docker run -p 8080:80 --name my-app-2 -d my-app:0.2

2. Pour afficher la liste des conteneurs en cours d'exécution, exécutez la commande suivante :

   docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 7071749fe0f6 my-app:0.2 "docker-entrypoint.s…" 10 seconds ago Up 10 seconds 0.0.0.0:8081->80/tcp my-app-2

Tester l'application

1. Pour tester l'application, envoyez-lui une requête HTTP à l'aide de curl :

   curl http://localhost:8080?user=Learner

2. Vérifiez la réponse de l'application :

   Learner, Welcome to your first Docker container! Remarque : La réponse contient la valeur de l'argument user qui a été transmis dans la requête au conteneur exécutant la version 0.2 de l'image de l'application.

   Cliquez sur Vérifier ma progression pour valider l'objectif. Modifier le conteneur et recréer l'image du conteneur

Tâche 5 : Dépannage

Il existe des techniques simples pour résoudre les problèmes liés à vos applications conteneurisées. Nous allons passer en revue certaines de ces méthodes dans cette tâche.

Afficher les journaux de conteneur

1. Commencez par récupérer l'ID du conteneur dont vous devez afficher les journaux :

   docker ps

2. Pour afficher les journaux du conteneur, exécutez la commande docker logs :

   docker logs [CONTAINER ID]

   Remplacez l'ID du conteneur par les premiers caractères de l'ID du conteneur qui l'identifient de manière unique dans le résultat de la commande précédente. Pour suivre la sortie du journal au cours de l'exécution du conteneur, utilisez l'option -f avec la commande logs.

   Server running at http://0.0.0.0:80/ Received request with URL: ?/?user=Learner

Démarrer un shell dans le conteneur

Vous pouvez démarrer un shell interactif dans un conteneur en cours d'exécution pour le dépanner.

1. Pour démarrer une session Bash interactive, exécutez la commande suivante :

   docker exec -it [CONTAINER ID] bash root@7071749fe0f6:/app#

2. Dans ce shell, vous pouvez inspecter le système de fichiers du conteneur et les autres fichiers de données que votre application est susceptible d'utiliser pour résoudre les problèmes.

   ls

3. Quittez le shell Bash :

   exit

Examiner les métadonnées du conteneur

1. Pour afficher les métadonnées d'un conteneur, exécutez la commande suivante :

   docker inspect [CONTAINER ID]

   Voici une partie du résultat de la commande :

   [ { "Id": "7071749fe0f66b8b1953bbb6f28f159bd5dbeae079595675e2591d32d87ae5dc", "Created": "2023-02-23T18:08:34.286519913Z", "Path": "docker-entrypoint.sh", "Args": [ "node", "app.js" ], "State": { "Status": "running", "Running": true, "Paused": false, "Restarting": false, "OOMKilled": false, "Dead": false, "Pid": 1099, "ExitCode": 0, "Error": "", "StartedAt": "2023-02-23T18:08:34.785098365Z", "FinishedAt": "0001-01-01T00:00:00Z" }, "Image": "sha256:5fc2d7a43c4678da17daf204ef4b071f2da869ead758864622d90d880a40c24b", "ResolvConfPath": "/var/lib/docker/containers/7071749fe0f66b8b1953bbb6f28f159bd5dbeae079595675e2591d32d87ae5dc/resolv.conf", "HostnamePath": "/var/lib/docker/containers/ ... ... } ] Remarque : Par défaut, la commande inspect fournit des métadonnées détaillées dans un tableau JSON. Vous pouvez filtrer les résultats avec l'argument --format pour inspecter des champs spécifiques dans le résultat.

Tâche 6 : Publier une image de conteneur

Artifact Registry est un service Google Cloud utilisé pour stocker et gérer des artefacts logiciels dans des dépôts privés, y compris des images de conteneurs et des packages logiciels.

Dans cette tâche, vous allez transférer vos images de conteneur vers Artifact Registry pour les rendre disponibles en vue de leur déploiement dans d'autres environnements, tels que les environnements de préproduction et de production, qui constituent le cycle de vie de la livraison de logiciels.

Créer un dépôt d'images

Avant de pouvoir transférer des images de conteneur vers Artifact Registry, vous devez d'abord créer un dépôt.

1. Dans la console Google Cloud, accédez au menu de navigation (), puis cliquez sur Afficher tous les produits. Ensuite, sous les catégories CI/CD, accédez à Artifact Registry > Dépôts.

2. Sur la page Créer un dépôt, fournissez les informations suivantes et conservez les valeurs par défaut pour les autres paramètres :

   Propriété	Valeur (à saisir ou sélectionner)
   Nom	my-repo
   Format	Docker
   Type d'emplacement	Région
   Région

3. Cliquez sur Créer.

Authentifier Docker pour utiliser le dépôt

Avant de pouvoir transférer des images vers le dépôt ou en extraire, vous devez configurer Docker afin d'authentifier les requêtes envoyées au dépôt dans Artifact Registry.

1. Pour configurer l'authentification auprès des dépôts Docker dans la région , exécutez la commande suivante dans le shell de la VM :

   gcloud auth configure-docker ${REGION}-docker.pkg.dev

2. Lorsque vous y êtes invité, saisissez Y.

   Le nom complet du dépôt que vous avez créé est le suivant : -docker.pkg.dev//my-repo.

   Les noms des dépôts d'images Docker utilisent le format [location]-docker.pkg.dev dans Artifact Registry.

Transférer le conteneur vers Artifact Registry

1. Pour transférer une image de conteneur vers votre registre privé hébergé par Artifact Registry, vous devez d'abord lui ajouter un tag correspondant au nom du dépôt :

   docker build -t ${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repo/my-app:0.2 .

2. Affichez la liste des images Docker que vous avez créées :

   docker images REPOSITORY TAG IMAGE ID CREATED SIZE my-app 0.2 9b1ef4854d32 4 minutes ago 997MB us-east1-docker.pkg.dev/qwiklabs-gcp-02-7c092125ce3a/my-repo/my-app 0.2 9b1ef4854d32 4 minutes ago 997MB my-app 0.1 8cf51a1aba35 5 minutes ago 997MB

3. Pour transférer l'image vers Artifact Registry, exécutez la commande suivante :

   docker push ${REGION}-docker.pkg.dev/$PROJECT_ID/my-repo/my-app:0.2

   Le résultat de cette commande ressemble à ceci :

   The push refers to repository [east1-docker.pkg.dev/qwiklabs-gcp-02-7c092125ce3a/my-repo/my-app] b29bce04ddbb: Pushed 9ba0e19073ee: Pushed 3c397285cb7e: Pushed a8d01c684adc: Pushed 56c4ec92f013: Pushed 4c92897e605e: Pushed 0b6859e9fff1: Pushed 11829b3be9c0: Pushed dc8e1d8b53e9: Pushed 9d49e0bc68a4: Pushed 8e396a1aad50: Pushed 0.2: digest: sha256:383ffb5213f92e33dedb49042c0f070a9f76f263621226de20499dffd863b3df size: 2628

4. Une fois la commande exécutée, dans la console Google Cloud, accédez au menu de navigation (), puis cliquez sur Afficher tous les produits. Ensuite, sous les catégories CI/CD, accédez à Artifact Registry > Dépôts.

5. Cliquez sur le dépôt my-repo pour afficher l'image de conteneur Docker my-app.

Cliquez sur Vérifier ma progression pour valider l'objectif. Publier une image de conteneur

Tâche 7 : Extraire et tester l'image de conteneur

Dans cette tâche, vous allez commencer par créer un environnement vierge, puis extraire l'image de conteneur d'Artifact Registry pour la tester. Pour simuler un autre environnement, vous allez arrêter et supprimer de votre environnement shell tous les conteneurs et toutes les images créés dans les tâches précédentes de cet atelier.

Arrêter et supprimer des conteneurs

1. Pour arrêter tous les conteneurs en cours d'exécution, exécutez la commande suivante :

   docker stop $(docker ps -q)

2. Pour supprimer tous les conteneurs, exécutez la commande suivante :

   docker rm $(docker ps -aq)

Supprimer toutes les images de conteneur

1. Pour supprimer l'image de conteneur taguée dans le registre, exécutez la commande suivante :

   docker rmi ${REGION}-docker.pkg.dev/$PROJECT_ID/my-repo/my-app:0.2 Remarque : Cette commande ne supprime pas l'image de conteneur du registre.

2. Pour supprimer toutes les autres images, exécutez la commande suivante :

   docker rmi -f $(docker images -aq)

3. Vérifiez qu'aucune image de conteneur n'existe dans votre environnement de VM :

   docker images REPOSITORY TAG IMAGE ID CREATED SIZE

   Vous devriez maintenant disposer d'un environnement hôte vierge, sans aucune image locale.

Tester l'image

Testez l'image en l'extrayant d'Artifact Registry.

1. Pour extraire l'image d'Artifact Registry, exécutez la commande suivante :

   docker pull ${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repo/my-app:0.2

2. Pour lister l'image, exécutez la commande suivante :

   docker images

3. Pour exécuter le conteneur, exécutez la commande suivante :

   docker run -p 8080:80 -d ${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repo/my-app:0.2

4. Pour tester l'application, exécutez la commande suivante :

   curl http://localhost:8080?user=Learner Remarque : Cette tâche illustre la portabilité des conteneurs, qui vous permet d'exécuter des applications conteneurisées sur d'autres VM ou environnements avec Docker, sans avoir à installer de dépendances d'application sur la machine hôte. Les images de conteneurs peuvent être hébergées sur des registres publics ou privés auxquels Docker doit pouvoir accéder.

Félicitations !

Félicitations ! Vous avez terminé cet atelier sur les principes de base de la création de conteneurs avec Docker. Au cours de cet atelier, vous avez :

• créé des images de conteneurs avec Docker et exécuté des conteneurs Docker ;
• transféré des images Docker vers Artifact Registry, le dépôt d'images de conteneurs de Google Cloud ;
• extrait des images Docker d'Artifact Registry et les avez exécutées dans un environnement vierge pour vérifier la portabilité des conteneurs.

Étapes suivantes et informations supplémentaires

Pour en savoir plus sur Docker et Artifact Registry, consultez la documentation :

• Documentation Docker
• Documentation de référence sur les commandes Docker
• Artifact Registry

Copyright 2026 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms de société et de produit peuvent être des marques des sociétés auxquelles ils sont associés.