Présentation

Dans cet atelier, vous allez créer des clusters GKE à l'aide de la ligne de commande. Vous allez inspecter le fichier "kubeconfig" et manipuler le cluster avec l'outil de ligne de commande kubectl.

Objectifs

Cet atelier va vous apprendre à effectuer les tâches suivantes :

• Créer et manipuler des clusters GKE avec l'outil de ligne de commande kubectl
• Déployer les pods avec kubectl et les fichiers de configuration
• Stocker et déployer les conteneurs avec Container Registry

Mettre en place l'atelier

Accéder à Qwiklabs

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.

Une fois la connexion initiale effectuée, le tableau de bord du projet s'affiche.

Ouvrir Cloud Shell

La plupart des tâches s'effectueront dans Cloud Shell. Cloud Shell est un environnement de ligne de commande exécuté dans Google Cloud. Cette machine virtuelle basée sur Debian contient tous les outils de gestion dont vous avez besoin (par exemple, docker, gcloud, gsutil et kubectl), ainsi qu'un répertoire d'accueil persistant de 5 Go.

1. Dans la barre de titre de la console Google Cloud, cliquez sur Activer Cloud Shell ().
2. Cliquez sur Continuer.

Une fois le provisionnement terminé, l'invite Cloud Shell s'affiche :

Tâche 1 : Déployer des clusters GKE

Dans cette tâche, vous allez déployer des clusters GKE à l'aide de Cloud Shell.

1. Dans Cloud Shell, définissez les variables d'environnement correspondant à la zone et au nom du cluster en saisissant la commande suivante :

export my_region={{{project_0.default_region|Region}}} export my_cluster=autopilot-cluster-1

2. Dans Cloud Shell, saisissez la commande suivante pour créer un cluster Kubernetes :

gcloud container clusters create-auto $my_cluster --region $my_region

Dans ce type de commande, les options sont généralement définies sur leur valeur par défaut. Pour afficher toutes les options possibles, consultez la documentation de référence de "gcloud container clusters create".

Au fur et à mesure de l'adoption des nouvelles versions de Kubernetes, des changements ont été apportés aux paramètres par défaut du cluster GKE. Ces changements sont signalés par des avertissements.

Remarque : Le déploiement du cluster peut prendre quelques minutes.

Une fois le déploiement terminé, la page Kubernetes Engine > Clusters de la console Google Cloud doit ressembler à la capture d'écran suivante :

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer des clusters GKE

Tâche 2 : Se connecter à un cluster GKE

Dans cette tâche, vous allez utiliser Cloud Shell pour vous authentifier auprès d'un cluster GKE et pour inspecter ensuite les fichiers de configuration kubectl.

Vous devrez vous authentifier dans Kubernetes non seulement pour pouvoir communiquer avec le cluster à partir d'un client externe via le kube-APIserver en cours d'exécution sur l'instance maître, mais également pour que les conteneurs de clusters puissent communiquer à l'intérieur ou à l'extérieur du cluster.

L'authentification dans Kubernetes peut se faire de différentes façons. Pour GKE, l'authentification se fait généralement avec des jetons OAuth2 et peut être gérée via Cloud Identity and Access Management pour l'ensemble du projet. L'authentification peut également se faire via un contrôle des accès basé sur les rôles, et peut alors être définie et configurée dans chaque cluster.

Dans GKE, les conteneurs de clusters peuvent utiliser les comptes de service pour s'authentifier et accéder aux ressources externes.

Remarque : Pour les versions de Kubernetes antérieures à 1.12, les certificats clients et l'authentification de base ne sont pas désactivés par défaut. Ces méthodes d'authentification moins sécurisées doivent être désactivées pour renforcer la sécurité des clusters. À partir de la version 1.12, ces deux méthodes sont désactivées par défaut.

1. Pour créer un fichier kubeconfig en utilisant les identifiants de l'utilisateur actuel (pour permettre l'authentification) et pour fournir les informations sur les points de terminaison d'un cluster spécifique (pour permettre la communication avec ce cluster via l'outil de ligne de commande kubectl), exécutez la commande suivante :

gcloud container clusters get-credentials $my_cluster --region $my_region

Cette commande crée dans votre répertoire d'accueil un répertoire .kube si celui-ci n'existe pas encore. Dans le répertoire .kube, la commande crée un fichier nommé config s'il n'existe pas déjà, et qui est utilisé pour stocker les informations d'authentification et de configuration. Le fichier de configuration est généralement appelé le fichier kubeconfig.

