Présentation

Dans cet atelier, vous allez configurer une application Web dans Google Kubernetes Engine (GKE), puis assurer son autoscaling à l'aide d'HorizontalPodAutoscaler. Vous travaillerez ensuite avec plusieurs pools de nœuds de différents types et appliquerez des rejets et des tolérances afin de contrôler la planification des pods par rapport au pool de nœuds sous-jacents.

Objectifs

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Configurer l'autoscaling et HorizontalPodAutoscaler
• Ajouter un pool de nœuds et configurer des rejets sur les nœuds pour l'anti-affinité du pod
• Configurer une exception pour le rejet du nœud en ajoutant une tolérance au fichier manifeste d'un pod

Préparation

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.

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 :

gcloud auth list

Résultat :

Credentialed accounts: - @.com (active)

Exemple de résultat :

Credentialed accounts: - google1623327_student@qwiklabs.net

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

gcloud config list project

Résultat :

[core] project =

Exemple de résultat :

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

Tâche 1 : Se connecter au cluster GKE de l'atelier et déployer un exemple de charge de travail

Dans cette tâche, vous allez vous connecter au cluster GKE de l'atelier et créer un fichier manifeste de déploiement pour un ensemble de pods au sein du cluster.

Se connecter au cluster GKE de l'atelier

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_zone={{{project_0.default_zone|ZONE}}} export my_cluster=standard-cluster-1

2. Configurez la complétion par tabulation dans l'outil de ligne de commande kubectl :

source <(kubectl completion bash)

3. Configurez l'accès à votre cluster pour kubectl :

gcloud container clusters get-credentials $my_cluster --zone $my_zone

Déployer un exemple d'application Web sur votre cluster GKE

Vous allez déployer un exemple d'application sur votre cluster à l'aide du fichier de déploiement web.yaml que nous avons créé pour vous :

apiVersion: apps/v1 kind: Deployment metadata: name: web spec: replicas: 1 selector: matchLabels: run: web template: metadata: labels: run: web spec: containers: - image: gcr.io/google-samples/hello-app:1.0 name: web ports: - containerPort: 8080 protocol: TCP resources: # You must specify requests for CPU to autoscale # based on CPU utilization requests: cpu: "250m"

Ce fichier manifeste crée un déploiement à l'aide de l'exemple d'image du conteneur de l'application Web qui écoute sur le port 8080 d'un serveur HTTP.

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/Autoscaling/

4. Pour créer un déploiement à partir de ce fichier, exécutez la commande suivante :

kubectl create -f web.yaml --save-config

5. Créez une ressource de service de type NodePort sur le port 8080 pour le déploiement Web :

kubectl expose deployment web --target-port=8080 --type=NodePort

6. Vérifiez que le service a été créé et qu'un port de nœud a bien été attribué :

kubectl get service web

Votre adresse IP et votre numéro de port peuvent être différents de ceux de l'exemple de résultat.

Résultat :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE web NodePort 10.11.246.185 8080:32056/TCP 12s

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer un exemple d'application Web sur un cluster GKE

Tâche 2 : Configurer l'autoscaling sur le cluster

Dans cette tâche, vous allez configurer le cluster pour qu'il effectue le scaling automatique de l'application que vous avez déployée précédemment.

Configurer l'autoscaling

1. Obtenez la liste des déploiements pour savoir si votre exemple d'application Web est toujours en cours d'exécution :

kubectl get deployment

Le résultat doit ressembler à cet exemple.

Résultat :

NAME READY UP-TO-DATE AVAILABLE AGE web 1/1 1 1 5m48s

Si le déploiement Web de votre application ne s'affiche pas, retournez à la tâche 1 et déployez-la de nouveau sur le cluster.

2. Pour configurer votre exemple d'application pour l'autoscaling (avec un nombre d'instances dupliquées allant de un à quatre, et un objectif d'utilisation du processeur de 1 %), exécutez la commande suivante :

kubectl autoscale deployment web --max 4 --min 1 --cpu-percent 1

Lorsque vous utilisez la commande kubectl autoscale, vous spécifiez un nombre maximal et un nombre minimal d'instances répliquées pour votre application, ainsi qu'un objectif d'utilisation du processeur.

3. Obtenez la liste des déploiements pour vérifier qu'il n'existe qu'un seul déploiement de l'application Web :

kubectl get deployment

Résultat :

NAME READY UP-TO-DATE AVAILABLE AGE web 1/1 1 1 8m21s

Inspecter l'objet HorizontalPodAutoscaler

