Présentation

Bienvenue dans Anthos !

Kubernetes est la norme de facto pour l'orchestration de conteneurs, et Google Kubernetes Engine (GKE) est un leader dans le domaine des solutions Kubernetes gérées. En 2018, Google a déployé Kubernetes dans les centres de données grâce à une nouvelle solution dénommée Anthos, une extension gérée et certifiée de la plate-forme cloud GKE.

En réponse aux premiers résultats positifs et en tenant compte des besoins des clients, Google a élargi son offre afin de faciliter votre modernisation.

Anthos est une plate-forme moderne de gestion d'applications annoncée par Google lors de la conférence Next 2019. Cette plate-forme fournit les outils et la technologie dont vous avez besoin pour créer des solutions modernes, hybrides et multicloud à partir des principes de base de GKE. Anthos comporte plusieurs fonctionnalités, dont les suivantes :

• Provisionnement d'infrastructure à la fois dans le cloud et sur site
• Outils de gestion de l'infrastructure, sécurité, règles et solutions de conformité
• Développement simplifié des applications, détection de services et télémétrie, gestion des services et migration des charges de travail sur site vers le cloud

Dans cet atelier, vous allez déployer des clusters Anthos sur AWS. Notez qu'Anthos offre un certain nombre d'autres options de déploiement, comme les clusters Anthos sur bare metal, les clusters Anthos sur VMware et les clusters Anthos sur Azure. De plus, vous allez utiliser des clusters associés, qui sont des clusters Kubernetes tiers enregistrés dans votre parc.

Objectifs

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

• Créer et enregistrer un cluster Anthos GKE sur Google Cloud

• Créer et enregistrer un cluster Anthos sur AWS

• Accéder au cluster Anthos sur AWS à l'aide de la passerelle Connect

• Examiner les configurations de cluster pour AWS et Google Cloud à l'aide de l'interface GKE de la console Google Cloud

• Déployer des charges de travail et des services dans des clusters Anthos sur Google Cloud et AWS

• Obtenir des informations sur votre déploiement multicloud à l'aide du tableau de bord Anthos de la console Google Cloud

Architecture de l'atelier

Prérequis

Dans cette tâche, vous allez utiliser Qwiklabs pour initialiser votre atelier.

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.

8. Cliquez sur Sélectionner un projet, puis mettez en surbrillance l'ID de votre projet Google Cloud. Enfin, cliquez sur Ouvrir pour sélectionner le projet.

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 : Configurer votre projet

Pour accéder à certains types de ressources dans Google Cloud, vous devez d'abord activer quelques API. Celles-ci sont activées automatiquement lorsque vous accédez pour la première fois à un service via l'interface utilisateur ou la ligne de commande. Pour simplifier le processus et réduire les invites utilisateur, vous devez activer explicitement les API nécessaires.

1. Dans Cloud Shell, configurez les variables d'environnement suivantes, qui seront utilisées dans les scripts de l'atelier :

   export PROJECT_ID=$(gcloud config get-value project) export GCP_CLUSTER_NAME=gcp-cluster export GCP_CLUSTER_ZONE=us-central1-b

2. Dans Cloud Shell, activez les API nécessaires pour effectuer les tâches de l'atelier :

   gcloud services enable \ gkemulticloud.googleapis.com \ connectgateway.googleapis.com \ cloudresourcemanager.googleapis.com \ container.googleapis.com \ gkeconnect.googleapis.com \ gkehub.googleapis.com \ serviceusage.googleapis.com \ anthos.googleapis.com \ logging.googleapis.com \ monitoring.googleapis.com \ stackdriver.googleapis.com \ storage-api.googleapis.com \ storage-component.googleapis.com \ securetoken.googleapis.com \ sts.googleapis.com

3. Pour confirmer que ces API sont activées, dans le menu de navigation () de la console Google Cloud, cliquez sur API et services.

Tâche 2 : Commencer la configuration de votre cluster GKE (sur Google Cloud)