2. Ouvrez le fichier kubeconfig avec l'éditeur de texte nano :

nano ~/.kube/config

Vous pouvez maintenant examiner toutes les données d'authentification et de configuration des points de terminaison qui sont stockées dans le fichier. Les informations concernant le cluster doivent apparaître. Ces informations ont été renseignées lors de la création du cluster.

3. Appuyez sur CTRL+X pour quitter l'éditeur nano.

Remarque : Le fichier kubeconfig peut contenir les informations de nombreux clusters. Le contexte actuellement actif (le cluster qui est manipulé par les commandes kubectl) est indiqué par la propriété current-context.

Vous n'avez pas besoin d'exécuter la commande gcloud container clusters get-credentials pour renseigner le fichier kubeconfig des clusters que vous avez créés dans le même contexte (même utilisateur et même environnement). En effet, les informations concernant ces clusters ont déjà été renseignées lors de leur création.

Vous devrez en revanche l'exécuter si vous souhaitez vous connecter à un cluster créé par un autre utilisateur ou dans un autre environnement. Cette commande permet également de définir un autre cluster pour le contexte actif.

Tâche 3 : Utiliser kubectl pour inspecter un cluster GKE

Dans cette tâche, vous allez inspecter un cluster GKE avec Cloud Shell et kubectl.

Après avoir renseigné le fichier kubeconfig et défini le contexte actif d'un cluster, vous pouvez exécuter des commandes sur ce cluster via l'outil de ligne de commande kubectl. La plupart des commandes aboutissent à un appel API REST sur le serveur maître API, ce qui déclenche l'action associée.

1. Dans Cloud Shell, exécutez la commande suivante pour afficher le contenu du fichier kubeconfig :

kubectl config view

Les données sensibles du certificat sont remplacées par DATA+OMITTED.

2. Dans Cloud Shell, exécutez la commande suivante pour afficher les informations du cluster pour le contexte actif :

kubectl cluster-info

Le résultat décrit le cluster pour le contexte actif.

Résultat :

Kubernetes control plane is running at https://34.133.211.75 GLBCDefaultBackend is running at https://34.133.211.75/api/v1/namespaces/kube-system/services/default-http-backend:http/proxy KubeDNS is running at https://34.133.211.75/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy KubeDNSUpstream is running at https://34.133.211.75/api/v1/namespaces/kube-system/services/kube-dns-upstream:dns/proxy Metrics-server is running at https://34.133.211.75/api/v1/namespaces/kube-system/services/https:metrics-server:/proxy To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

3. Dans Cloud Shell, exécutez la commande suivante pour afficher le contexte actif :

kubectl config current-context

Une ligne de résultat indique le cluster pour le contexte actif.

Résultat :

gke_{{{project_0.project_id|Project_ID}}}_{{{project_0.default_region|Region}}}_autopilot-cluster-1

PROJECT_ID correspond à l'ID de votre projet. Cette information est la même que celle contenue dans la propriété current-context du fichier kubeconfig.

4. Dans Cloud Shell, exécutez la commande suivante pour afficher les détails de tous les contextes de cluster dans le fichier kubeconfig :

kubectl config get-contexts

Plusieurs lignes de résultat fournissent les détails concernant le cluster que vous avez créé et identifient le cluster pour le contexte actif. En général, cette commande affiche les détails des clusters présents dans le fichier kubeconfig de l'utilisateur, y compris les autres clusters créés par l'utilisateur, ainsi que les détails ajoutés manuellement au fichier kubeconfig.

5. Dans Cloud Shell, exécutez la commande suivante pour modifier le contexte actif :

kubectl config use-context gke_${DEVSHELL_PROJECT_ID}_{{{project_0.default_region|Region}}}_autopilot-cluster-1

Dans le cas présent, vous n'avez qu'un seul cluster. Cette commande n'a donc rien modifié.

Il peut cependant arriver qu'un projet contienne plusieurs clusters. Cette approche vous permet de modifier le contexte actif lorsque les informations d'identification et de configuration de plusieurs clusters sont déjà renseignées dans votre fichier kubeconfig. Vous aurez besoin du nom complet du cluster, qui inclut le préfixe gke, l'ID du projet, l'emplacement et le nom à afficher, le tout concaténé avec des traits de soulignement.

