GSP766

Présentation

Lorsque vous envisagez d'utiliser des solutions d'optimisation des coûts pour une infrastructure Google Cloud basée sur des clusters Google Kubernetes Engine (GKE), il est important de vous assurer que vous utilisez efficacement les ressources qui vous sont facturées. L'un des écueils courants consiste à attribuer les utilisateurs ou les équipes à un cluster dédié, ce qui en définitive multiplie les clusters.

Un cluster mutualisé permet à plusieurs utilisateurs ou équipes de partager un cluster pour leurs charges de travail tout en assurant l'isolation et le partage équitable des ressources. Pour ce faire, vous devez créer des espaces de noms. Les espaces de noms permettent à plusieurs clusters virtuels de coexister sur un même cluster physique.

Dans cet atelier, vous allez apprendre à configurer un cluster mutualisé en utilisant plusieurs espaces de noms pour optimiser l'utilisation des ressources et donc les coûts.

Objectifs

Dans cet atelier, vous allez apprendre à :

• créer plusieurs espaces de noms dans un cluster GKE ;
• configurer le contrôle des accès basé sur les rôles pour accéder aux espaces de noms ;
• configurer des quotas de ressources Kubernetes pour partager équitablement les ressources entre plusieurs espaces de noms ;
• afficher et configurer les tableaux de bord de surveillance pour consulter l'utilisation des ressources par espace de noms ;
• générer un rapport de mesure GKE dans Data Studio pour obtenir des métriques précises sur l'utilisation des ressources par espace de noms.

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.

Démarrage

Lorsque vous appuyez sur le bouton Démarrer l'atelier, le message Provisionnement des ressources de l'atelier s'affiche en bleu avec une estimation du temps restant. Cela crée et configure l'environnement que vous utiliserez pour tester la gestion d'un cluster mutualisé. Dans un délai de cinq minutes environ, un cluster est créé, les ensembles de données BigQuery sont copiés et les comptes de service qui représentent les équipes sont générés.

Lorsque le processus se termine, le message disparaît.

À ce stade, vous pourrez commencer l'atelier.

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 : télécharger les fichiers requis

1. Dans cet atelier, certaines étapes utilisent des fichiers YAML pour configurer votre cluster Kubernetes. Dans votre environnement Cloud Shell, téléchargez ces fichiers à partir d'un bucket Cloud Storage :

gsutil -m cp -r gs://spls/gsp766/gke-qwiklab ~

2. Passez de votre répertoire de travail actuel au répertoire gke-qwiklab :

cd ~/gke-qwiklab

Tâche 2 : afficher et créer des espaces de noms

• Exécutez la commande suivante pour définir une zone de calcul par défaut et authentifier le cluster mutualisé fourni :

export ZONE={{{project_0.default_zone|placeholder}}} gcloud config set compute/zone ${ZONE} && gcloud container clusters get-credentials multi-tenant-cluster

Espaces de noms par défaut

Par défaut, les clusters Kubernetes disposent de quatre espaces de noms système.

1. Vous pouvez obtenir la liste complète des espaces de noms du cluster actuel en exécutant cette commande :

kubectl get namespace

Le résultat doit ressembler à ceci :

NAME STATUS AGE default Active 5m kube-node-lease Active 5m kube-public Active 5m kube-system Active 5m

• default : espace de noms par défaut utilisé lorsqu'aucun autre espace de noms n'est spécifié
• kube-node-lease : gère les objets de bail associés aux pulsations de chaque nœud du cluster
• kube-public : à utiliser pour les ressources qui devront peut-être être visibles ou lisibles par tous les utilisateurs dans l'ensemble du cluster
• kube-system : utilisé pour les composants créés par le système Kubernetes

Les ressources n'appartiennent pas toutes à un espace de noms. Par exemple, les nœuds, les volumes persistants et les espaces de noms eux-mêmes n'appartiennent à aucun espace de noms.

2. Pour obtenir la liste complète des ressources associées à un espace de noms, exécutez la commande suivante :

kubectl api-resources --namespaced=true

Une fois créées, ces ressources doivent être associées à un espace de noms. Pour ce faire, vous pouvez inclure le flag --namespace ou indiquer un espace de noms dans le champ de métadonnées du fichier YAML.

3. L'espace de noms peut également être spécifié avec n'importe quelle sous-commande kubectl get pour afficher les ressources d'un espace de noms. Exemple :

