GSP055

Aperçu

Docker est une plate-forme ouverte permettant de développer, de lancer et d'exécuter des applications. Avec cette solution, vous pouvez séparer les applications de votre infrastructure et traiter cette dernière comme une application gérée. Docker vous fait gagner du temps lors des phases de lancement, de test et de déploiement du code, et raccourcit le cycle entre la rédaction 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.

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

Objectifs

Dans cet atelier, vous allez apprendre à :

• créer, exécuter et déboguer des conteneurs Docker ;
• extraire des images Docker à partir de Docker Hub et Google Artifact Registry ;
• transférer des images Docker vers Google Artifact Registry.

Prérequis

Cet atelier s'adresse aux débutants. Il ne nécessite aucune connaissance particulière de Docker ni des conteneurs. Une connaissance préalable de Cloud Shell et de la ligne de commande est recommandée, mais pas indispensable.

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;

Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google. L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue Se connecter. Cliquez sur Suivant.

4. Copiez le mot de passe inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue de bienvenue. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis dans le panneau de gauche. Ne saisissez pas vos identifiants Google Cloud Skills Boost. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

5. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas aux essais offerts.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Vous pouvez afficher le menu qui contient la liste des produits et services Google Cloud en cliquant sur le menu de navigation en haut à gauche.

Activer Cloud Shell

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. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Le résultat contient une ligne qui déclare YOUR_PROJECT_ID (VOTRE_ID_PROJET) pour cette session :

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

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.

2. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

3. Cliquez sur Autoriser.

4. Vous devez à présent obtenir le résultat suivant :

Résultat :

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = <ID_Projet>

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6 Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Tâche 1 : Hello World

1. Pour commencer, saisissez la commande suivante dans Cloud Shell pour exécuter un conteneur Hello World :

docker run hello-world

(Résultat de la commande)

Unable to find image 'hello-world:latest' locally latest: Pulling from library/hello-world 9db2ca6ccae0: Pull complete Digest: sha256:4b8ff392a12ed9ea17784bd3c9a8b1fa3299cac44aca35a85c90c5e3c7afacdc Status: Downloaded newer image for hello-world:latest Hello from Docker! This message shows that your installation appears to be working correctly. ...

Ce conteneur simple affiche Hello from Docker! sur votre écran. La commande en elle-même est assez simple, mais vous pouvez constater dans le résultat le nombre conséquent d'étapes effectuées. Le daemon Docker a recherché l'image "hello-world", ne l'a pas trouvée en local, l'a extraite d'un registre public appelé Docker Hub, a créé un conteneur à partir de cette image et a exécuté ce conteneur.

2. Exécutez la commande suivante pour examiner l'image de conteneur extraite de Docker Hub :

docker images

(Résultat de la commande)

REPOSITORY TAG IMAGE ID CREATED SIZE hello-world latest feb5d9fea6a5 14 months ago 13.3kB

Il s'agit de l'image extraite du registre public Docker Hub. L'ID de l'image se présente sous la forme d'un hachage SHA256 qui identifie l'image Docker provisionnée. Par défaut, le daemon Docker recherche une image dans le registre public lorsqu'il ne la trouve pas en local.

3. Exécutez le conteneur à nouveau :

docker run hello-world

(Résultat de la commande)

Hello from Docker! This message shows that your installation appears to be working correctly. To generate this message, Docker took the following steps: ...

Notez que lorsque vous exécutez à nouveau la commande, le daemon Docker trouve l'image dans votre registre local et exécute le conteneur à partir de cette image. Il n'a pas besoin d'extraire l'image de Docker Hub.

4. Pour finir, utilisez la commande suivante afin d'examiner les conteneurs en cours d'exécution :

docker ps

(Résultat de la commande)

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

Aucun conteneur n'est en cours d'exécution. Vous avez déjà quitté les conteneurs hello-world que vous avez précédemment exécutés.

5. Pour voir tous les conteneurs, y compris ceux dont l'exécution est terminée, lancez la commande docker ps -a :

docker ps -a

(Résultat de la commande)

CONTAINER ID IMAGE COMMAND ... NAMES 6027ecba1c39 hello-world "/hello" ... elated_knuth 358d709b8341 hello-world "/hello" ... epic_lewin