La commande kubectl autoscale employée dans la tâche précédente crée un objet HorizontalPodAutoscaler qui cible une ressource spécifiée (appelée objectif de scaling), et la fait évoluer si besoin.

L'autoscaler ajuste régulièrement le nombre d'instances dupliquées de l'objectif de scaling, afin de respecter la valeur d'utilisation moyenne du processeur que vous spécifiez lors de la création de l'autoscaler.

1. Pour obtenir la liste des ressources HorizontalPodAutoscaler, exécutez la commande suivante :

kubectl get hpa

Le résultat doit ressembler à cet exemple.

Résultat :

NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE web Deployment/web 0%/1% 1 4 1 1m

2. Pour inspecter la configuration d'HorizontalPodAutoscaler au format table, exécutez la commande suivante :

kubectl describe horizontalpodautoscaler web

Le résultat doit ressembler à cet exemple.

Résultat :

Name: web Namespace: default Labels: Annotations: CreationTimestamp: Tue, 08 Sep 2020... Reference: Deployment/web Metrics: ( current / target ) resource cpu on pods (as a percentage of request): 0% (0) / 1% Min replicas: 1 Max replicas: 4 Deployment pods: 1 current / 1 desired Conditions: Type Status Reason Message ---- ------ ------ ------- AbleToScale True ScaleDownStabilized recent recommendations [...] ScalingActive True ValidMetricFound the HPA was able to [...] ScalingLimited False DesiredWithinRange the desired count [...] Events:

3. Pour afficher la configuration de HorizontalPodAutoscaler au format YAML, exécutez la commande suivante :

kubectl get horizontalpodautoscaler web -o yaml

Le résultat doit ressembler à cet exemple.

Résultat :

apiVersion: autoscaling/v1 kind: HorizontalPodAutoscaler metadata: annotations: autoscaling.alpha.kubernetes.io/conditions: [...] autoscaling.alpha.kubernetes.io/current-metrics: [...] creationTimestamp: 2018-11-14T02:59:28Z name: web namespace: default resourceVersion: "14588" selfLink: /apis/autoscaling/v1/namespaces/[...] spec: maxReplicas: 4 minReplicas: 1 scaleTargetRef: apiVersion: apps/v1 kind: Deployment name: web targetCPUUtilizationPercentage: 1 status: currentCPUUtilizationPercentage: 0 currentReplicas: 1 desiredReplicas: 1

Tester la configuration de l'autoscaling

Créez une charge importante sur l'application Web pour la forcer à effectuer un scaling horizontal. Créez un fichier de configuration qui définit un déploiement de quatre conteneurs exécutant une boucle infinie de requêtes HTTP sur le serveur Web de l'exemple d'application.

Pour créer la charge sur votre application Web, déployez l'application loadgen à l'aide du fichier loadgen.yaml fourni.

apiVersion: apps/v1 kind: Deployment metadata: name: loadgen spec: replicas: 4 selector: matchLabels: app: loadgen template: metadata: labels: app: loadgen spec: containers: - name: loadgen image: k8s.gcr.io/busybox args: - /bin/sh - -c - while true; do wget -q -O- http://web:8080; done

1. Pour déployer ce conteneur, exécutez la commande suivante :

kubectl apply -f loadgen.yaml

Après avoir déployé ce fichier manifeste, le scaling du pod Web démarre.

Cliquez sur Check my progress (Vérifier ma progression) pour vérifier l'objectif. Déployer l'application loadgen

2. Obtenez la liste des déploiements pour vérifier que le générateur de charge est en cours d'exécution :

kubectl get deployment

Le résultat doit ressembler à cet exemple.

Résultat :

NAME READY UP-TO-DATE AVAILABLE AGE loadgen 4/4 4 4 26s web 1/1 1 1 14m

3. Inspectez HorizontalPodAutoscaler :

kubectl get hpa

Une fois que le pod loadgen commence à générer du trafic, l'utilisation du processeur du déploiement Web s'intensifie. Dans l'exemple de résultat, les cibles sont maintenant à 35 % d'utilisation du processeur par rapport au seuil de 1 %.

Résultat :

NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE web Deployment/web 35%/1% 1 4 1 8m

4. Au bout de quelques minutes, inspectez à nouveau HorizontalPodAutoscaler :

kubectl get hpa

L'autoscaler a augmenté le nombre d'instances répliquées du déploiement Web, qui en compte maintenant quatre.

Résultat :

NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE web Deployment/web 88%/1% 1 4 4 9m

5. Pour arrêter de générer une charge sur l'application Web, ramenez à zéro le nombre d'instances répliquées du déploiement de l'application loadgen :

