GSP005

Présentation

L'objectif de cet atelier pratique est de transformer du code que vous avez développé en une application répliquée, exécutée sur Kubernetes via le service Kubernetes Engine. Pour cet atelier, le code sera une simple application node.js Hello World.

Voici un schéma des différents éléments impliqués dans cet atelier afin de vous aider à comprendre comment ils interagissent. Vous utiliserez ce schéma comme référence au fur et à mesure de votre progression. Il prendra tout son sens à la fin de l'atelier. Pour l'instant, vous pouvez le laisser de côté.

Kubernetes est un projet Open Source (disponible sur kubernetes.io) qui peut s'exécuter sur de nombreux environnements différents : ordinateurs portables, clusters multinœuds haute disponibilité, clouds publics, déploiements sur site, machines virtuelles ou solutions Bare Metal.

Pour cet atelier, l'utilisation d'un environnement géré comme Kubernetes Engine (une version de Kubernetes hébergée par Google et exécutée sur Compute Engine) vous permet de vous consacrer à la découverte de Kubernetes plutôt que d'avoir à configurer l'infrastructure sous-jacente.

Points abordés

• Créer un serveur Node.js
• Créer une image de conteneur Docker
• Créer un cluster de conteneurs
• Créer un pod Kubernetes
• Effectuer un scaling à la hausse de vos services

Prérequis

• Une bonne connaissance des éditeurs de texte Linux standards tels que vim, emacs ou nano vous sera utile.

Nous vous invitons à saisir vous-même les commandes, afin de mieux assimiler les concepts fondamentaux. Notez que de nombreux ateliers comportent un bloc de code qui contient les commandes à saisir. Vous pouvez les copier et les coller directement dans les emplacements adéquats au cours des ateliers si vous le souhaitez.

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 les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Des identifiants temporaires vous sont fournis pour vous permettre de 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 (recommandé) ou de navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le compte temporaire de participant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

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

Remarque : Utilisez uniquement le compte de participant pour cet atelier. Si vous utilisez un autre compte Google Cloud, des frais peuvent être facturés à ce compte.

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, une boîte de dialogue 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 Cloud"
   • 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 Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).

   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 ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau "Détails concernant l'atelier".

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau "Détails concernant l'atelier".

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

7. 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 à des essais sans frais.

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

Remarque : Pour accéder aux produits et services Google Cloud, cliquez sur le menu de navigation ou saisissez le nom du service ou du produit dans le champ Recherche.

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.

2. Passez les fenêtres suivantes :

   • Accédez à la fenêtre d'informations de Cloud Shell.
   • Autorisez Cloud Shell à utiliser vos identifiants pour effectuer des appels d'API 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 l'ID_PROJET pour cette session :