Vous obtenez l'ID du conteneur (Container ID), un UUID généré par Docker pour identifier le conteneur, ainsi que d'autres métadonnées relatives à l'exécution. Les noms de conteneur (Names) sont également générés de manière aléatoire, mais peuvent être définis grâce à la commande docker run --name [nom-conteneur] hello-world.

Tâche 2 : Créer

Dans cette section, vous allez créer une image Docker basée sur une application de nœud simple.

1. Exécutez la commande suivante pour créer un dossier nommé test et basculer dans ce dossier.

mkdir test && cd test

2. Créez un 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 ADD . /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

Ce fichier indique au daemon Docker comment créer votre image.

• La première ligne indique l'image parent de base, qui correspond ici à l'image Docker officielle de la version LTS (support à long terme) du nœud.
• Dans la deuxième ligne, vous devez définir le répertoire de travail (actuel) du conteneur.
• Dans la troisième ligne, vous ajoutez le contenu du répertoire actuel (indiqué par le ".") dans le conteneur.
• Vous indiquez ensuite le port du conteneur afin d'autoriser les connexions sur ce port, puis terminez en exécutant la commande "node" pour démarrer l'application.

Remarque : Prenez le temps de consulter la documentation de référence sur les commandes Dockerfile pour comprendre chaque ligne de ce fichier Dockerfile.

Vous allez maintenant rédiger le code de l'application du nœud, puis créer l'image.

3. Exécutez la commande suivante pour créer l'application du nœud :

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("Hello World\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

Il s'agit d'un serveur HTTP simple qui écoute le port 80 et renvoie "Hello World".

Maintenant, créez l'image.

4. Vous pouvez remarquer là encore la présence du ".", qui désigne le répertoire actuel. Vous devez donc exécuter cette commande depuis le répertoire qui contient le fichier Dockerfile :

docker build -t node-app:0.1 .

L'exécution de cette commande peut prendre quelques minutes. Une fois terminée, le résultat doit se présenter comme suit :

+] Building 0.7s (8/8) FINISHED docker:default => [internal] load .dockerignore 0.0s => => transferring context: 2B 0.0s => [internal] load build definition from Dockerfile 0.0s => => transferring dockerfile: 397B 0.0s => [internal] load metadata for docker.io/library/node:lts

L'option -t permet de nommer une image et de lui ajouter un tag par le biais de la syntaxe nom:tag. Ici, le nom de l'image est node-app et le tag 0.1. L'utilisation d'un tag est vivement recommandée lors de la création d'images Docker. Si vous ne définissez pas de tag, la valeur latest sera attribuée par défaut aux images et il sera plus difficile de distinguer les images plus récentes des images plus anciennes. Notez également comment, pour chaque ligne du Dockerfile ci-dessus, des couches de conteneur intermédiaires sont ajoutées au fur et à mesure que l'image se crée.

5. À présent, exécutez la commande suivante pour examiner les images que vous avez créées :

docker images

Le résultat doit se présenter comme suit :

REPOSITORY TAG IMAGE ID CREATED SIZE node-app 0.1 f166cd2a9f10 25 seconds ago 656.2 MB node lts 5a767079e3df 15 hours ago 656.2 MB hello-world latest 1815c82652c0 6 days ago 1.84 kB

Notez que node désigne l'image de base et que node-app désigne l'image que vous avez créée. Vous ne pouvez pas supprimer node sans d'abord supprimer node-app. La taille de l'image est relativement petite par rapport aux VM. D'autres versions de l'image du nœud telles que node:slim et node:alpine peuvent vous donner des images encore plus petites pour une meilleure portabilité. La réduction de la taille des conteneurs est abordée plus en détail dans la section "Sujets avancés". Toutes les versions du dépôt officiel sont précisées sur la page node.

Tâche 3 : Exécuter

1. Utilisez ce code pour exécuter des conteneurs basés sur l'image que vous avez créée :

docker run -p 4000:80 --name my-app node-app:0.1

(Résultat de la commande)

Server running at http://0.0.0.0:80/