kubectl get services --namespace=kube-system

Tous les services de l'espace de noms kube-system sont ainsi renvoyés.

Créer des espaces de noms

Remarque : Lorsque vous créez des espaces de noms supplémentaires, évitez d'utiliser le préfixe "kube", celui-ci étant réservé aux espaces de noms système.

1. Créez deux espaces de noms, un pour l'équipe A (team-a), l'autre pour l'équipe B (team-b) :

kubectl create namespace team-a && \ kubectl create namespace team-b

Le résultat de la commande kubectl get namespace doit maintenant inclure vos deux nouveaux espaces de noms :

namespace/team-a created namespace/team-b created

En spécifiant le tag --namespace, vous pouvez créer des ressources de cluster dans l'espace de noms fourni. Les noms des ressources telles que les déploiements ou les pods doivent être uniques uniquement dans leur espace de noms respectif.

2. Par exemple, exécutez la commande suivante pour déployer un pod avec le même nom dans les espaces de noms team-a et team-b :

kubectl run app-server --image=quay.io/centos/centos:9 --namespace=team-a -- sleep infinity && \ kubectl run app-server --image=quay.io/centos/centos:9 --namespace=team-b -- sleep infinity

3. Utilisez la commande kubectl get pods -A pour détecter deux pods nommés app-server, un pour chaque espace de noms d'équipe :

kubectl get pods -A

Résultat :

NAMESPACE NAME READY STATUS RESTARTS AGE kube-system event-exporter-gke-8489df9489-k2blq 2/2 Running 0 3m41s kube-system fluentd-gke-fmt4v 2/2 Running 0 113s kube-system fluentd-gke-n9dvn 2/2 Running 0 79s kube-system fluentd-gke-scaler-cd4d654d7-xj78p 1/1 Running 0 3m37s kube-system gke-metrics-agent-4jvn8 1/1 Running 0 3m33s kube-system gke-metrics-agent-b4vvw 1/1 Running 0 3m27s kube-system kube-dns-7c976ddbdb-gtrct 4/4 Running 0 3m41s kube-system kube-dns-7c976ddbdb-k9bgk 4/4 Running 0 3m kube-system kube-dns-autoscaler-645f7d66cf-jwqh5 1/1 Running 0 3m36s kube-system kube-proxy-gke-new-cluster-default-pool-eb9986d5-tpql 1/1 Running 0 3m26s kube-system kube-proxy-gke-new-cluster-default-pool-eb9986d5-znm6 1/1 Running 0 3m33s kube-system l7-default-backend-678889f899-xvt5t 1/1 Running 0 3m41s kube-system metrics-server-v0.3.6-64655c969-jtl57 2/2 Running 0 3m kube-system prometheus-to-sd-d6dpf 1/1 Running 0 3m27s kube-system prometheus-to-sd-rfdlv 1/1 Running 0 3m33s kube-system stackdriver-metadata-agent-cluster-level-79f9ddf6d6-7ck2w 2/2 Running 0 2m56s team-a app-server 1/1 Running 0 33s team-b app-server 1/1 Running 0 33s

Cliquez sur Vérifier ma progression pour vérifier que vous avez correctement effectué la tâche ci-dessus. Créer des espaces de noms

4. Utilisez la commande kubectl describe pour afficher des informations supplémentaires sur chaque pod créé, en spécifiant l'espace de noms avec le tag "--namespace" :

kubectl describe pod app-server --namespace=team-a

5. Pour travailler exclusivement avec les ressources d'un seul espace de noms sans avoir à inclure le flag --namespace pour chaque commande, vous pouvez utiliser le contexte kubectl :

kubectl config set-context --current --namespace=team-a

6. Toutes les commandes suivantes seront alors exécutées dans l'espace de noms indiqué sans spécifier le flag --namespace :

kubectl describe pod app-server

Dans la section suivante, vous allez configurer le contrôle des accès basé sur les rôles pour vos espaces de noms afin de faciliter l'organisation du cluster.

Tâche 3 : contrôle des accès dans les espaces de noms

Le provisionnement des accès aux ressources d'espace de noms dans un cluster repose sur l'attribution de rôles IAM, associés au contrôle des accès basé sur les rôles (RBAC, role-based access control) intégré à Kubernetes. Un rôle IAM offre à un compte un accès initial au projet, tandis que les autorisations RBAC octroient un accès précis aux ressources d'espace de noms d'un cluster (pods, déploiements, services, etc.).