• Pour créer votre cluster, exécutez la commande suivante dans Cloud Shell :

  gcloud container clusters create $GCP_CLUSTER_NAME \ --zone $GCP_CLUSTER_ZONE \ --machine-type "n1-standard-2" \ --enable-ip-alias \ --num-nodes=2 \ --workload-pool=$PROJECT_ID.svc.id.goog \ --release-channel=regular \ --project=$PROJECT_ID

  L'installation de votre cluster GKE devrait commencer. La création du cluster prend environ cinq minutes. Vous pouvez donc passer à la tâche suivante pendant que l'installation se poursuit en arrière-plan.

Tâche 3 : Examiner les ressources AWS provisionnées et préparer l'environnement

Dans cet atelier, l'architecture de cloud privé virtuel (VPC) AWS suivante a été provisionnée afin de vous permettre d'exécuter des clusters Anthos sur AWS. Consultez la documentation Créer un VPC AWS pour savoir comment reproduire la procédure de configuration.

Le VPC AWS a été déployé dans us-east-1 et utilise la plage CIDR d'adresses IP 10.0.0.0/16. Il contient les ressources suivantes :

• Trois sous-réseaux privés dans trois zones de disponibilité différentes : us-east-1a, us-east-1b et us-east-1c
  • Par la suite, vous allez déployer les nœuds du plan de contrôle, les points de terminaison de l'équilibreur de charge et les nœuds de calcul du cluster dans ces sous-réseaux.
• Trois sous-réseaux publics dans les mêmes zones de disponibilité que les sous-réseaux privés
  • Une passerelle NAT dans chaque sous-réseau public pour fournir un accès Internet sortant aux sous-réseaux privés et aux points de terminaison publics de l'équilibreur de charge
  • Une passerelle Internet qui crée une route depuis les sous-réseaux publics afin d'établir la connectivité Internet

Tous les sous-réseaux sont tagués pour la détection automatique de sous-réseaux. Ainsi, lorsque vous créez un service Kubernetes, un équilibreur de charge AWS peut être provisionné dans ces réseaux. Les équilibreurs de charge internes sont provisionnés dans les sous-réseaux privés, et les équilibreurs de charge Web dans les sous-réseaux publics. Le tag utilisé détermine le type d'équilibreur de charge.

Examiner les ressources lancées dans la console AWS

1. Sur la page d'instructions de Qwiklabs, effectuez un clic droit sur le bouton d'URL de la console AWS, puis sélectionnez Ouvrir le lien dans la fenêtre de navigation privée (ou tout autre élément équivalent dans votre navigateur).

2. Connectez-vous à l'aide des identifiants AWS Username (Nom d'utilisateur AWS) et AWS Password (Mot de passe AWS) fournis par Qwiklabs.

3. Dans la barre de recherche de la fenêtre de la console, saisissez vpc et appuyez sur ENTRÉE.

   Toutes les ressources réseau AWS qui ont été déployées sont affichées dans un tableau de bord.

   

4. (Facultatif) Examinez les ressources créées et vérifiez qu'elles correspondent au schéma de l'architecture de l'atelier présenté dans la section Objectifs de ce guide. Vous verrez peut-être d'autres ressources qu'AWS crée dans chaque nouveau compte, mais vous pouvez les ignorer.

Notez les réponses à ces questions :

• Quelles sont les plages CIDR d'adresses IP associées aux sous-réseaux privés ?
• Quels sont les tags associés aux sous-réseaux ?
• Quelles sont les adresses IP Elastic associées aux passerelles NAT ?

Configurer la CLI AWS

1. Dans la console Google Cloud, ouvrez un nouvel onglet Cloud Shell.

2. Dans cet onglet, configurez l'ID du projet comme variable d'environnement :

   export PROJECT_ID=$(gcloud config get-value project) gcloud config set project $PROJECT_ID

3. Téléchargez et installez l'interface de ligne de commande AWS :

   curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" unzip awscliv2.zip sudo ./aws/install

4. Configurez la CLI AWS :

   aws configure