Your Cloud Platform project in this session is set to {{{project_0.project_id | "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.

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

gcloud auth list

4. Cliquez sur Autoriser.

Résultat :

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} 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 = {{{project_0.project_id | "PROJECT_ID"}}} 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 : Créer votre application Node.js

1. À l'aide de Cloud Shell, créez un serveur Node.js simple que vous allez déployer sur Kubernetes Engine :

vi server.js

2. Lancez l'éditeur :

i

3. Ajoutez le contenu suivant au fichier :

var http = require('http'); var handleRequest = function(request, response) { response.writeHead(200); response.end("Hello World!"); } var www = http.createServer(handleRequest); www.listen(8080); Remarque : Nous utilisons vi dans cet exemple, mais nano et emacs sont également disponibles dans Cloud Shell. Vous pouvez aussi utiliser la fonctionnalité d'éditeur Web de Cloud Shell, comme indiqué dans le guide de fonctionnement de Cloud Shell.

4. Enregistrez le fichier server.js en appuyant sur Échap, puis saisissez :

:wq

5. L'exécutable node étant installé sur Cloud Shell, vous pouvez exécuter la commande suivante (qui ne renvoie aucun résultat) pour démarrer le serveur de nœud :

node server.js

6. Utilisez la fonctionnalité d'aperçu sur le Web intégrée à Cloud Shell pour ouvrir un nouvel onglet dans le navigateur afin de transmettre une requête à l'instance que vous venez de démarrer sur le port 8080.

Un nouvel onglet de navigateur contenant les résultats s'ouvre :

7. Avant de continuer, retournez dans Cloud Shell et appuyez sur CTRL+C pour arrêter le serveur de nœud en cours d'exécution.

Vous allez ensuite créer un package de cette application sous forme de conteneur Docker.

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

1. Vous allez maintenant créer un Dockerfile qui décrit l'image que vous voulez générer. Les images de conteneurs Docker peuvent être basées sur des images existantes. Pour cette image, nous partirons donc d'une image de nœud existante :

vi Dockerfile

2. Lancez l'éditeur :

i

3. Ajoutez le contenu suivant :

FROM node:6.9.2 EXPOSE 8080 COPY server.js . CMD ["node", "server.js"]

Cette "recette" pour l'image Docker :

• se basera sur l'image node trouvée sur Docker Hub ;
• exposera le port 8080 ;
• copiera votre fichier server.js dans l'image ;
• démarrera le serveur de nœud comme nous l'avons précédemment fait manuellement.

4. Enregistrez ce fichier Dockerfile en appuyant sur Échap, puis saisissez :

:wq

5. Créez l'image à l'aide de la commande suivante :

docker build -t hello-node:v1 .

Le téléchargement et l'extraction de tous les éléments peuvent prendre un peu de temps, mais des barres de progression vous indiquent l'état d'avancement de la création de l'image.

Une fois la création terminée, testez l'image en local en exécutant un conteneur Docker en tant que daemon sur le port 8080 en vous servant de l'image de conteneur que vous venez de créer.

6. Exécutez le conteneur Docker à l'aide de cette commande :

docker run -d -p 8080:8080 hello-node:v1

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

325301e6b2bffd1d0049c621866831316d653c0b25a496d04ce0ec6854cb7998

7. Pour afficher vos résultats, utilisez la fonctionnalité d'aperçu sur le Web de Cloud Shell. Vous pouvez également utiliser la commande curl depuis votre invite Cloud Shell :

curl http://localhost:8080

Voici le résultat que vous devez obtenir :

Hello World! Remarque : Vous retrouverez la documentation complète de la commande docker run dans la documentation de référence sur l'exécution de Docker.

Ensuite, arrêtez le conteneur en cours d'exécution.

1. Recherchez l'ID du conteneur Docker en exécutant cette commande :

docker ps

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

CONTAINER ID IMAGE COMMAND 2c66d0efcbd4 hello-node:v1 "/bin/sh -c 'node

2. Arrêtez le conteneur en exécutant la commande suivante, en remplaçant [CONTAINER ID] par la valeur fournie à l'étape précédente :

docker stop [CONTAINER ID]

Le résultat de la console doit se présenter comme suit (votre ID de conteneur) :

2c66d0efcbd4

Maintenant que l'image fonctionne comme prévu, transférez-la vers Google Artifact Registry, un dépôt privé pour vos images Docker accessible à partir de vos projets Google Cloud.

1. Vous devez d'abord créer un dépôt dans Artifact Registry. Appelons-le my-docker-repo. Exécutez la commande suivante :

gcloud artifacts repositories create my-docker-repo \ --repository-format=docker \ --location={{{ project_0.default_region | YOUR_REGION }}} \ --project={{{ project_0.project_id | YOUR_PROJECT_ID }}}

2. Exécutez maintenant la commande suivante pour configurer l'authentification Docker :

gcloud auth configure-docker

Lorsque l'invite "Do you want to continue (Y/n)?" (Voulez-vous continuer (Oui/Non) ?) apparaît, saisissez Y (Oui).

3. Pour taguer votre image avec le nom du dépôt, exécutez la commande suivante en remplaçant PROJECT_ID par l'ID de votre projet, que vous trouverez dans la console et dans la section Détails concernant l'atelier :

docker tag hello-node:v1 {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v1

4. Transmettez ensuite votre image de conteneur au dépôt en exécutant la commande suivante :

docker push {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v1

Le transfert initial peut prendre quelques minutes. Des barres de progression s'affichent pendant la création.

The push refers to a repository [pkg.dev/qwiklabs-gcp-6h281a111f098/hello-node] ba6ca48af64e: Pushed 381c97ba7dc3: Pushed 604c78617f34: Pushed fa18e5ffd316: Pushed 0a5e2b2ddeaa: Pushed 53c779688d06: Pushed 60a0858edcd5: Pushed b6ca02dfe5e6: Pushed v1: digest: sha256:8a9349a355c8e06a48a1e8906652b9259bba6d594097f115060acca8e3e941a2 size: 2002

3. L'image de conteneur est répertoriée dans votre console. Cliquez sur le menu de navigation > Artifact Registry.

Vous disposez maintenant d'une image Docker disponible au niveau du projet, que Kubernetes peut consulter et orchestrer.

Remarque : Nous avons utilisé la méthode recommandée pour travailler avec Artifact Registry, qui spécifie la région à utiliser. Pour en savoir plus, consultez la page Transférer et extraire des images depuis Artifact Registry.

Tâche 3 : Créer votre cluster

Vous pouvez désormais créer votre cluster Kubernetes Engine. Un cluster se compose d'un serveur d'API maître Kubernetes hébergé par Google et d'un ensemble de nœuds de calcul. Les nœuds de calcul sont des machines virtuelles Compute Engine.

1. Assurez-vous d'avoir configuré votre projet à l'aide de gcloud (remplacez PROJECT_ID par l'ID de votre projet, que vous trouverez dans la console et dans la section Détails concernant l'atelier de l'atelier) :

gcloud config set project PROJECT_ID

2. Créez un cluster avec deux nœuds e2-medium (cette opération prend quelques minutes) :

gcloud container clusters create hello-world \ --num-nodes 2 \ --machine-type e2-medium \ --zone "{{{project_0.default_zone|ZONE}}}"

Vous pouvez ignorer les avertissements qui s'affichent lors de la création du cluster.

Le résultat de la console doit se présenter comme suit :

Creating cluster hello-world...done. Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/"{{{project_0.default_zone|ZONE}}}"/clusters/hello-world]. kubeconfig entry generated for hello-world. NAME ZONE MASTER_VERSION MASTER_IP MACHINE_TYPE STATUS hello-world "{{{project_0.default_zone|ZONE}}}" 1.5.7 146.148.46.124 e2-medium RUNNING

Vous pouvez également créer ce cluster depuis la console en ouvrant le menu de navigation et en sélectionnant Kubernetes Engine > Clusters Kubernetes > Créer.

Remarque : Nous vous recommandons de créer le cluster dans la même zone que le bucket de stockage utilisé par Artifact Registry (voir étape précédente).

Accédez au Menu de navigation > Kubernetes Engine. Vous pouvez constater que vous disposez à présent d'un cluster Kubernetes entièrement fonctionnel, exécuté sur Kubernetes Engine.

Il est temps de déployer votre propre application conteneurisée sur le cluster Kubernetes. À partir de maintenant, vous utiliserez la ligne de commande kubectl (déjà configurée dans votre environnement Cloud Shell).

Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier.

Créer votre cluster

Tâche 4 : Créer votre pod

Un pod Kubernetes est un groupe de conteneurs réunis à des fins d'administration et de mise en réseau. Il peut contenir un ou plusieurs conteneurs. Dans cet exemple, vous allez utiliser un seul conteneur créé avec votre image Node.js stockée dans votre dépôt Artifact Registry privé. Il livrera le contenu sur le port 8080.

1. Créez un pod avec la commande kubectl run (remplacez PROJECT_ID par votre ID de projet, que vous trouverez dans la console et dans la section Détails de connexion de l'atelier) :

kubectl create deployment hello-node \ --image={{{ project_0.default_region}}}-docker.pkg.dev/PROJECT_ID/my-docker-repo/hello-node:v1

Résultat :

deployment.apps/hello-node created

Comme vous pouvez le voir, vous avez créé un objet Déploiement. L'utilisation des déploiements est recommandée pour créer et faire évoluer des pods. Dans le cas présent, un nouveau déploiement gère un seul pod dupliqué qui exécute l'image hello-node:v1.

2. Pour afficher le déploiement, exécutez la commande suivante :

kubectl get deployments

Résultat :

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 1/1 1 1 1m36s

3. Pour afficher le pod créé par le déploiement, exécutez cette commande :

kubectl get pods

Résultat :

NAME READY STATUS RESTARTS AGE hello-node-714049816-ztzrb 1/1 Running 0 6m

Nous vous proposons à présent de passer en revue quelques commandes kubectl intéressantes. Aucune d'entre elles ne modifiera l'état du cluster. Pour consulter la documentation de référence complète, reportez-vous à Outil de ligne de commande (kubectl) :

kubectl cluster-info kubectl config view

Pour le dépannage :

kubectl get events kubectl logs <pod-name>

Vous devez maintenant rendre votre pod accessible depuis l'extérieur.

Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier.

Créer votre pod

Tâche 5 : Autoriser le trafic externe

Par défaut, le pod n'est accessible que par le biais de son adresse IP interne au sein du cluster. Pour rendre le conteneur hello-node accessible depuis l'extérieur du réseau virtuel Kubernetes, vous devez exposer le pod en tant que service Kubernetes.

1. Depuis Cloud Shell, vous pouvez présenter le pod au réseau Internet public avec la commande kubectl expose associée à l'indicateur --type="LoadBalancer". Cette option est requise pour créer une adresse IP accessible depuis l'extérieur :

kubectl expose deployment hello-node --type="LoadBalancer" --port=8080

Résultat :

service/hello-node exposed

L'option utilisée dans cette commande indique qu'elle se sert de l'équilibreur de charge fourni par l'infrastructure sous-jacente (dans notre cas, l'équilibreur de charge Compute Engine). Remarquez que vous exposez le déploiement, et non le pod directement. Par conséquent, le service obtenu va répartir le trafic sur tous les pods gérés par le déploiement (dans le cas présent, un seul pod, mais vous ajouterez des instances répliquées par la suite).

Le maître Kubernetes crée l'équilibreur de charge et les règles de transfert Compute Engine associées, les pools cibles et les règles de pare-feu afin de rendre le service entièrement accessible depuis l'extérieur de Google Cloud.

2. Pour trouver l'adresse IP publiquement accessible du service, demandez à kubectl de lister tous les services du cluster :

kubectl get services

Voici le résultat que vous devez obtenir :

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-node 10.3.250.149 104.154.90.147 8080/TCP 1m kubernetes 10.3.240.1 < none > 443/TCP 5m

Deux adresses IP accessibles par le port 8080 sont listées pour votre service hello-node. CLUSTER-IP est l'adresse IP interne visible uniquement au sein de votre réseau virtuel cloud. EXTERNAL-IP correspond à l'adresse IP externe à équilibrage de charge.

Remarque : La disponibilité et la visibilité de l'information EXTERNAL-IP peuvent nécessiter quelques minutes. Si EXTERNAL-IP ne s'affiche pas, patientez quelques minutes, puis exécutez de nouveau la commande.

3. Vous devez maintenant pouvoir accéder au service en utilisant l'adresse suivante dans votre navigateur : http://<EXTERNAL_IP>:8080

À ce stade, vous avez gagné plusieurs fonctionnalités en passant aux conteneurs et à Kubernetes. Vous n'avez pas besoin de spécifier sur quel hôte exécuter votre charge de travail. Vous bénéficiez également de la surveillance et du redémarrage des services. Découvrez maintenant les autres avantages que vous pouvez tirer de votre nouvelle infrastructure Kubernetes.

Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier.

Créer un service Kubernetes

Tâche 6 : Effectuer un scaling à la hausse de votre service

Le scaling des applications, qui est une puissante fonctionnalité de Kubernetes, est simple à mettre en œuvre. Imaginons que vous ayez soudain besoin d'augmenter la capacité de votre solution. Vous pouvez demander au contrôleur de réplication de gérer un certain nombre de nouvelles instances répliquées pour votre pod.

1. Définissez le nombre d'instances répliquées pour votre pod :

kubectl scale deployment hello-node --replicas=4

Résultat :

deployment.extensions/hello-node scaled

2. Demandez une description du déploiement mis à jour :

kubectl get deployment

Résultat :

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 4/4 4 4 16m

Exécutez de nouveau la commande ci-dessus jusqu'à ce que les quatre instances répliquées soient créées.

3. Listez tous les pods :

kubectl get pods

Voici le résultat que vous devez obtenir :

NAME READY STATUS RESTARTS AGE hello-node-714049816-g4azy 1/1 Running 0 1m hello-node-714049816-rk0u6 1/1 Running 0 1m hello-node-714049816-sh812 1/1 Running 0 1m hello-node-714049816-ztzrb 1/1 Running 0 16m

Une approche déclarative est utilisée ici. Plutôt que de démarrer ou d'arrêter des instances, vous déclarez le nombre d'instances à exécuter en permanence. Les boucles de rapprochement de Kubernetes veillent à ce que la réalité corresponde à votre demande et prennent des mesures si nécessaire.

Voici un schéma qui résume l'état de votre cluster Kubernetes :

Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier.

Effectuer un scaling à la hausse de votre service

Tâche 7 : Déployer une mise à niveau sur votre service

À un moment donné, des corrections de bugs ou de nouvelles fonctionnalités seront nécessaires sur l'application que vous avez déployée en production. Kubernetes vous aide à déployer une nouvelle révision en production sans affecter les utilisateurs.

1. Commencez par modifier l'application en ouvrant server.js :

vi server.js i

2. Ensuite, mettez à jour le message de réponse :

response.end("Hello Kubernetes World!");

3. Enregistrez le fichier server.js en appuyant sur Échap, puis saisissez :

:wq

Vous pouvez à présent créer une nouvelle image de conteneur et la publier sur le registre en lui associant un tag représentant un numéro de version (v2 dans cet exemple).

4. Exécutez les commandes suivantes en remplaçant PROJECT_ID par l'ID du projet de l'atelier :

docker build -t hello-node:v2 . docker tag hello-node:v2 {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v2 docker push {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v2 Remarque : La création et le transfert de cette image modifiée devraient être plus rapides, car le cache est utilisé.

Kubernetes met à jour votre contrôleur de réplication de manière fluide pour installer la nouvelle version de l'application. Afin de modifier l'étiquette de l'image pour votre conteneur en cours d'exécution, vous devez modifier le déploiement hello-node deployment existant et remplacer l'image pkg.dev/PROJECT_ID/hello-node:v1 par pkg.dev/PROJECT_ID/hello-node:v2.

1. Pour ce faire, utilisez la commande kubectl edit :

kubectl edit deployment hello-node

Elle permet d'ouvrir un éditeur de texte qui affiche la configuration yaml complète du déploiement. Vous n'avez pas besoin de comprendre la configuration yaml complète pour le moment. Sachez simplement qu'en mettant à jour le champ spec.template.spec.containers.image de la configuration, vous demandez au déploiement de mettre à jour les pods avec la nouvelle image.

2. Recherchez Spec > containers > image et remplacez le numéro de version v1 par v2 :

# Please edit the object below. Lines beginning with a '#' will be ignored, # and an empty file will abort the edit. If an error occurs while saving this file will be # reopened with the relevant failures. # apiVersion: extensions/v1beta1 kind: Deployment metadata: annotations: deployment.kubernetes.io/revision: "1" creationTimestamp: 2016-03-24T17:55:28Z generation: 3 labels: run: hello-node name: hello-node namespace: default resourceVersion: "151017" selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-node uid: 981fe302-f1e9-11e5-9a78-42010af00005 spec: replicas: 4 selector: matchLabels: run: hello-node strategy: rollingUpdate: maxSurge: 1 maxUnavailable: 1 type: RollingUpdate template: metadata: creationTimestamp: null labels: run: hello-node spec: containers: - image: pkg.dev/PROJECT_ID/hello-node:v1 ## Update this line ## imagePullPolicy: IfNotPresent name: hello-node ports: - containerPort: 8080 protocol: TCP resources: {} terminationMessagePath: /dev/termination-log dnsPolicy: ClusterFirst restartPolicy: Always securityContext: {} terminationGracePeriodSeconds: 30

3. Après avoir effectué la modification, pour enregistrer et fermer ce fichier, appuyez sur Échap, puis saisissez :

:wq

Voici le résultat que vous devez obtenir :

deployment.extensions/hello-node edited

4. Exécutez la commande suivante pour mettre à jour le déploiement avec la nouvelle image :

kubectl get deployments

De nouveaux pods seront créés avec la nouvelle image et les anciens pods seront supprimés.

Voici le résultat que vous devez obtenir (vous devrez peut-être réexécuter la commande ci-dessus pour voir ce qui suit) :

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 4/4 4 4 1h

Pendant cette opération, les utilisateurs de vos services ne devraient pas constater d'interruption. Au bout d'un moment, ils commenceront à accéder à la nouvelle version de votre application. Pour en savoir plus sur les mises à jour progressives, consultez la documentation sur l'exécution de mises à jour progressives.

Une fois le cluster Kubernetes Engine configuré, ces fonctionnalités de déploiement, de scaling et de mise à jour offertes par Kubernetes devraient vous permettre de vous concentrer sur l'application plutôt que sur l'infrastructure.

Félicitations !

Notre atelier pratique sur Kubernetes se termine ici. Vous n'avez fait qu'effleurer les possibilités offertes par cette technologie. Explorez-la avec vos propres pods, contrôleurs de réplication et services. Intéressez-vous également aux vérifications d'activité (vérifications de l'état) et envisagez d'utiliser directement l'API Kubernetes.

Atelier suivant

Essayez-vous à la Gestion des déploiements avec Kubernetes Engine ou consultez ces suggestions :

• Orchestrer le cloud avec Kubernetes
• Configurer un cluster Kubernetes privé

Étapes suivantes et informations supplémentaires

• Après cet atelier, nous vous incitons à vous intéresser à Minikube, qui permet de configurer facilement un cluster Kubernetes à nœud unique à des fins de développement et de test : http://kubernetes.io/docs/getting-started-guides/minikube/.
• Kubernetes est un projet Open Source (http://kubernetes.io/) hébergé sur GitHub. Vos commentaires et contributions sont donc toujours utiles.
• Vous pouvez suivre l'actualité de Kubernetes sur Twitter et sur le blog de la communauté.

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 : 8 mai 2025

Dernier test de l'atelier : 8 mai 2025

Copyright 2025 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.