Rôles IAM

Remarque : Pour attribuer des rôles IAM dans un projet, vous aurez besoin du rôle Administrateur IAM de projet. Ce rôle est déjà configuré dans votre compte Qwiklabs temporaire.

Lors de la gestion du contrôle des accès pour Kubernetes, Identity and Access Management (IAM) permet de gérer l'accès et les autorisations au niveau de l'organisation et du projet.

Dans IAM, plusieurs rôles peuvent être attribués aux utilisateurs et aux comptes de service pour régir leur niveau d'accès avec GKE. Les autorisations RBAC précises utilisent l'accès déjà fourni par IAM et ne peuvent restreindre l'accès accordé par celui-ci. Par conséquent, pour les clusters mutualisés avec espaces de noms, le rôle IAM attribué doit accorder un accès minimal.

Voici un tableau des rôles IAM de GKE courants que vous pouvez attribuer :

Rôle	Description
Administrateur Kubernetes Engine	Permet de gérer intégralement les clusters et leurs objets API Kubernetes. Un utilisateur doté de ce rôle peut créer, modifier et supprimer n'importe quelle ressource dans n'importe quel cluster et dans les espaces de noms correspondants.
Développeur sur Kubernetes Engine	Fournit un accès aux objets de l'API Kubernetes dans les clusters. Un utilisateur doté de ce rôle peut créer, modifier et supprimer des ressources dans n'importe quel cluster et dans les espaces de noms correspondants.
Administrateur de cluster Kubernetes Engine	Permet de gérer les clusters. Un utilisateur doté de ce rôle n'est pas autorisé à créer ni à modifier directement les ressources d'un cluster ni des espaces de noms correspondants, mais il peut créer, modifier et supprimer des clusters.
Lecteur Kubernetes Engine	Fournit un accès en lecture seule aux ressources GKE. Un utilisateur doté de ce rôle dispose d'un accès en lecture seule aux espaces de noms et à leurs ressources.
Lecteur de cluster Kubernetes Engine	Permet d'accéder aux clusters GKE et de les lister. Il s'agit du rôle minimal requis pour toute personne ayant besoin d'accéder aux ressources des espaces de noms d'un cluster.

Alors que la plupart de ces rôles accordent un accès trop étendu pour permettre une restriction RBAC, le rôle IAM Lecteur de cluster Kubernetes Engine accorde aux utilisateurs suffisamment d'autorisations pour accéder au cluster et aux ressources des espaces de noms.

Dans cet atelier, votre projet dispose d'un compte de service représentant un développeur qui utilisera l'espace de noms team-a.

• Attribuez au compte le rôle Lecteur de cluster Kubernetes Engine en exécutant la commande suivante :

gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \ --member=serviceAccount:team-a-dev@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com \ --role=roles/container.clusterViewer

RBAC dans Kubernetes

Dans un cluster, l'accès à n'importe quel type de ressource (pod, service, déploiement, etc.) est défini par un rôle ou un rôle de cluster. Seuls les rôles peuvent être associés à un espace de noms. Un rôle indique les ressources et les actions autorisées pour chaque ressource, tandis qu'une liaison de rôle indique les comptes ou les groupes d'utilisateurs auxquels attribuer cet accès.

Pour créer un rôle dans l'espace de noms actuel, spécifiez le type de ressource ainsi que les verbes indiquant le type d'action qui sera autorisé.

1. Vous pouvez créer des rôles comportant une règle unique en utilisant la commande kubectl create :

kubectl create role pod-reader \ --resource=pods --verb=watch --verb=get --verb=list

Vous pouvez créer des rôles comportant plusieurs règles à l'aide d'un fichier YAML. Les fichiers que vous avez téléchargés précédemment contiennent un exemple pour cet atelier.

2. Inspectez le fichier YAML :

cat developer-role.yaml

Exemple de résultat :

apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: namespace: team-a name: developer rules: - apiGroups: [""] resources: ["pods", "services", "serviceaccounts"] verbs: ["update", "create", "delete", "get", "watch", "list"] - apiGroups:["apps"] resources: ["deployments"] verbs: ["update", "create", "delete", "get", "watch", "list"]

3. Appliquez le rôle ci-dessus :

kubectl create -f developer-role.yaml

4. Créez une liaison de rôle entre le compte de service team-a-developers et le rôle de développeur :