kubectl scale deployment loadgen --replicas 0

6. Obtenez la liste des déploiements pour vérifier que l'application loadgen a effectué un scaling à la baisse :

kubectl get deployment

Le déploiement de l'application loadgen ne doit présenter aucune instance répliquée.

Résultat :

NAME READY UP-TO-DATE AVAILABLE AGE loadgen 0/0 0 0 3m40s web 2/4 4 2 18m Remarque : Vous devez attendre entre deux et trois minutes avant de pouvoir lister à nouveau les déploiements.

7. Obtenez la liste des déploiements pour vérifier que le nombre d'instances répliquées de l'application Web est revenu au seuil minimal de 1 que vous aviez configuré en déployant l'autoscaler :

kubectl get deployment

Vous devez maintenant avoir un seul déploiement de l'application Web.

Résultat :

NAME READY UP-TO-DATE AVAILABLE AGE loadgen 0/0 0 0 12m web 1/1 1 1 14m

Tâche 3 : Gérer les pools de nœuds

Dans cette tâche, vous allez créer un pool de nœuds à l'aide d'instances préemptives, puis faire en sorte que le déploiement Web ne s'exécute que sur les nœuds préemptifs.

Ajouter un pool de nœuds

1. Pour déployer un nouveau pool de nœuds à l'aide de trois instances de VM préemptives, exécutez la commande suivante :

gcloud container node-pools create "temp-pool-1" \ --cluster=$my_cluster --zone=$my_zone \ --num-nodes "2" --node-labels=temp=true --preemptible

Si vous recevez un message d'erreur indiquant qu'aucune instance préemptive n'est disponible, vous pouvez supprimer l'option --preemptible pour poursuivre l'atelier.

2. Obtenez la liste des nœuds pour vérifier que les nouveaux nœuds sont prêts :

kubectl get nodes

Vous devez maintenant avoir 4 nœuds.

Les noms que vous utiliserez seront différents de ceux de l'exemple.

Résultat :

NAME STATUS ROLES AGE VERSION gke-standard-cluster-1-default-pool...xc Ready 33m v1.19.10-gke.1600 gke-standard-cluster-1-default-pool...q8 Ready 33m v1.19.10-gke.1600 gke-standard-cluster-1-temp-pool-1-...vj Ready 32s v1.19.10-gke.1600 gke-standard-cluster-1-temp-pool-1-...xj Ready 37s v1.19.10-gke.1600

Tous les nœuds que vous avez ajoutés présentent l'étiquette temp=true, car vous l'avez définie lors de la création du pool de nœuds. Cette étiquette facilite la localisation et la configuration de ces nœuds.

3. Pour recenser uniquement les nœuds présentant l'étiquette temp=true, exécutez la commande suivante :

kubectl get nodes -l temp=true

Seuls les deux nœuds que vous avez ajoutés doivent s'afficher.

Les noms que vous utiliserez seront différents de ceux de l'exemple.

Résultat :

NAME STATUS ROLES AGE VERSION gke-standard-cluster-1-temp-pool-1-...vj Ready 3m26s v1.19.10-gke.1600 gke-standard-cluster-1-temp-pool-1-...xj Ready 3m31s v1.19.10-gke.1600

Contrôler la planification à l'aide des tolérances et des rejets de nœuds

Pour empêcher le programmeur d'exécuter un pod sur les nœuds temporaires, vous devez ajouter un rejet à chacun des nœuds du pool temporaire. Les rejets sont mis en œuvre sous la forme d'une paire clé-valeur ayant un effet (tel que NoExecute) qui détermine si les pods peuvent s'exécuter sur un nœud donné. Seuls les pods configurés pour tolérer la clé-valeur du rejet sont programmés pour s'exécuter sur ces nœuds.

1. Pour ajouter un rejet à chacun des nœuds nouvellement créés, exécutez la commande suivante.

Vous pouvez utiliser l'étiquette temp=true pour appliquer cette modification simultanément à tous les nouveaux nœuds :

kubectl taint node -l temp=true nodetype=preemptible:NoExecute

Pour permettre aux pods d'applications de s'exécuter sur ces nœuds de rejets, vous devez ajouter une clé de tolérances à la configuration du déploiement.

2. Pour modifier le fichier web.yaml, exécutez la commande suivante :

nano web.yaml

3. Ajoutez la clé suivante dans la section spec du modèle :

tolerations: - key: "nodetype" operator: Equal value: "preemptible"

La section "spec" du fichier doit ressembler à cet exemple :