6. Dans Cloud Shell, exécutez la commande suivante afin d'activer la saisie semi-automatique en Bash pour kubectl :

source <(kubectl completion bash)

Cette commande n'affiche aucun résultat.

7. Dans Cloud Shell, saisissez kubectl suivi par un espace, puis appuyez deux fois sur la touche Tabulation.

Le shell renvoie toutes les commandes possibles :

8. Dans Cloud Shell, saisissez kubectl co, puis appuyez deux fois sur la touche Tabulation.

L'interface renvoie toutes les commandes commençant par "co" (ou tout autre texte que vous saisissez).

Tâche 4 : Déployer des pods sur des clusters GKE

Dans cette tâche, vous allez utiliser Cloud Shell pour déployer des pods sur des clusters GKE.

Déployer des pods sur GKE avec kubectl

Kubernetes introduit l'abstraction d'un pod pour regrouper un ou plusieurs conteneurs associés en une seule entité à programmer et à déployer en tant qu'unité du même nœud. Vous pouvez déployer un pod constitué d'un seul conteneur à partir d'une image de conteneur unique. Un pod peut également contenir plusieurs conteneurs provenant de plusieurs images de conteneurs.

1. Dans Cloud Shell, exécutez la commande suivante pour déployer nginx en tant que pod nommé nginx-1 :

kubectl create deployment --image nginx nginx-1

Cette commande crée un pod nommé nginx avec un conteneur exécutant l'image nginx. Si aucun dépôt n'est spécifié, le comportement par défaut consiste à essayer de trouver l'image en local ou dans le registre public Docker. En l'occurrence, l'image est extraite du registre public Docker.

2. Dans Cloud Shell, exécutez la commande suivante pour afficher tous les pods déployés dans le cluster actif :

kubectl get pods

Le résultat doit ressembler à l'exemple ci-dessous, mais avec un nom de pod légèrement différent.

Remarque : Si un message indique que le serveur n'est actuellement pas en mesure de gérer la requête, attendez la fin du déploiement et que le serveur soit prêt.

Résultat :

NAME READY STATUS RESTARTS AGE nginx-1-74c7bbdb84-nvwsc 1/1 Running 0 2m52s

3. Dans Cloud Shell, exécutez la commande suivante pour afficher l'utilisation des ressources réparties entre les nœuds du cluster :

kubectl top nodes

Le résultat doit ressembler à cet exemple.

Résultat :

NAME CPU(cores) CPU% MEMORY(bytes) MEMORY% gk3-autopilot-cluster-1-pool-2-7246ae0e-4q7s 1971m 102% 1803Mi 30%

Une autre commande top (kubectl top pods) affiche des informations similaires pour tous les pods déployés dans le cluster.

4. Vous allez maintenant remplacer le nom de votre pod par une variable que nous allons utiliser tout au long de cet atelier. Utiliser les variables de cette manière permet de limiter les erreurs humaines lors de la saisie de noms trop longs. Vous devez saisir le nom unique de votre pod à la place de [your_pod_name].

export my_nginx_pod=[your_pod_name]

Exemple :

export my_nginx_pod=nginx-1-74c7bbdb84-nvwsc

5. Pour vérifier que vous avez correctement défini la variable d'environnement, exécutez dans le shell une commande vous renvoyant sa valeur :

echo $my_nginx_pod

Résultat :

nginx-1-74c7bbdb84-nvwsc

6. Dans Cloud Shell, exécutez la commande suivante pour afficher tous les détails du pod que vous venez de créer :

kubectl describe pod $my_nginx_pod

Le résultat doit ressembler à l'exemple ci-dessous. Les détails du pod, son état, ses conditions et les événements de son cycle de vie sont affichés.

Résultat :