kubectl create rolebinding team-a-developers \ --role=developer --user=team-a-dev@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com

Tester la liaison de rôle

1. Téléchargez les clés du compte de service qui permettent d'en emprunter l'identité :

gcloud iam service-accounts keys create /tmp/key.json --iam-account team-a-dev@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com

Cliquez sur Vérifier ma progression pour vérifier que vous avez correctement effectué la tâche ci-dessus. Contrôle des accès dans les espaces de noms

2. Dans Cloud Shell, cliquez sur + pour ouvrir un nouvel onglet dans votre terminal.

3. Exécutez la commande suivante pour activer le compte de service : Vous pourrez ainsi exécuter les commandes sous l'identité du compte :

gcloud auth activate-service-account --key-file=/tmp/key.json

4. Récupérez les identifiants de votre cluster sous l'identité du compte de service :

export ZONE={{{project_0.default_zone|placeholder}}} gcloud container clusters get-credentials multi-tenant-cluster --zone ${ZONE} --project ${GOOGLE_CLOUD_PROJECT}

5. Vous constaterez qu'en tant que team-a-dev, vous pouvez lister les pods dans l'espace de noms team-a :

kubectl get pods --namespace=team-a

Résultat :

NAME READY STATUS RESTARTS AGE app-server 1/1 Running 0 6d

6. Toutefois, l'affichage de la liste des pods dans l'espace de noms team-b est limité :

kubectl get pods --namespace=team-b

Résultat :

Error from server (Forbidden): pods is forbidden: User "team-a-dev@a-gke-project.iam.gserviceaccount.com" cannot list resource "pods" in API group "" in the namespace "team-b": requires one of ["container.pods.list"] permission(s).

7. Revenez au premier onglet Cloud Shell ou ouvrez-en un autre.

8. Renouvelez les identifiants du cluster et réinitialisez votre contexte sur l'espace de noms team-a :

export ZONE={{{project_0.default_zone|placeholder}}} gcloud container clusters get-credentials multi-tenant-cluster --zone ${ZONE} --project ${GOOGLE_CLOUD_PROJECT}

Tâche 4 : quotas de ressources

Lorsqu'un cluster est mutualisé et partagé, il est important de s'assurer que les utilisateurs ne peuvent pas accaparer les ressources de façon inéquitable. Un objet de quota de ressources (ResourceQuota) définit des contraintes qui limitent la consommation des ressources dans un espace de noms. Un quota de ressources peut spécifier une limite pour le nombre d'objets (pods, services, StatefulSets, etc.), la somme totale des ressources de stockage (revendications de volume persistant, stockage éphémère, classes de stockage) ou la somme totale des ressources de calcul (processeur et mémoire).

1. Par exemple, la commande suivante limite le nombre de pods autorisés dans l'espace de noms team-a à deux et le nombre d'équilibreurs de charge à un :

kubectl create quota test-quota \ --hard=count/pods=2,count/services.loadbalancers=1 --namespace=team-a

2. Créez un deuxième pod dans l'espace de noms team-a :

kubectl run app-server-2 --image=quay.io/centos/centos:9 --namespace=team-a -- sleep infinity

3. Essayez à présent de créer un troisième pod :

kubectl run app-server-3 --image=quay.io/centos/centos:9 --namespace=team-a -- sleep infinity

Vous devriez recevoir l'erreur suivante :

Error from server (Forbidden): pods "app-server-3" is forbidden: exceeded quota: test-quota, requested: count/pods=1, used: count/pods=2, limited: count/pods=2

4. Vous pouvez vérifier les détails de votre quota de ressources à l'aide de la commande kubectl describe :

kubectl describe quota test-quota --namespace=team-a

Résultat :

Name: test-quota Namespace: team-a Resource Used Hard -------- ---- ---- count/pods 2 2 count/services.loadbalancers 0 1

Cette liste indique les ressources restreintes par le quota de ressources, la limite stricte configurée et la quantité actuellement utilisée.

5. Mettez à jour test-quota pour appliquer une limite de six pods, en exécutant la commande suivante :

export KUBE_EDITOR="nano" kubectl edit quota test-quota --namespace=team-a

Vous pourrez modifier un fichier YAML que kubectl utilisera pour mettre à jour le quota. Le quota inconditionnel correspond à la valeur count/pods sous spec.