L'option --name vous permet de nommer le conteneur si vous le souhaitez. L'option -p demande à Docker de faire correspondre le port 4000 de l'hôte avec le port 80 du conteneur. Vous pouvez à présent accéder au serveur via l'adresse http://localhost:4000. Sans mise en correspondance des ports, vous ne pourrez pas accéder au conteneur sur "localhost".

2. Ouvrez un autre terminal (dans Cloud Shell, cliquez sur l'icône +), puis testez le serveur :

curl http://localhost:4000

(Résultat de la commande)

Hello World

Le conteneur s'exécute à condition que le terminal initial soit en cours d'exécution. Si vous souhaitez que le conteneur s'exécute en arrière-plan (sans être associé à la session du terminal), vous devez définir l'option -d.

3. Fermez le terminal initial, puis exécutez la commande suivante pour arrêter l'exécution du conteneur et le supprimer :

docker stop my-app && docker rm my-app

4. À présent, exécutez la commande ci-dessous pour lancer le conteneur en arrière-plan :

docker run -p 4000:80 --name my-app -d node-app:0.1 docker ps

(Résultat de la commande)

CONTAINER ID IMAGE COMMAND CREATED ... NAMES xxxxxxxxxxxx node-app:0.1 "node app.js" 16 seconds ago ... my-app

5. Notez que le résultat de la commande docker ps indique que le conteneur est en cours d'exécution. Pour consulter les journaux, exécutez la commande docker logs [id_conteneur].

Remarque : Il est inutile d'indiquer l'intégralité de l'ID du conteneur si les premiers caractères l'identifient de manière unique. Par exemple, vous pouvez exécuter docker logs 17b si l'ID du conteneur est 17bcaca6f.... docker logs [id_conteneur]

(Résultat de la commande)

Server running at http://0.0.0.0:80/

Maintenant, modifiez l'application.

1. Dans votre session Cloud Shell, ouvrez le répertoire de test que vous avez créé un peu plus tôt :

cd test

2. Dans l'éditeur de texte de votre choix (par exemple, nano ou vim), modifiez app.js en remplaçant "Hello World" par une autre chaîne :

.... const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Welcome to Cloud\n'); }); ....

3. Créez cette image, puis ajoutez-lui le tag 0.2 :

docker build -t node-app:0.2 .

(Résultat de la commande)

[+] Building 0.7s (8/8) FINISHED docker:default => [internal] load .dockerignore 0.0s => => transferring context: 2B 0.0s => [internal] load build definition from Dockerfile 0.0s => => transferring dockerfile: 397B 0.0s => [internal] load metadata for docker.io/library/node:lts 0.5s

Notez qu'à l'étape 2, vous utilisez une couche de cache existante. À partir de l'étape 3, les couches sont modifiées, car vous avez effectué un changement dans app.js.

4. Exécutez un autre conteneur avec la nouvelle version de l'image. Comme vous pouvez le constater, nous effectuons le mappage sur le port 8080 de l'hôte plutôt que sur le port 80. Vous ne pouvez pas vous servir du port 4000 de l'hôte, car il est déjà utilisé.

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

(Résultat de la commande)

CONTAINER ID IMAGE COMMAND CREATED xxxxxxxxxxxx node-app:0.2 "node app.js" 53 seconds ago ... xxxxxxxxxxxx node-app:0.1 "node app.js" About an hour ago ...

5. Testez les conteneurs :

curl http://localhost:8080

(Résultat de la commande)

Welcome to Cloud

6. Testez à présent le premier conteneur que vous avez créé :

curl http://localhost:4000

(Résultat de la commande)

Hello World

Tâche 4 : Déboguer

Maintenant que vous savez créer et exécuter des conteneurs, découvrez comment effectuer un débogage.

1. Pour consulter les journaux d'un conteneur, exécutez la commande docker logs [id_conteneur]. Pour suivre la sortie du journal au cours de l'exécution du conteneur, utilisez l'option -f.

docker logs -f [id_conteneur]

(Résultat de la commande)

Server running at http://0.0.0.0:80/

Vous pouvez parfois avoir besoin de démarrer une session bash interactive dans le conteneur en cours d'exécution.

2. Pour ce faire, vous pouvez utiliser docker exec. Ouvrez un autre terminal (dans Cloud Shell, cliquez sur l'icône +), puis saisissez la commande suivante :

docker exec -it [id_conteneur] bash

Avec l'option -it, vous pouvez interagir avec un conteneur en attribuant un "pseudo-tty" et en gardant "stdin" ouvert. Comme vous pouvez le constater, bash a été exécuté dans le répertoire WORKDIR (/app) indiqué dans le fichier Dockerfile. Vous disposez maintenant d'une session de shell interactive dans le conteneur à déboguer.

(Résultat de la commande)

root@xxxxxxxxxxxx:/app#

3. Examinez le répertoire :

ls

(Résultat de la commande)

Dockerfile app.js

4. Quittez la session bash :

exit

5. Vous pouvez examiner les métadonnées d'un conteneur dans Docker à l'aide de la commande "docker inspect" :

docker inspect [id_conteneur]

(Résultat de la commande)

[ { "Id": "xxxxxxxxxxxx....", "Created": "2017-08-07T22:57:49.261726726Z", "Path": "node", "Args": [ "app.js" ], ...

6. Utilisez --format pour examiner des champs spécifiques du JSON affiché. Exemple :

docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' [id_conteneur]

(Exemple de résultat)

192.168.9.3

Consultez les documentations Docker suivantes pour en savoir plus sur le débogage :

• Documentation de référence sur "docker inspect"
• Documentation de référence sur "docker exec"

Tâche 5 : Publier

Vous allez à présent transférer votre image vers Google Artifact Registry. Vous supprimerez ensuite l'ensemble des conteneurs et des images pour simuler un nouvel environnement, puis vous extrairez et exécuterez vos conteneurs. Vous pourrez ainsi constater la portabilité des conteneurs Docker.

Pour transférer des images vers votre registre privé hébergé par Artifact Registry, vous devez leur ajouter un tag correspondant au nom du registre. Le format est <dépôt-régional>-docker.pkg.dev/mon-projet/mon-dépôt/mon-image.

Créer le dépôt Docker cible (à l'aide de la console Cloud)

Vous devez créer un dépôt pour pouvoir y transférer des images. Le transfert d'une image ne peut pas déclencher la création d'un dépôt et le compte de service Cloud Build ne dispose pas des autorisations nécessaires pour créer des dépôts.

1. Dans le menu de navigation, sous "CI/CD", accédez à Artifact Registry > Dépôts.

2. Cliquez sur l'icône + CRÉER DÉPÔT à côté des dépôts.

3. Indiquez my-repository comme nom de dépôt.

4. Sélectionnez Docker comme format.

5. Sous "Type d'emplacement", sélectionnez Région, puis l'emplacement : .

6. Cliquez sur Créer.

Configurer l'authentification

Avant de pouvoir transférer ou extraire des images, vous devez configurer Docker afin qu'il se serve de la Google Cloud CLI pour authentifier les requêtes envoyées à Artifact Registry.

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

gcloud auth configure-docker {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev

2. Saisissez Y quand vous y êtes invité.

La commande met à jour votre configuration Docker. Vous pouvez désormais vous connecter à Artifact Registry dans votre projet Google Cloud pour transférer et extraire des images.

Remarque : Vous pouvez également utiliser la gcloud CLI pour une approche de ligne de commande simplifiée.

Créer un dépôt Artifact Registry (à l'aide de la CLI)

1. Exécutez les commandes suivantes pour créer un dépôt Artifact Registry.

gcloud artifacts repositories create my-repository --repository-format=docker --location={{{ project_0.default_region | "REGION" }}} --description="Docker repository" Remarque : Lorsque vous effectuez un appel d'API Google Cloud ou utilisez un outil de ligne de commande nécessitant des identifiants (gcloud CLI, bq ou gsutil, par exemple) avec Cloud Shell pour la première fois, Cloud Shell affiche la boîte de dialogue Autoriser Cloud Shell. Pour autoriser l'outil à utiliser vos identifiants afin d'effectuer des appels, cliquez sur Autoriser.

Transférer le conteneur vers Artifact Registry

1. Accédez au répertoire avec le Dockerfile.

cd ~/test

2. Exécutez la commande suivante pour ajouter le tag node-app:0.2.

docker build -t {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id | "PROJECT_ID" }}}/my-repository/node-app:0.2 .

3. Exécutez la commande suivante pour vérifier les images Docker créées.

docker images

(Résultat de la commande)

REPOSITORY TAG IMAGE ID CREATED node-app 0.2 76b3beef845e 22 hours {{{project_0.default_region | "REGION"}}}-....node-app:0.2 0.2 76b3beef845e 22 hours node-app 0.1 f166cd2a9f10 26 hours node lts 5a767079e3df 7 days hello-world latest 1815c82652c0 7 weeks

4. Transférez l'image vers Artifact Registry.

docker push {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id | "PROJECT_ID" }}}/my-repository/node-app:0.2

Résultat de la commande (celui que vous obtiendrez sera peut-être différent) :

The push refers to a repository [{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/{{{project_0.project_id | "PROJECT_ID"}}}/my-repository/node-app:0.2] 057029400a4a: Pushed 342f14cb7e2b: Pushed 903087566d45: Pushed 99dac0782a63: Pushed e6695624484e: Pushed da59b99bbd3b: Pushed 5616a6292c16: Pushed f3ed6cb59ab0: Pushed 654f45ecb7e3: Pushed 2c40c66f7667: Pushed 0.2: digest: sha256:25b8ebd7820515609517ec38dbca9086e1abef3750c0d2aff7f341407c743c46 size: 2419

5. Une fois le transfert terminé, dans le menu de navigation, sous "CI/CD", accédez à Artifact Registry > Dépôts.

6. Cliquez sur my-repository. Le conteneur Docker node-app créé devrait s'afficher :

Tester l'image

Vous pourriez démarrer une nouvelle VM, vous connecter en SSH à cette VM et installer gcloud. Pour plus de simplicité, vous allez juste supprimer l'ensemble des conteneurs et des images pour simuler un nouvel environnement.

1. Arrêtez et supprimez tous les conteneurs :

docker stop $(docker ps -q) docker rm $(docker ps -aq)

Vous devez supprimer les images enfants (de node:lts) avant de supprimer l'image du nœud.

2. Exécutez la commande suivante pour supprimer toutes les images Docker.

docker rmi {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id| "PROJECT_ID" }}}/my-repository/node-app:0.2 docker rmi node:lts docker rmi -f $(docker images -aq) # remove remaining images docker images

(Résultat de la commande)

REPOSITORY TAG IMAGE ID CREATED SIZE

À ce stade, vous devriez disposer d'un pseudo-nouvel environnement.

3. Extrayez l'image, puis exécutez-la.

docker run -p 4000:80 -d {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id| "PROJECT_ID" }}}/my-repository/node-app:0.2