... spec: tolerations: - key: "nodetype" operator: Equal value: "preemptible" containers: - image: gcr.io/google-samples/hello-app:1.0 name: web ports: - containerPort: 8080 protocol: TCP resources: # You must specify requests for CPU to autoscale # based on CPU utilization requests: cpu: "250m"

4. Pour forcer le déploiement Web à utiliser le nouveau pool de nœuds, ajoutez une clé nodeSelector dans la section spec du modèle. Elle agit en parallèle à la clé de tolérances que vous venez d'ajouter :

nodeSelector: temp: "true" Remarque : GKE ajoute à chaque nœud une étiquette personnalisée appelée cloud.google.com/gke-nodepool qui contient le nom du pool de nœuds auquel le nœud appartient. Cette clé peut aussi être employée dans un nodeSelector pour veiller à ce que les pods ne soient déployés que sur les nœuds appropriés.

Le déploiement complet du fichier web.yaml doit maintenant ressembler à ce qui suit :

apiVersion: apps/v1 kind: Deployment metadata: name: web spec: replicas: 1 selector: matchLabels: run: web template: metadata: labels: run: web spec: tolerations: - key: "nodetype" operator: Equal value: "preemptible" nodeSelector: temp: "true" containers: - image: gcr.io/google-samples/hello-app:1.0 name: web ports: - containerPort: 8080 protocol: TCP resources: # You must specify requests for CPU to autoscale # based on CPU utilization requests: cpu: "250m"

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

6. Pour appliquer cette modification, exécutez la commande suivante :

kubectl apply -f web.yaml

Si vous ne parvenez pas à modifier ce fichier, vous pouvez utiliser le fichier d'exemple prédéfini, appelé web-tolerations.yaml.

Cliquez sur Check my progress (Vérifier ma progression) pour vérifier l'objectif. Gérer des pools de nœuds

7. Obtenez la liste des pods :

kubectl get pods

Les noms que vous utilisez peuvent être différents de ceux de l'exemple.

Résultat :

NAME READY STATUS RESTARTS AGE web-7cb566bccd-pkfst 1/1 Running 0 1m

6. Pour confirmer que la modification a bien été effectuée, inspectez le ou les pods Web en cours d'exécution à l'aide de la commande suivante :

kubectl describe pods -l run=web

Une section Tolerations (Tolérances) dont la liste affiche nodetype=preemptible doit apparaître au bas du résultat (tronqué).

Résultat :

Node-Selectors: temp=true Tolerations: node.kubernetes.io/not-ready:NoExecute op=Exists for 300s node.kubernetes.io/unreachable:NoExecute op=Exists for 300s nodetype=preemptible Events:

Le résultat confirme que les pods vont tolérer la valeur de rejet des nouveaux nœuds préemptifs et qu'ils peuvent donc être programmés pour s'exécuter sur ces nœuds.

7. Pour forcer l'application Web à effectuer de nouveau un scaling horizontal, redimensionnez le déploiement de l'application loadgen à quatre instances répliquées :

kubectl scale deployment loadgen --replicas 4

Vous pouvez directement mettre l'application Web à l'échelle. Toutefois, l'application loadgen vous permet de voir comment les différents paramètres de rejet, de tolérance et de nodeSelector associés aux applications Web et loadgen affectent les nœuds sur lesquels ils sont programmés.

8. Pour obtenir la liste des pods et afficher les nœuds qui les exécutent, utilisez le format de sortie large :

kubectl get pods -o wide

Vous constaterez que l'application loadgen s'exécute uniquement sur les nœuds default-pool, tandis que l'application Web exécute uniquement les nœuds préemptifs dans temp-pool-1.

Le paramètre de rejet empêche les pods de s'exécuter sur les nœuds préemptifs. L'application loadgen ne s'exécute donc que sur le pool par défaut. Le paramètre de tolérance permet à l'application Web de s'exécuter sur les nœuds préemptifs tandis que nodeSelector force les pods de l'application Web à s'exécuter sur ces nœuds.

NAME READY STATUS [...] NODE Loadgen-x0 1/1 Running [...] gke-xx-default-pool-y0 loadgen-x1 1/1 Running [...] gke-xx-default-pool-y2 loadgen-x3 1/1 Running [...] gke-xx-default-pool-y3 loadgen-x4 1/1 Running [...] gke-xx-default-pool-y4 web-x1 1/1 Running [...] gke-xx-temp-pool-1-z1 web-x2 1/1 Running [...] gke-xx-temp-pool-1-z2 web-x3 1/1 Running [...] gke-xx-temp-pool-1-z3 web-x4 1/1 Running [...] gke-xx-temp-pool-1-z4

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.