5. Lorsque vous y êtes invité, saisissez les valeurs suivantes :

   Propriété	Valeur
   AWS Access Key ID (ID de clé d'accès AWS)
   AWS Secret Access Key (Clé d'accès secrète AWS)
   Default region name (Nom de la région par défaut)	us-east-1
   Default output format (Format de sortie par défaut)	json

    

Obtenir les ID AWS

1. Initialisez les variables d'environnement avec les références aux ressources AWS :

   AWS_CLUSTER=aws-cluster AWS_REGION=us-east-1 VPC=${AWS_CLUSTER}-anthos-vpc PRIVATE_SUBNET_1=${VPC}-private-cp-us-east-1a PRIVATE_SUBNET_2=${VPC}-private-cp-us-east-1b PRIVATE_SUBNET_3=${VPC}-private-cp-us-east-1c CONTROL_PLANE_PROFILE=${AWS_CLUSTER}-anthos-cp-instance-profile NODE_POOL_IAM_INSTANCE_PROFILE=aws-cluster-anthos-np-instance-profile

2. Récupérez le VPC AWS et les sous-réseaux, puis stockez leurs identifiants :

   VPC_ID=`aws ec2 describe-vpcs \ --filters Name=tag:Name,Values=$VPC \ --query Vpcs[].VpcId --output text` PRIVATE_SUBNET_ID_1=`aws ec2 describe-subnets \ --filters Name=tag:Name,Values=$PRIVATE_SUBNET_1 \ --query "Subnets[].SubnetId" --output text` PRIVATE_SUBNET_ID_2=`aws ec2 describe-subnets \ --filters Name=tag:Name,Values=$PRIVATE_SUBNET_2 \ --query "Subnets[].SubnetId" --output text` PRIVATE_SUBNET_ID_3=`aws ec2 describe-subnets \ --filters Name=tag:Name,Values=$PRIVATE_SUBNET_3 \ --query "Subnets[].SubnetId" --output text`

3. Récupérez les rôles de l'API AWS qu'utilisera l'API Anthos Multi-Cloud pour créer et gérer les clusters et les pools de nœuds :

   API_ROLE_ARN=$(aws iam list-roles \ --query 'Roles[?RoleName==`aws-cluster-anthos-api-role`].Arn' \ --output text)

   Ce rôle dispose d'une règle associée à des autorisations de gérer AWS Key Management Service (KMS), Elastic Compute Cloud (EC2), Auto Scaling, Elastic Load Balancing (ELB) et Identity and Access Management (IAM).

4. Récupérez les clés d'AWS Key Management Service (KMS) :

   ENCRYPTION_KEY=$(aws kms describe-key \ --key-id alias/aws-cluster-database-encryption-key \ --query 'KeyMetadata.Arn' --output text)

   Les clusters Anthos sur AWS nécessitent deux clés KMS AWS. Dans cet atelier, vous vous servirez de la même clé pour les deux cas d'utilisation. Les clés KMS assurent le chiffrement :

   • des données pendant le processus d'installation avec le chiffrement encapsulé ;
   • des secrets de la couche d'application dans vos clusters d'utilisateurs.

Tâche 4 : Créer le cluster Anthos sur AWS

1. Créez le cluster Anthos sur AWS :

   gcloud container aws clusters create $AWS_CLUSTER \ --cluster-version 1.24.3-gke.2100 \ --aws-region us-east-1 \ --location=us-east4 \ --fleet-project $PROJECT_ID \ --vpc-id $VPC_ID \ --subnet-ids $PRIVATE_SUBNET_ID_1,$PRIVATE_SUBNET_ID_2,$PRIVATE_SUBNET_ID_3 \ --pod-address-cidr-blocks 10.2.0.0/16 \ --service-address-cidr-blocks 10.1.0.0/16 \ --role-arn $API_ROLE_ARN \ --iam-instance-profile $CONTROL_PLANE_PROFILE \ --database-encryption-kms-key-arn $ENCRYPTION_KEY \ --config-encryption-kms-key-arn $ENCRYPTION_KEY \ --tags google:gkemulticloud:cluster=$AWS_CLUSTER

   Vous remarquerez que la plage CIDR d'adresses IP 10.1.0.0/16 est utilisée pour les services ClusterIP de Kubernetes et que la plage CIDR d'adresses IP 10.2.0.0/16 est utilisée pour les pods Kubernetes. Ces plages CIDR font partie du VPC AWS que vous avez créé, mais pas des sous-réseaux. Les sous-réseaux hébergent les nœuds du cluster.

Félicitations ! Vous avez commencé à créer un cluster Anthos sur AWS. Ce processus prend environ cinq minutes.

2. En attendant que le cluster soit provisionné, accédez à l'onglet de la console AWS dans votre navigateur et notez les VM créées.

Notez les réponses à ces questions :

• Combien de VM ont été créées pour le plan de contrôle de votre cluster d'utilisateur (vous devrez peut-être attendre une minute et actualiser pour voir les VM) ?
• Dans quelles zones se trouvent les nœuds du plan de contrôle ?

3. Sur le côté gauche de la console AWS, faites défiler la page jusqu'à Load Balancing (Équilibrage de charge), puis sélectionnez Load Balancers (Équilibreurs de charge).

Notez les réponses à ces questions :

• Combien d'équilibreurs de charge ont été créés ?
• À quoi sert chacun d'entre eux ?

4. Revenez à l'onglet Cloud Shell que vous avez ouvert dans le navigateur et lorsque la commande a terminé, générez une clé privée asymétrique, puis importez sa clé publique dans AWS :

   ssh-keygen -t rsa -m PEM -b 4096 -C "$USER" \ -f SSH_PRIVATE_KEY -N "" 1>/dev/null aws ec2 import-key-pair --key-name SSH_KEY_PAIR_NAME \ --public-key-material fileb://SSH_PRIVATE_KEY.pub

   À l'étape suivante, vous allez les associer aux instances de pool de nœuds EC2 afin de pouvoir vous y connecter en SSH par la suite.

5. Ajoutez un pool de nœuds au cluster :

   gcloud container aws node-pools create pool-0 \ --cluster $AWS_CLUSTER \ --location=us-east4 \ --node-version 1.24.3-gke.2100 \ --min-nodes 1 \ --max-nodes 5 \ --max-pods-per-node 110 \ --root-volume-size 50 \ --subnet-id $PRIVATE_SUBNET_ID_1 \ --iam-instance-profile $NODE_POOL_IAM_INSTANCE_PROFILE \ --config-encryption-kms-key-arn $ENCRYPTION_KEY \ --ssh-ec2-key-pair SSH_KEY_PAIR_NAME \ --tags google:gkemulticloud:cluster=$AWS_CLUSTER

6. Récupérez les identifiants du cluster :

   gcloud container aws clusters get-credentials $AWS_CLUSTER --location=us-east4 kubectx aws=.

7. Vérifiez les informations du cluster :

   kubectl cluster-info

   Résultat :

   Kubernetes control plane is running at https://connectgateway.googleapis.com... CoreDNS is running at https://connectgateway.googleapis.com... Metrics-server is running at https://connectgateway.googleapis.com...

   Notez que vous ne vous connectez pas directement au cluster Anthos sur AWS. Vous vous connectez par le biais de la passerelle Anthos Connect, qui transmet ensuit les requêtes de manière sécurisée au serveur d'API Kubernetes via l'agent Connect.

8. Vérifiez que vous voyez bien vos nœuds de calcul :

   kubectl get nodes

9. Pour autoriser l'agent gke-system/gke-telemetry-agent de Kubernetes Workload Identity à écrire des journaux sur Cloud Logging et des métriques sur Cloud Monitoring, exécutez cette commande :

   gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member="serviceAccount:${PROJECT_ID}.svc.id.goog[gke-system/gke-telemetry-agent]" \ --role=roles/gkemulticloud.telemetryWriter

   Les clusters Anthos sur AWS ne peuvent créer et importer des journaux système et des métriques dans la suite Google Cloud Operations que s'ils y sont autorisés.

Tâche 5 : Connecter le cluster Anthos sur AWS à la console Google Cloud

1. Dans votre navigateur, passez à l'onglet où est ouverte la console Google Cloud.

2. Dans le menu de navigation, cliquez sur Kubernetes Engine > Clusters.

3. Dans la liste des clusters, à la ligne aws-cluster, cliquez sur le menu à trois points

4. Cliquez sur Log in (Connexion), puis sélectionnez Utiliser mon identité Google pour me connecter. Enfin, cliquez sur Se connecter.

5. Cliquez sur l'entrée aws-cluster afin d'afficher les informations concernant votre cluster Anthos sur AWS.

6. Dans le menu de navigation, cliquez sur Anthos > Tableau de bord. Un cluster s'affiche.

7. Cliquez sur Afficher les clusters.

8. Cliquez sur l'entrée aws-cluster.

   Un volet "Détails" affiche les informations concernant votre cluster Anthos AWS.

Tâche 6 : Enregistrer le cluster GKE sur Anthos Hub

1. Retournez au premier onglet Cloud Shell.

2. Vérifiez que votre cluster a bien été créé. Le résultat de la commande de création initiale du cluster doit ressembler à ceci :

   NAME LOCATION MASTER_VERSION... gcp-cluster us-central1-b 1.21.5-gke.1302 ...

   Vous devrez peut-être patienter une minute ou deux avant que le cluster soit créé.

3. Pour configurer kubectx avec un nom court pour le contexte kubectl servant à gérer le cluster Google Cloud, exécutez la commande suivante :

   gcloud container clusters get-credentials gcp-cluster \ --zone us-central1-b \ --project $PROJECT_ID kubectx gcp=.

   Lors de l'enregistrement du cluster, vous pouvez configurer l'agent Connect de sorte qu'il utilise soit la fonctionnalité Workload Identity, soit un compte de service Google Cloud. Dans cet atelier, vous allez utiliser Workload Identity.

4. Enregistrez le cluster GKE sur Anthos Hub :

   gcloud beta container hub memberships register $GCP_CLUSTER_NAME \ --gke-cluster=$GCP_CLUSTER_ZONE/$GCP_CLUSTER_NAME \ --enable-workload-identity Remarque : si vous voyez le message d'erreur PERMISSION_DENIED: hub default service account does not have access (AUTORISATION REFUSÉE : le compte de service Hub par défaut n'a pas accès), patientez une minute, puis exécutez une nouvelle fois la commande. Si l'opération échoue à nouveau, répétez le cycle attente/réexécution une ou deux fois.
   Un problème connu se produit lors de l'enregistrement des clusters GKE à l'aide de Workload Identity. La première tentative échoue, mais cela fonctionne une à trois minutes plus tard.

5. Dans la console Cloud, accédez au menu de navigation, puis cliquez sur Anthos > Tableau de bord. Deux clusters disponibles doivent à présent figurer sous État du cluster.

6. Cliquez sur Afficher les clusters. Une liste contenant votre cluster GKE sur Google Cloud s'affiche.

7. Cliquez sur l'entrée gcp-cluster pour afficher les détails du cluster.

Notez la réponse à cette question : À quoi sert le bouton Gérer les fonctionnalités dans le volet "Détails" ?

Tâche 7 : Déployer des applications sur vos clusters

Effectuer un déploiement simple sur votre cluster Anthos sur Google Cloud

1. Dans votre navigateur, revenez à l'onglet Cloud Shell. Passez au premier onglet du terminal Cloud Shell, dans lequel vous avez initialement créé le cluster sur Google Cloud.

2. Assurez-vous que kubectl est configuré dans cette fenêtre de terminal pour pointer vers votre cluster Google Cloud :

   kubectx gcp

3. Créez un fichier manifeste pour le déploiement Kubernetes d'une application simple :

cat <<EOF > deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: my-deployment-50001 spec: selector: matchLabels: app: products department: sales replicas: 3 template: metadata: labels: app: products department: sales spec: containers: - name: hello image: "gcr.io/google-samples/hello-app:2.0" env: - name: "PORT" value: "50001" EOF

4. Créez le déploiement sur votre cluster Google Cloud :

   kubectl apply -f deployment.yaml

5. Dans la console Cloud, accédez à Kubernetes Engine > Charges de travail, puis vérifiez que le déploiement a bien été créé et que les pods sont en cours d'exécution.

   Vous pouvez également vérifier les pods à partir de la ligne de commande :

   kubectl get pods --selector=app=products

6. Retournez à l'onglet Cloud Shell. Créez un fichier manifeste de service Kubernetes pour votre application :

   cat <<EOF > service.yaml apiVersion: v1 kind: Service metadata: name: my-lb-service spec: type: LoadBalancer selector: app: products department: sales ports: - protocol: TCP port: 80 targetPort: 50001 EOF

7. Créez le service en exécutant la commande suivante :

   kubectl apply -f service.yaml

8. Dans la console Cloud, accédez à Kubernetes Engine > Services, puis vérifiez que le service a bien été créé et que l'adresse IP externe a été attribuée. Le service est fonctionnel après une à deux minutes.

   Vous pouvez également vérifier les pods à partir de la ligne de commande :

   kubectl get service my-lb-service

9. Une fois que le service est prêt, récupérez l'adresse IP externe de l'équilibreur de charge et chargez-la dans un nouvel onglet du navigateur. Le résultat doit ressembler à ce qui suit :

Hello, world! Version: 2.0.0 Hostname: my-deployment-50001-66f7d57555-c7j55

Effectuer un déploiement simple dans votre cluster Anthos sur AWS

Vous allez maintenant effectuer le même déploiement sur votre cluster AWS.

1. Dans le navigateur, accédez à l'onglet de Cloud Shell.

2. Passez au troisième onglet Cloud Shell, celui dans lequel vous avez créé le cluster AWS.

3. Assurez-vous que kubectl est configuré pour gérer votre cluster AWS :

   kubectx aws

4. Appliquez le fichier manifeste de déploiement et de service à ce cluster :

   kubectl apply -f ~/deployment.yaml kubectl apply -f ~/service.yaml

5. Vérifiez que le déploiement a bien été créé :

   kubectl get pods

6. Vérifiez que le service a bien été créé :

   kubectl get services

Vous pouvez également utiliser l'interface utilisateur de gestion GKE dans la console.

7. Passez à l'onglet dans lequel la console Google Cloud est affichée.

8. Dans le menu de navigation, cliquez sur Kubernetes Engine > Charges de travail.

   Une deuxième entrée my-deployment-50001 est affichée, pour aws-cluster cette fois-ci.

9. Dans le volet du menu, cliquez sur Services et entrées.

   Deux entrées my-lb-service s'affichent, une pour chaque cluster.

10. Dans la colonne Points de terminaison, cliquez sur le lien du service aws-cluster my-lb-service.

Le même message hello world que vous avez vu lorsque vous avez déployé gcp-cluster doit s'afficher. Si vous rencontrez une erreur, patientez une ou deux minutes le temps que la configuration de l'équilibreur de charge dans AWS soit terminée, puis réessayez.

Tâche 8 : Nettoyer l'environnement

1. Supprimez les ressources Kubernetes du cluster Anthos sur AWS :

kubectx aws kubectl delete -f ~/deployment.yaml kubectl delete -f ~/service.yaml

2. Supprimez le pool de nœuds du cluster Anthos sur AWS :

gcloud container aws node-pools delete pool-0 --cluster aws-cluster --location=us-east4

3. Saisissez Y et appuyez sur Entrée pour confirmer.

4. Supprimez votre cluster Anthos sur AWS :

gcloud container aws clusters delete aws-cluster --location=us-east4

5. Saisissez Y et appuyez sur Entrée pour confirmer.

6. Supprimez le cluster GKE :

gcloud container clusters delete gcp-cluster --zone us-central1-b

7. Saisissez Y et appuyez sur Entrée pour confirmer.

Félicitations !

Dans cet atelier, vous avez créé et enregistré des clusters Anthos GKE sur Google Cloud et AWS. Vous avez géré des clusters à l'aide de la CLI et de la console Google Cloud. Vous avez déployé des charges de travail à l'aide des commandes kubectl standards sur les deux clusters.

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.