4. Exécutez une commande curl sur le conteneur en cours d'exécution.

curl http://localhost:4000

(Résultat de la commande)

Welcome to Cloud

Tester la tâche terminée

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si l'image de conteneur a bien été publiée vers Artifact Registry, une note d'évaluation apparaît.

Publier l'image de conteneur vers Artifact Registry

La portabilité des conteneurs est mise en avant ici. Tant que Docker est installé sur l'hôte (sur site ou sur une VM), il peut extraire des images de registres publics ou privés et exécuter des conteneurs basés sur une de ces images. Il n'est nécessaire d'installer aucune dépendance d'application sur l'hôte, sauf pour Docker.

Félicitations !

Félicitations ! Au cours de cet atelier, vous avez réalisé plusieurs activités pratiques comme exécuter des conteneurs basés sur des images publiques à partir de Docker Hub. Vous avez également créé vos propres images de conteneurs, que vous avez transférées vers Google Artifact Registry. Cet atelier vous a aussi doté des compétences nécessaires pour déboguer efficacement des conteneurs en cours d'exécution. Enfin, vous vous êtes familiarisé avec l'exécution de conteneurs basés sur des images extraites de Google Artifact Registry, ce qui vous a permis d'améliorer vos connaissances et vos compétences sur Docker.

Étapes suivantes et informations supplémentaires

• Documentation de référence sur Dockerfile
• Docker Hub
• En savoir plus sur Docker grâce à la documentation officielle
• Documentation Artifact Registry

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 29 février 2024

Dernier test de l'atelier : 29 février 2024

Copyright 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.