Image: nginx Image: nginx Image: nginx Image ID: docker.io/library/nginx@sha256:480868e8c8c797794257e2abd88d0f9a8809b2fe956cbfbc05dcc0bca1f7cd43 Port: Host Port: State: Running Started: Wed, 17 May 2023 10:47:04 +0000 Ready: True Restart Count: 0 Limits: cpu: 500m ephemeral-storage: 1Gi memory: 2Gi Requests: cpu: 500m ephemeral-storage: 1Gi memory: 2Gi Environment: Mounts: /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-ksxxr (ro) Conditions: Type Status Initialized True Ready True ContainersReady True PodScheduled True Volumes: kube-api-access-ksxxr: Type: Projected (a volume that contains injected data from multiple sources) TokenExpirationSeconds: 3607 ConfigMapName: kube-root-ca.crt ConfigMapOptional: DownwardAPI: true QoS Class: Guaranteed Node-Selectors: Tolerations: kubernetes.io/arch=amd64:NoSchedule node.kubernetes.io/not-ready:NoExecute op=Exists for 300s node.kubernetes.io/unreachable:NoExecute op=Exists for 300s Events: Type Reason Age From Message ---- ------ ---- ---- ------- Warning FailedScheduling 5m42s gke.io/optimize-utilization-scheduler 0/2 nodes are available: 2 Insufficient cpu, 2 Insufficient memory. preemption: 0/2 nodes are available: 2 No preemption victims found for incoming pod. Normal Scheduled 4m15s gke.io/optimize-utilization-scheduler Successfully assigned default/nginx-1-6b7bff9fc7-t7fzk to gk3-autopilot-cluster-1-pool-1-242a3a6a-j9rh Normal TriggeredScaleUp 5m34s cluster-autoscaler pod triggered scale-up: [{https://www.googleapis.com/compute/v1/projects/qwiklabs-gcp-02-92c260add90a/zones/{{{project_0.default_zone|Zone}}}/instanceGroups/gk3-autopilot-cluster-1-pool-1-242a3a6a-grp 0->1 (max: 1000)}] Normal Pulling 3m30s kubelet Pulling image "nginx" Normal Pulled 3m16s kubelet Successfully pulled image "nginx" in 13.843394735s (13.843643782s including waiting) Normal Created 3m16s kubelet Created container nginx Normal Started 3m15s kubelet Started container nginx

Transférer un fichier dans un conteneur

Pour pouvoir diffuser des contenus statiques via le serveur Web nginx, vous devez créer et placer un fichier dans le conteneur.

1. Dans Cloud Shell, exécutez les commandes suivantes pour ouvrir dans l'éditeur de texte nano un fichier nommé test.html :

nano ~/test.html

2. Ajoutez le texte suivant (script shell) au fichier test.html vide :

This is title Hello World

3. Appuyez sur CTRL+X, puis sur Y et sur Entrée pour enregistrer le fichier et quitter l'éditeur nano.

4. Dans Cloud Shell, exécutez la commande suivante pour placer le fichier à l'emplacement approprié dans le conteneur nginx du pod nginx livré de manière statique :

kubectl cp ~/test.html $my_nginx_pod:/usr/share/nginx/html/test.html

Cette commande copie le fichier test.html depuis le répertoire d'accueil local vers le répertoire /usr/share/nginx/html du premier conteneur du pod nginx. Vous pouvez spécifier d'autres conteneurs dans un pod comportant plusieurs conteneurs à l'aide de l'option -c, suivie du nom du conteneur.

Exposer le pod pour des tests

Exposer un pod à des clients en dehors du cluster nécessite un service. Les services sont abordés ailleurs dans le cours et sont très utilisés dans d'autres ateliers. Vous pouvez utiliser une commande simple pour créer un service visant à exposer un pod.

1. Dans Cloud Shell, exécutez la commande suivante afin de créer un service pour exposer notre pod nginx en externe :

kubectl expose pod $my_nginx_pod --port 80 --type LoadBalancer

Cette commande crée un service LoadBalancer, qui permet d'accéder au pod nginx à partir d'adresses Internet situées à l'extérieur du cluster.

2. Dans Cloud Shell, exécutez la commande suivante pour afficher les détails des services du cluster :

kubectl get services

Le résultat doit ressembler à l'exemple ci-dessous. Vous allez utiliser l'adresse IP externe lors de l'étape suivante.

Remarque : Vous devrez peut-être répéter la commande plusieurs fois jusqu'à ce que le nouveau service obtienne son adresse IP externe.

Résultat :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.11.240.1 443/TCP 1h nginx-1-7...wsc LoadBalancer 10.11.240.87 80:31695/TCP 3s

Le service Kubernetes est l'un des services par défaut créés ou utilisés par le cluster. Le service nginx que vous avez créé s'affiche également.

Vous devrez peut-être exécuter cette commande plusieurs fois avant que l'adresse IP externe ne s'affiche.

Résultat :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.11.240.1 443/TCP 1h nginx-1-7...wsc LoadBalancer 10.11.240.87 104.154.177.46 80:31695/TCP 1m

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer des pods sur des clusters GKE

3. Dans Cloud Shell, exécutez la commande suivante pour vérifier que le conteneur nginx livre bien le fichier HTML statique que vous avez copié.

Remplacez [EXTERNAL_IP] par l'adresse IP externe de votre service que vous avez obtenue dans le résultat de l'étape précédente.

curl http://[EXTERNAL_IP]/test.html

Le contenu du fichier apparaît dans le résultat. Vous pouvez accéder à la même adresse dans votre navigateur pour afficher le fichier au format HTML.

Exemple :

curl http://104.154.177.46/test.html This is title Hello World

4. Dans Cloud Shell, exécutez la commande suivante pour afficher les ressources utilisées par le pod nginx :

kubectl top pods

Résultat :

NAME CPU(cores) MEMORY(bytes) nginx-1-74c7bbdb84-nvwsc 0m 2Mi

Tâche 5 : Analyser les pods GKE

Dans cette tâche, vous allez vous connecter à un pod pour ajuster les paramètres, modifier des fichiers et effectuer d'autres modifications en direct sur le pod.

Remarque : Utilisez ce processus uniquement en cas de dépannage ou d'expérimentation. Étant donné que les modifications que vous effectuez ne concernent pas l'image source du pod, elles n'apparaîtront dans aucune instance répliquée.

Préparer l'environnement

Le moyen le plus simple de déployer des pods et d'autres ressources sur Kubernetes est d'utiliser des fichiers de configuration, parfois appelés fichiers manifestes. Les fichiers de configuration sont généralement rédigés en syntaxe YAML et contiennent les détails de la ressource. Il est plus facile de spécifier des options complexes avec les fichiers de configuration plutôt qu'avec une longue ligne d'arguments de ligne de commande.

La syntaxe YAML est semblable à la syntaxe JSON, en plus concise. Elle permet le même type de structure hiérarchique des objets et des propriétés. Le dépôt source de l'atelier contient des exemples de fichiers YAML qui ont été préparés pour vous.

1. Saisissez la commande suivante dans Cloud Shell pour cloner le dépôt dans l'environnement Cloud Shell de l'atelier :

git clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Créez un lien symbolique qui servira de raccourci vers le répertoire de travail :

ln -s ~/training-data-analyst/courses/ak8s/v1.1 ~/ak8s

3. Passez au répertoire qui contient les exemples de fichiers de l'atelier :

cd ~/ak8s/GKE_Shell/

Nous vous avons fourni un exemple de fichier manifeste YAML de pod nommé new-nginx-pod.yaml :

apiVersion: v1 kind: Pod metadata: name: new-nginx labels: name: new-nginx spec: containers: - name: new-nginx image: nginx ports: - containerPort: 80

4. Exécutez la commande suivante pour déployer votre fichier manifeste :

kubectl apply -f ./new-nginx-pod.yaml

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer un nouveau pod à l'aide d'un fichier YAML

5. Pour afficher la liste des pods, exécutez la commande suivante :

kubectl get pods

Le résultat doit ressembler à cet exemple.

Résultat :

NAME READY STATUS RESTARTS AGE new-nginx 1/1 Running 0 9s nginx-1-74c7bbdb84-nvwsc 1/1 Running 0 55m

Vous pouvez voir votre nouveau pod nginx, ainsi que celui que nous avons créé plus tôt dans l'atelier.

Utiliser la redirection du shell pour se connecter à un pod

Certaines images de conteneurs contiennent un environnement de shell que vous pouvez lancer. Utiliser cet environnement de shell peut être plus pratique que d'exécuter des commandes individuelles à l'aide de kubectl. Par exemple, l'image nginx contient un shell bash. Dans cette tâche, vous utilisez la redirection shell pour vous connecter au shell bash de votre nouveau pod nginx et effectuer une séquence d'actions.

1. Dans Cloud Shell, exécutez la commande suivante pour démarrer un shell bash interactif dans le conteneur nginx :

kubectl exec -it new-nginx -- /bin/bash

Une invite du shell s'affiche.

Résultat :

root@new-nginx:/#

Vous avez démarré un shell Bash interactif dans le conteneur du pod new-nginx. Si le pod a plusieurs conteneurs, vous pouvez spécifier le nom du conteneur que vous souhaitez utiliser avec l'option -c.

Étant donné que l'image du conteneur nginx n'a par défaut aucun outil d'édition de texte, vous devez en installer un.

2. Dans Cloud Shell, exécutez les commandes suivantes dans le shell bash nginx pour installer l'éditeur de texte nano :

apt-get update apt-get install nano

Lorsque l'invite Do you want to continue (Y/n) (Voulez-vous continuer (O/n)) apparaît, appuyez sur Y pour continuer.

Vous devez créer un fichier test.html dans le répertoire statique livré du conteneur nginx.

3. Dans Cloud Shell, exécutez les commandes suivantes dans le shell bash nginx pour passer au répertoire de fichiers statiques et créer un fichier test.html :

cd /usr/share/nginx/html nano test.html

4. Dans Cloud Shell, saisissez le texte suivant dans la session nano du shell Bash nginx :

This is title Hello World

5. Appuyez sur CTRL+X, puis sur Y et sur Entrée pour enregistrer le fichier et quitter l'éditeur nano.
6. Dans Cloud Shell, exécutez la commande suivante dans le shell bash nginx pour le quitter :

exit

Pour vous connecter au conteneur nginx modifié (contenant le nouveau fichier HTML statique) et le tester, vous pouvez créer un service. Une méthode plus simple consiste à utiliser le transfert de port pour se connecter au pod directement à partir de Cloud Shell.

7. Dans Cloud Shell, exécutez la commande suivante pour configurer le transfert de port de Cloud Shell vers le pod nginx (du port 10081 de la VM Cloud Shell au port 80 du conteneur nginx) :

kubectl port-forward new-nginx 10081:80

Le résultat doit ressembler à cet exemple.

Résultat :

Forwarding from 127.0.0.1:10081 -> 80 Forwarding from [::1]:10081 -> 80

Il s'agit d'un processus de premier plan. Vous devez donc ouvrir une autre instance Cloud Shell pour tester le conteneur.

8. Dans la barre de menu de Cloud Shell, cliquez sur l'icône représentant un signe plus (+) pour démarrer une nouvelle session Cloud Shell.

Une deuxième session Cloud Shell apparaît dans votre fenêtre Cloud Shell. Vous pouvez passer d'une session à l'autre en cliquant sur les titres dans la barre de menu.

9. Dans la deuxième session Cloud Shell, exécutez la commande suivante pour tester le conteneur nginx modifié via le transfert de port :

curl http://127.0.0.1:10081/test.html

Le texte HTML que vous avez saisi dans le fichier test.html s'affiche.

This is title Hello World

Afficher les journaux d'un pod

1. Dans la barre de menu de Cloud Shell, cliquez sur l'icône représentant un signe plus (+) pour démarrer une nouvelle session Cloud Shell.

Une troisième session Cloud Shell apparaît dans votre fenêtre Cloud Shell. Comme précédemment, vous pouvez changer de session en cliquant dessus dans la barre de menu.

2. Dans la troisième fenêtre Cloud Shell, exécutez la commande suivante pour afficher les journaux et pour diffuser les nouveaux à mesure qu'ils arrivent (tout en incluant les codes temporels) pour le pod new-nginx :

kubectl logs new-nginx -f --timestamps

3. Les journaux s'affichent dans la nouvelle fenêtre.
4. Revenez à la deuxième fenêtre Cloud Shell et exécutez à nouveau la commande curl pour générer du trafic sur le pod.
5. Examinez les autres messages de journal qui apparaissent dans la troisième fenêtre Cloud Shell.

6. Fermez la troisième fenêtre Cloud Shell pour arrêter d'afficher les messages de journal.
7. Fermez la première fenêtre Cloud Shell pour arrêter le processus de transfert de port.

Terminer l'atelier

Une fois l'atelier terminé, cliquez sur Terminer l'atelier. Google Cloud Skills Boost supprime les ressources que vous avez utilisées, puis efface le compte.

Si vous le souhaitez, vous pouvez noter l'atelier. Sélectionnez un nombre d'étoiles, saisissez un commentaire, puis cliquez sur Envoyer.

Le nombre d'étoiles correspond à votre degré de satisfaction :

• 1 étoile = très insatisfait(e)
• 2 étoiles = insatisfait(e)
• 3 étoiles = ni insatisfait(e), ni satisfait(e)
• 4 étoiles = satisfait(e)
• 5 étoiles = très satisfait(e)

Si vous ne souhaitez pas donner votre avis, vous pouvez fermer la boîte de dialogue.

Pour soumettre des commentaires, suggestions ou corrections, veuillez accéder à l'onglet Assistance.

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