6. Sous "spec", définissez la valeur count/pods sur 6 :

apiVersion: v1 kind: ResourceQuota metadata: creationTimestamp: "2020-10-21T14:12:07Z" name: test-quota namespace: team-a resourceVersion: "5325601" selfLink: /api/v1/namespaces/team-a/resourcequotas/test-quota uid: a4766300-29c4-4433-ba24-ad10ebda3e9c spec: hard: count/pods: "6" count/services.loadbalancers: "1" status: hard: count/pods: "5" count/services.loadbalancers: "1" used: count/pods: "2"

7. Appuyez sur Ctrl+X, Y, puis ENTRÉE pour enregistrer et quitter.

Le quota mis à jour doit maintenant apparaître dans le résultat :

kubectl describe quota test-quota --namespace=team-a

Résultat :

Name: test-quota Namespace: team-a Resource Used Hard -------- ---- ---- count/pods 2 6 count/services.loadbalancers 0 1

Quotas de ressources processeur et mémoire

Lorsque vous définissez des quotas pour le processeur et la mémoire, vous pouvez indiquer un quota pour la somme des demandes (une valeur qu'un conteneur est assuré d'obtenir) ou la somme des limites (une valeur qu'un conteneur ne sera jamais autorisé à dépasser).

Dans cet atelier, votre cluster comporte quatre machines e2-standard-2, chacune avec deux cœurs et 8 Go de mémoire. Un exemple de fichier YAML de quota de ressources vous a été fourni pour votre cluster :

cpu-mem-quota.yaml

apiVersion: v1 kind: ResourceQuota metadata: name: cpu-mem-quota namespace: team-a spec: hard: limits.cpu: "4" limits.memory: "12Gi" requests.cpu: "2" requests.memory: "8Gi"

1. Appliquez la configuration du fichier :

Remarque : Vérifiez que vous vous trouvez toujours dans le répertoire gke-qwiklab. kubectl create -f cpu-mem-quota.yaml

Une fois ce quota en place, la somme des demandes de ressources mémoire et processeur de tous les pods est limitée à deux processeurs et 8 Gio, et leurs limites respectives à quatre processeurs et 12 Gio.

Remarque : Lorsqu'un quota de ressources processeur ou mémoire existe dans un espace de noms, chaque nouveau conteneur dans cet espace de noms doit être créé avec sa propre limite de processeur et de mémoire, ou un objet LimitRange doit définir une valeur par défaut dans l'espace de noms.

2. Pour illustrer le quota de processeurs et de mémoire, créez un nouveau pod à l'aide de cpu-mem-demo-pod.yaml :

cpu-mem-demo-pod.yaml

apiVersion: v1 kind: Pod metadata: name: cpu-mem-demo namespace: team-a spec: containers: - name: cpu-mem-demo-ctr image: nginx resources: requests: cpu: "100m" memory: "128Mi" limits: cpu: "400m" memory: "512Mi"

3. Appliquez la configuration du fichier :

kubectl create -f cpu-mem-demo-pod.yaml --namespace=team-a

4. Une fois ce pod créé, exécutez la commande suivante pour que les demandes et limites de processeur et de mémoire soient reflétées dans le quota :

kubectl describe quota cpu-mem-quota --namespace=team-a

Résultat :

Name: cpu-mem-quota Namespace: team-a Resource Used Hard -------- ---- ---- limits.cpu 400m 4 limits.memory 512Mi 12Gi requests.cpu 100m 2 requests.memory 128Mi 8Gi

Cliquez sur Vérifier ma progression pour vérifier que vous avez correctement effectué la tâche ci-dessus. Quotas de ressources

Tâche 5 : surveiller GKE et mesurer l'utilisation de GKE

Pour la plupart des clusters mutualisés, il est probable que les charges de travail et les ressources nécessaires pour chacun des locataires évoluent, et que les quotas de ressources aient besoin d'être modifiés. Grâce à Monitoring, vous pouvez obtenir une vue générale des ressources utilisées par chaque espace de noms.

En mesurant l'utilisation de GKE, vous obtenez une vue plus précise de l'utilisation des ressources et vous pouvez vous faire une meilleure idée des coûts associés à chaque locataire.

Tableau de bord Monitoring

1. Dans la console Cloud, cliquez sur le menu de navigation () > Afficher tous les produits. Dans la section Observabilité, cliquez sur Monitoring.

Patientez une minute, le temps que l'espace de travail soit créé pour votre projet.

2. Une fois sur la page "Aperçu", sélectionnez Tableaux de bord dans le menu de gauche :

3. Sur la page Aperçu des tableaux de bord, sélectionnez GKE.

Le tableau de bord GKE présente un ensemble de tables qui détaillent l'utilisation du processeur, de la mémoire et du disque, en fonction de plusieurs ressources.

Par exemple, la table "Espaces de noms" indique l'utilisation de chacun des espaces de noms de vos clusters :

Vous pouvez également consulter les données d'utilisation des charges de travail exécutées sur votre cluster dans la table "Charges de travail".

4. Cliquez sur Tout afficher.

5. Dans la zone AJOUTER UN FILTRE, sélectionnez Espaces de noms > team-a.

6. Cliquez ensuite sur Appliquer.

Cela filtrera les charges de travail de façon à n'inclure que celles qui s'exécutent sur l'espace de noms team-a :

Explorateur de métriques

1. Dans le volet de gauche, sélectionnez Explorateur de métriques.

2. Dans le champ "Sélectionner une métrique", cliquez sur le menu déroulant Métrique.

3. Saisissez Conteneur Kubernetes dans "Filtrer par nom de ressource ou de métrique".

4. Cliquez sur Conteneur Kubernetes > Conteneur.

5. Sélectionnez Durée d'utilisation du processeur.

6. Cliquez sur Appliquer.

Remarque : Saisissez du dans le champ "Métrique". L'option "Durée d'utilisation du processeur" devrait apparaître dans un menu déroulant.

7. Pour exclure l'espace de noms "kube-system", cliquez sur Ajouter un filtre dans la section "Filtre".

8. Choisissez namespace_name comme étiquette.

9. Sélectionnez != (est différent de) en tant que comparateur et kube-system en tant que valeur.

10. Sélectionnez ensuite Somme dans le menu déroulant Agrégation et namespace_name dans le menu déroulant "Par", puis cliquez sur OK.

    Vous verrez un graphique illustrant la durée d'utilisation du processeur du conteneur par espace de noms :

Mesure de l'utilisation de GKE

Vous pouvez exporter l'utilisation et la consommation des ressources du cluster GKE vers un ensemble de données BigQuery, où vous pouvez les visualiser à l'aide de Data Studio. Vous obtenez ainsi une vue plus précise de l'utilisation des ressources. Mesurer l'utilisation vous permet également de définir des quotas de ressources plus adaptés et d'optimiser la configuration des clusters.

Remarque : L'intégration des données de métriques GKE dans BigQuery peut prendre plusieurs heures. Les ensembles de données BigQuery de votre projet d'atelier contiennent donc une simulation de l'utilisation des ressources et des données de facturation à des fins de démonstration.

Les deux ensembles de données suivants ont été ajoutés à votre projet :

cluster_dataset : ensemble de données créé manuellement avant d'activer la mesure de l'utilisation de GKE sur le cluster. Cet ensemble de données contient deux tables générées par GKE (gke_cluster_resource_consumption et gke_cluster_resource_usage). Il est mis à jour en continu à l'aide des métriques d'utilisation des clusters.

billing_dataset : ensemble de données créé manuellement avant l'activation de l'exportation vers BigQuery pour la facturation. Cet ensemble de données contient une table (gcp_billing_export_v1_xxxx). Il est mis à jour quotidiennement avec les coûts journaliers d'un projet.

• Exécutez la commande suivante pour activer la mesure de l'utilisation de GKE sur le cluster et spécifier l'ensemble de données cluster_dataset :

export ZONE={{{project_0.default_zone|placeholder}}} gcloud container clusters \ update multi-tenant-cluster --zone ${ZONE} \ --resource-usage-bigquery-dataset cluster_dataset

Créer la table de répartition des coûts pour GKE

Une table de répartition des coûts peut être générée à partir des tables de facturation et d'utilisation des ressources de votre projet. Vous pouvez le faire dans l'ensemble de données du cluster à l'aide du fichier usage_metering_query_template.sql. Ce modèle est disponible sur la page Comprendre l'utilisation des ressources de cluster.

Tout d'abord, dans Cloud Shell, définissez des variables d'environnement.

1. Définissez le chemin d'accès de la table de facturation fournie, l'ensemble de données de mesure de l'utilisation fourni et un nom pour la nouvelle table de répartition des coûts :

export GCP_BILLING_EXPORT_TABLE_FULL_PATH=${GOOGLE_CLOUD_PROJECT}.billing_dataset.gcp_billing_export_v1_xxxx export USAGE_METERING_DATASET_ID=cluster_dataset export COST_BREAKDOWN_TABLE_ID=usage_metering_cost_breakdown

2. Spécifiez ensuite le chemin d'accès du modèle de requête de mesure de l'utilisation téléchargé au début de cet atelier, un fichier de sortie pour la requête qui sera générée, et une date de début pour les données (la première date étant le 26/10/2020) :

export USAGE_METERING_QUERY_TEMPLATE=~/gke-qwiklab/usage_metering_query_template.sql export USAGE_METERING_QUERY=cost_breakdown_query.sql export USAGE_METERING_START_DATE=2020-10-26

3. Générez à présent la requête de mesure de l'utilisation à l'aide des variables d'environnement ci-dessous et du modèle de requête :

sed \ -e "s/\${fullGCPBillingExportTableID}/$GCP_BILLING_EXPORT_TABLE_FULL_PATH/" \ -e "s/\${projectID}/$GOOGLE_CLOUD_PROJECT/" \ -e "s/\${datasetID}/$USAGE_METERING_DATASET_ID/" \ -e "s/\${startDate}/$USAGE_METERING_START_DATE/" \ "$USAGE_METERING_QUERY_TEMPLATE" \ > "$USAGE_METERING_QUERY"

4. Exécutez la commande suivante pour configurer votre table de répartition des coûts à l'aide de la requête exécutée à l'étape précédente :

bq query \ --project_id=$GOOGLE_CLOUD_PROJECT \ --use_legacy_sql=false \ --destination_table=$USAGE_METERING_DATASET_ID.$COST_BREAKDOWN_TABLE_ID \ --schedule='every 24 hours' \ --display_name="GKE Usage Metering Cost Breakdown Scheduled Query" \ --replace=true \ "$(cat $USAGE_METERING_QUERY)"

5. Le transfert de données doit fournir un lien d'autorisation. Cliquez dessus, connectez-vous avec votre compte étudiant, suivez les instructions et collez à nouveau la commande version_info dans Cloud Shell.

Un message indiquant que la configuration du transfert a été créée doit ensuite s'afficher.

Créer la source de données dans Data Studio

1. Ouvrez la page Sources de données de Data Studio.

2. En haut à gauche, cliquez sur Créer > Source de données pour ajouter une source de données.

La fenêtre Pour commencer, finalisez la configuration de votre compte s'affiche.

3. Sélectionnez un pays, saisissez un nom d'entreprise, cochez la case indiquant que vous avez pris connaissance des conditions, puis cliquez sur Continuer.

4. Comme il s'agit d'un compte temporaire utilisé pour cet atelier, sélectionnez Non pour chaque option des préférences relatives aux e-mails.

5. Cliquez sur Continuer.

La liste des connecteurs Google compatibles avec Data Studio s'affiche.

6. Sélectionnez BigQuery dans la liste.

7. Cliquez sur le bouton Autoriser pour que Data Studio puisse accéder à votre projet BigQuery.

8. En haut à gauche de la page, renommez votre source de données en remplaçant Source de données sans titre par Utilisation de GKE.

9. Dans la première colonne, sélectionnez REQUÊTE PERSONNALISÉE.

10. Sélectionnez votre ID de projet dans la colonne des projets.

11. Saisissez la requête suivante dans la zone de requête personnalisée, en remplaçant [PROJECT-ID] par l'ID de votre projet Qwiklabs :

SELECT * FROM `[PROJECT-ID].cluster_dataset.usage_metering_cost_breakdown`

12. Cliquez sur ASSOCIER.

Cliquez sur Vérifier ma progression pour vérifier que vous avez correctement effectué la tâche ci-dessus. Surveiller GKE et mesurer l'utilisation de GKE

13. Cliquez ensuite en haut à droite.

Maintenant que la source de données a été ajoutée, vous pouvez l'utiliser pour créer un rapport.

1. En haut de la page de votre source de données, cliquez sur CRÉER UN RAPPORT.

Remarque : Si une erreur s'affiche à ce stade, il est possible que votre job de transfert de données ne soit pas encore terminé. Patientez une minute, puis réessayez.

Lorsque vous créez un rapport à partir d'une source de données, vous devez ajouter des données à votre rapport.

2. Cliquez sur AJOUTER AU RAPPORT.

Créer un rapport Data Studio

Le rapport vous permet de visualiser les métriques d'utilisation de la source de données en fonction de votre table BigQuery.

Vous commencerez par utiliser une table simple :

Configurez cette table de façon à afficher une répartition des coûts par espace de noms. Une fois le tableau sélectionné, les données correspondantes s'affichent dans le panneau de droite.

1. Cliquez sur "Mise en page au format libre" ou sur Ajouter un graphique, sélectionnez "Tableau" et modifiez les paramètres suivants dans le panneau :

• Dimension associée à la plage de données : usage_start_time
• Dimension : namespace
• Métrique : cost

Conservez les valeurs par défaut dans les autres champs.

Pour limiter votre table aux ressources d'espace de noms, vous pouvez appliquer un filtre.

2. Dans le panneau des données, cliquez sur Ajouter un filtre dans la section "Filtre". Créez un filtre pour exclure les ressources non allouées à un espace de noms :

3. Cliquez sur Enregistrer.

4. Cliquez à nouveau sur Ajouter un filtre, puis sur Créer un filtre pour créer un second filtre permettant de limiter les données aux requêtes :

5. Cliquez sur Enregistrer pour appliquer le filtre. La table obtenue doit se présenter comme suit :

Ajoutez ensuite à votre rapport un graphique à secteurs présentant la répartition des coûts par espace de noms.

6. Cliquez avec le bouton droit sur la table que vous avez créée, puis sélectionnez Dupliquer.

7. Faites glisser l'objet de table dupliquée n'importe où dans votre rapport.

8. Cliquez ensuite sur l'en-tête Types de graphiques du panneau de configuration :

9. Dans les options affichées, cliquez sur l'icône de graphique à secteurs :

Le graphique à secteurs obtenu ressemblera à ceci :

Ajoutez maintenant un graphique en anneau qui indique la répartition des coûts par type de ressource.

1. Dans la barre d'outils située en haut, cliquez sur Ajouter un graphique, puis sélectionnez  pour créer un graphique en anneau.

2. Faites glisser le graphique où vous le souhaitez dans votre rapport et configurez-le comme suit :

• Dimension associée à la plage de données : usage_start_time
• Dimension : resource_name
• Métrique : cost

3. Cliquez sur Ajouter un filtre, puis sélectionnez les deux filtres appliqués au graphique précédent. Le graphique en anneau obtenu se présentera comme suit :

4. Pour ajouter une répartition par espace de noms, cliquez sur Ajouter une commande dans la barre d'outils du haut, puis sélectionnez Liste déroulante.

5. Faites-la glisser à côté du graphique en anneau et configurez-la comme suit :

• Dimension associée à la plage de données : usage_start_time
• Champ de commande : namespace
• Métrique : None

6. Cliquez sur Ajouter un filtre.

7. Sélectionnez non allouées (filtre espace de noms) dans la liste.

8. Pour configurer la commande afin qu'elle n'affecte que le graphique en anneau, sélectionnez l'objet de commande et le graphique à l'aide du curseur de sélection, afin de dessiner un rectangle autour des deux objets.

9. Effectuez un clic droit et sélectionnez Grouper pour les lier à un groupe :

10. Pour prévisualiser votre rapport, cliquez sur Afficher dans la barre d'outils supérieure.

Dans ce mode, vous pouvez régler l'affichage de votre graphique en anneau sur un espace de noms spécifique :

11. Dans le menu Partager en haut de la page, cliquez sur Télécharger le rapport pour récupérer une copie du rapport complet au format PDF.

Félicitations !

Les espaces de noms permettent de configurer des clusters mutualisés, de minimiser les risques de sous-utilisation des ressources et de prolifération de clusters, et d'éviter les coûts supplémentaires. Grâce à la surveillance et à la mesure de l'utilisation de GKE, vous pouvez également visualiser l'utilisation des ressources par espace de noms et optimiser la configuration de vos quotas de ressources et de vos clusters.

Étapes suivantes et informations supplémentaires

• Documentation sur l'architecture de cluster mutualisée
• Bonnes pratiques pour l'exécution d'applications Kubernetes à coût maîtrisé sur GKE

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 : 18 mars 2026

Dernier test de l'atelier : 18 mars 2026

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