Créer des clusters d'administrateur et d'utilisateur GKE sur Bare Metal sur des VM Compute Engine

Cette page explique comment créer un cluster d'utilisateur GKE sur Bare Metal et un cluster d'administrateur sur des machines virtuelles (VM) Compute Engine. Le script fourni crée des VM Compute Engine pour les nœuds des clusters d'administrateur et d'utilisateur, ainsi qu'un poste de travail administrateur.

Le poste de travail administrateur héberge des outils d'interface de ligne de commande (CLI) et des fichiers de configuration permettant de provisionner les clusters lors de l'installation, ainsi que des outils d'interface de ligne de commande permettant d'interagir avec les clusters provisionnés après l'installation. Le script installe les outils CLI sur la VM du poste de travail administrateur.

Un cluster d'utilisateur est un cluster Kubernetes qui exécute vos charges de travail conteneurisées. Il se compose de nœuds de plan de contrôle et de nœuds de calcul. Les clusters d'utilisateur doivent contenir un ou plusieurs nœuds de calcul qui exécutent les charges de travail utilisateur. Un cluster d'administrateur est un cluster Kubernetes qui gère un ou plusieurs clusters d'utilisateur et facilite la création, la mise à jour et la suppression de clusters d'utilisateur. Un cluster d'administrateur ne comporte que des nœuds de plan de contrôle. Pour en savoir plus, consultez Déploiement de clusters d'administrateur et d'utilisateurs.

Le script configure un réseau superposé virtuel (VXLAN) entre les VM et prépare les VM pour la création du cluster. Le script peut également créer un cluster d'administrateur, ou vous pouvez choisir de créer vous-même le cluster d'administrateur pour en savoir plus sur les outils fournis par Google Distributed Cloud pour créer des clusters d'administrateur.

Le script fourni vous permet d'essayer Google Distributed Cloud rapidement et sans avoir à préparer de matériel. En suivant les étapes de cette page, vous disposez d'un environnement de test Google Distributed Cloud opérationnel s'exécutant sur Compute Engine.

Important : Ce déploiement n'est fourni qu'à des fins d'évaluation. N'exécutez pas Google Distributed Cloud sur des VM Compute Engine en production.

Qu'est-ce que l'API GKE On-Prem ?

L'API GKE On-Prem est une API hébergée par Google Cloud qui vous permet de gérer le cycle de vie de vos clusters sur site à l'aide de Terraform et des applications Google Cloud standards. L'API GKE On-Prem s'exécute dans l'infrastructure de Google Cloud. Terraform, la console et gcloud CLI sont des clients de l'API qui l'utilisent pour créer des clusters dans votre centre de données.

Pour gérer le cycle de vie de vos clusters, l'API GKE On-Prem doit stocker des métadonnées sur l'état de votre cluster dans Google Cloud, en utilisant la région Google Cloud que vous spécifiez lors de la création du cluster. Ces métadonnées permettent à l'API de gérer le cycle de vie du cluster et n'incluent pas les données spécifiques aux charges de travail.

Lorsque vous créez un cluster à l'aide d'un client API GKE On-Prem, vous spécifiez un projet Google Cloud. Une fois le cluster créé, il est automatiquement enregistré dans le parc du projet spécifié. Ce projet est appelé projet hôte du parc. Une fois le cluster créé, le projet hôte du parc ne peut plus être modifié.

Avant de commencer

1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

3. Vérifiez que la facturation est activée pour votre projet Google Cloud.

4. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

5. Vérifiez que la facturation est activée pour votre projet Google Cloud.

6. Notez l'ID de projet, car vous en aurez besoin pour définir une variable d'environnement qui sera utilisée dans le script et les commandes de cette page. Si vous avez sélectionné un projet existant, assurez-vous d'en être le propriétaire ou l'éditeur.
7. Vous pouvez exécuter le script sur Cloud Shell, ou sur votre ordinateur local exécutant Linux ou macOS. Si vous n'utilisez pas Cloud Shell :
   1. Assurez-vous d'avoir installé la dernière version de Google Cloud CLI, l'outil de ligne de commande permettant d'interagir avec Google Cloud. Mettez à jour les composants de la gcloud CLI, si nécessaire :

      gcloud components update

      Selon la manière dont la gcloud CLI a été installée, le message suivant peut s'afficher: "Vous ne pouvez pas effectuer cette action, car le gestionnaire de composants de la CLI gcloud est désactivé pour cette installation. Vous pouvez exécuter la commande suivante pour obtenir le même résultat pour cette installation:" Suivez les instructions pour copier et coller la commande afin de mettre à jour les composants.

   2. Assurez-vous que kubectl est installé. Si vous devez installer kubectl, exécutez la commande suivante :

      gcloud components install kubectl

Créer l'infrastructure de la VM et, éventuellement, le cluster d'administrateur

Procédez comme suit pour configurer et exécuter le script. Le script que vous téléchargez et exécutez provient du dépôt anthos-samples. Si vous souhaitez en savoir plus sur le script avant de l'exécuter, consultez la section suivante, À propos du script.

1. Configurez des variables d'environnement :

   export PROJECT_ID=PROJECT_ID
   export ADMIN_CLUSTER_NAME=ADMIN_CLUSTER_NAME
   export ON_PREM_API_REGION=ON_PREM_API_REGION
   export ZONE=ZONE
   

   • ON_PREM_API_REGION: région Google Cloud dans laquelle l'API GKE On-Prem s'exécute et stocke ses métadonnées. Spécifiez us-central1 ou une autre région compatible.

   • ZONE: zone Google Cloud dans laquelle les VM Compute Engine seront créées. Vous pouvez utiliser us-central1-a ou n'importe quelle autre zone Compute Engine.

2. Définissez le projet et la zone par défaut :

   gcloud config set project $PROJECT_ID
   gcloud config set compute/zone $ZONE
   

   Si vous obtenez une erreur PERMISSION_DENIED, vérifiez l'ID de projet que vous avez saisi. Si l'ID du projet est correct, exécutez gcloud auth login pour vous connecter à la gcloud CLI avec le compte ayant accès au projet.

3. Obtenez la liste des versions de Google Distributed Cloud que vous pouvez installer:

   gcloud container bare-metal admin-clusters query-version-config \
       --location=ON_PREM_API_REGION
   

   Certaines instructions de ce document dépendent de l'API GKE On-Prem, qui prend en charge un sous-ensemble de versions Google Distributed Cloud disponibles.

4. Sélectionnez une version dans le résultat de la commande précédente et définissez-la dans une variable d'environnement:

   export BMCTL_VERSION=BMCTL_VERSION
   

   Nous vous recommandons de sélectionner la version compatible la plus élevée pour obtenir les dernières fonctionnalités et correctifs Google Distributed Cloud.

5. Clonez le dépôt anthos-samples et accédez au répertoire dans lequel se trouve le script:

   git clone https://github.com/GoogleCloudPlatform/anthos-samples
   cd anthos-samples/anthos-bm-gcp-bash
   

6. Exécutez le script :

   bash install_admin_cluster.sh
   

7. Lorsque vous y êtes invité, saisissez un nombre pour choisir le mode d'installation:

   • Saisissez 1 pour que le script configure l'infrastructure de la VM et installe le cluster d'administrateur.
   • Saisissez 2 pour que le script ne configure que l'infrastructure de VM.

8. Lorsque vous y êtes invité, confirmez votre sélection.

Le script affiche chaque commande exécutée ainsi que son état. Une fois l'opération terminée, le script affiche ce qui suit selon que vous avez choisi d'installer ou non le cluster d'administrateur:

Cluster d'administrateur créé

✅ Installation complete. Please check the logs for any errors!!!
✅ If you do not see any errors in the output log, then you now have the following setup:

|---------------------------------------------------------------------------------------------------------|
| VM Name               | L2 Network IP (VxLAN) | INFO                                                    |
|---------------------------------------------------------------------------------------------------------|
| abm-admin-cluster-cp1 | 10.200.0.3            | Has control plane of admin cluster running inside       |
| abm-user-cluster-cp1  | 10.200.0.4            | 🌟 Ready for use as control plane for the user cluster  |
| abm-user-cluster-w1   | 10.200.0.5            | 🌟 Ready for use as worker for the user cluster         |
| abm-user-cluster-w2   | 10.200.0.6            | 🌟 Ready for use as worker for the user cluster         |
|---------------------------------------------------------------------------------------------------------|

Configurer uniquement les VM

|---------------------------------------------------------------------------------------------------------|
| VM Name               | L2 Network IP (VxLAN) | INFO                                                    |
|---------------------------------------------------------------------------------------------------------|
| abm-admin-cluster-cp1 | 10.200.0.3            | 🌟 Ready for use as control plane for the admin cluster |
| abm-user-cluster-cp1  | 10.200.0.4            | 🌟 Ready for use as control plane for the user cluster  |
| abm-user-cluster-w1   | 10.200.0.5            | 🌟 Ready for use as worker for the user cluster         |
| abm-user-cluster-w2   | 10.200.0.6            | 🌟 Ready for use as worker for the user cluster         |
|---------------------------------------------------------------------------------------------------------|

À propos du script

Pour en savoir plus sur install_admin_cluster.sh, cliquez sur À propos du script sur la ligne suivante.

À propos du script

Le script automatise les étapes manuelles suivantes:

1. Il crée un compte de service appelé baremetal-gcr et lui accorde des autorisations supplémentaires pour éviter d'avoir besoin de plusieurs comptes de service pour différents services et API.
2. Active les API Google Cloud suivantes :

     anthos.googleapis.com
     anthosaudit.googleapis.com
     anthosgke.googleapis.com
     cloudresourcemanager.googleapis.com
     connectgateway.googleapis.com
     container.googleapis.com
     gkeconnect.googleapis.com
     gkehub.googleapis.com
     gkeonprem.googleapis.com
     iam.googleapis.com
     logging.googleapis.com
     monitoring.googleapis.com
     opsconfigmonitoring.googleapis.com
     serviceusage.googleapis.com
     stackdriver.googleapis.com
     storage.googleapis.com

3. Il crée les VM suivantes :
   • Une VM pour le poste de travail administrateur. Le poste de travail administrateur aura accès à tous les autres nœuds du cluster à l'aide de SSH.
   • Une VM pour le nœud de plan de contrôle du cluster d'administrateur
   • Deux VM pour les nœuds de calcul du cluster d'utilisateur.
   • Une VM pour le nœud de plan de contrôle du cluster d'utilisateur.
   Le script vérifie également que SSH est activé sur toutes les VM.
4. Crée un réseau superposé virtuel VXLAN (Virtual Extensible LAN) pour assurer une connectivité de couche 2 entre les VM. Le VXLAN n'est pas persistant. Par conséquent, si vous redémarrez une instance de VM, le réseau est détruit. Le réseau est configuré pour se trouver sur le sous-réseau 10.200.0.0/24. La connectivité de couche 2 est requise pour l'équilibreur de charge groupé.
5. Installe les outils suivants sur le poste de travail administrateur :
   • bmctl
   • kubectl
   • Docker

   Le script télécharge également la clé associée au compte de service baremetal-gcr sur le poste de travail administrateur.

6. Elle s'assure que root@10.200.0.x du poste de travail administrateur fonctionne en effectuant les tâches suivantes :
   1. Générez une nouvelle clé SSH sur le poste de travail administrateur.
   2. Ajoute la clé publique à toutes les autres VM du déploiement.
7. Le script peut éventuellement créer le cluster d'administrateur avec le fichier de configuration suivant:

     gcloud compute ssh root@"$VM_WS" --zone "${ZONE}" <<EOF
   set -x
   export PROJECT_ID=\$(gcloud config get-value project)
   ADMIN_CLUSTER_NAME=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/cluster_id -H "Metadata-Flavor: Google")
   BMCTL_VERSION=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/bmctl_version -H "Metadata-Flavor: Google")
   export ADMIN_CLUSTER_NAME
   export BMCTL_VERSION
   bmctl create config -c \$ADMIN_CLUSTER_NAME
   cat > bmctl-workspace/\$ADMIN_CLUSTER_NAME/\$ADMIN_CLUSTER_NAME.yaml << EOB
   ---
   gcrKeyPath: /root/bm-gcr.json
   sshPrivateKeyPath: /root/.ssh/id_rsa
   gkeConnectAgentServiceAccountKeyPath: /root/bm-gcr.json
   gkeConnectRegisterServiceAccountKeyPath: /root/bm-gcr.json
   cloudOperationsServiceAccountKeyPath: /root/bm-gcr.json
   ---
   apiVersion: v1
   kind: Namespace
   metadata:
     name: cluster-\$ADMIN_CLUSTER_NAME
   ---
   apiVersion: baremetal.cluster.gke.io/v1
   kind: Cluster
   metadata:
     name: \$ADMIN_CLUSTER_NAME
     namespace: cluster-\$ADMIN_CLUSTER_NAME
   spec:
     type: admin
     anthosBareMetalVersion: \$BMCTL_VERSION
     gkeConnect:
       projectID: \$PROJECT_ID
     controlPlane:
       nodePoolSpec:
         clusterName: \$ADMIN_CLUSTER_NAME
         nodes:
         - address: 10.200.0.3
     clusterNetwork:
       pods:
         cidrBlocks:
         - 192.168.0.0/16
       services:
         cidrBlocks:
         - 10.96.0.0/20
     loadBalancer:
       mode: bundled
       ports:
         controlPlaneLBPort: 443
       vips:
         controlPlaneVIP: 10.200.0.48
     clusterOperations:
       # might need to be this location
       location: us-central1
       projectID: \$PROJECT_ID
     storage:
       lvpNodeMounts:
         path: /mnt/localpv-disk
         storageClassName: node-disk
       lvpShare:
         numPVUnderSharedPath: 5
         path: /mnt/localpv-share
         storageClassName: local-shared
     nodeConfig:
       podDensity:
         maxPodsPerNode: 250
   EOB
   
   bmctl create cluster -c \$ADMIN_CLUSTER_NAME
   EOF

   Si vous avez choisi de laisser le script créer le cluster d'administrateur, il utilise SSH pour se connecter au poste de travail administrateur en tant qu'utilisateur racine. Ensuite, le script exécute l'outil de ligne de commande bmctl pour créer le cluster d'administrateur. C'est l'un des outils que vous pouvez utiliser pour créer des clusters d'administrateur.

   Lorsque Google Distributed Cloud crée des clusters, il déploie un cluster Kubernetes dans un cluster Docker (genre) sur le poste de travail administrateur. Ce cluster d'amorçage héberge les contrôleurs Kubernetes nécessaires à la création de clusters et permet de créer le cluster d'administrateur. Lors de leur création, les contrôleurs concernés sont déplacés du cluster d'amorçage vers le cluster d'administrateur. Enfin, sauf indication contraire de votre part, le cluster d'amorçage est supprimé une fois la création du cluster terminée. Le cluster d'amorçage nécessite que Docker puisse extraire les images de conteneurs.

Créer le cluster d'administrateur (facultatif)

Si le script a créé le cluster d'administrateur, passez à la section suivante, Vérifier le cluster d'administrateur. Sinon, suivez les étapes de cette section pour créer un cluster d'amorçage et le cluster d'administrateur.

Avant de créer le cluster d'administrateur, vous devez exécuter la commande bmctl register bootstrap sur votre poste de travail administrateur. Cette commande déploie un cluster Kubernetes temporaire dans Docker (kind) sur le poste de travail administrateur. Ce cluster d'amorçage héberge les contrôleurs Kubernetes nécessaires à la création du cluster d'administrateur. Lorsque vous créez le cluster d'administrateur, les contrôleurs du cluster d'amorçage provisionnent les nœuds, exécutent les vérifications préliminaires et enregistrent le cluster d'administrateur dans le parc. Le cluster d'amorçage est automatiquement supprimé une fois le cluster créé.

Console

1. Dans la console, accédez à la page Créer un cluster GKE sur Bare Metal.

   Accéder à la page Créer un cluster GKE sur Bare Metal

2. Veillez à sélectionner PROJECT_ID dans la liste des projets.

3. Dans la barre de navigation de gauche, cliquez sur Install bootstrap environment (Installer l'environnement d'amorçage).

4. Saisissez ADMIN_CLUSTER_NAME comme nom de cluster d'administrateur. Notez que le nom du cluster d'amorçage est obtenu en ajoutant bootstrap- au nom du cluster d'administrateur.

5. Sélectionnez VERSION comme version de votre cluster d'administrateur. Le script a téléchargé cette version de l'outil de ligne de commande bmctl sur le poste de travail administrateur. La version Google Distributed Cloud que vous installez doit correspondre à la version bmctl.

6. Dans le champ Emplacement de l'API Google Cloud, sélectionnez ON_PREM_API_REGION dans la liste. Ce paramètre spécifie la région dans laquelle l'API GKE On-Prem s'exécute et la région dans laquelle les éléments suivants sont stockés:

   • Les métadonnées du cluster dont l'API GKE On-Prem a besoin pour gérer son cycle de vie
   • Données Cloud Logging et Cloud Monitoring des composants système
   • Journal d'audit d'administrateur créé par Cloud Audit Logs

   Le nom, le projet et l'emplacement du cluster identifient de manière unique le cluster dans Google Cloud.

Suivez les étapes de la section suivante au lieu de celles affichées dans la console pour créer le cluster d'amorçage. Laissez la page de la console affichée, car vous y reviendrez pour créer le cluster d'administrateur.

gcloud CLI

Ouvrez une nouvelle fenêtre de terminal. Vous utiliserez la deuxième fenêtre de terminal pour vous connecter au poste de travail administrateur afin de créer le cluster d'amorçage. Vous utiliserez la première fenêtre de terminal pour exécuter la commande de gcloud CLI afin de créer le cluster d'administrateur.

Créer le cluster d'amorçage

Procédez comme suit sur votre poste de travail administrateur.

1. Utilisez SSH pour accéder au poste de travail administrateur en tant que racine:

   gcloud compute ssh root@abm-ws --zone ZONE
   

   Vous pouvez ignorer les messages concernant la mise à jour de la VM et suivre ce tutoriel. Si vous envisagez de conserver les VM en tant qu'environnement de test, vous pouvez mettre à jour l'OS ou passer à la version suivante, comme décrit dans la documentation d'Ubuntu.

2. Définissez vos identifiants utilisateur comme Identifiants par défaut de l'application (ADC):

   gcloud auth application-default login
   

   Suivez les instructions pour sélectionner votre compte Google pour les appels par centres d'intérêt.

3. Créez le cluster d'amorçage.

   bmctl register bootstrap \
     --ssh-key=/root/.ssh/id_rsa \
     --name=bootstrap-ADMIN_CLUSTER_NAME \
     --project-id=PROJECT_ID
   

Une fois que bmctl a créé le cluster d'amorçage, un résultat semblable aux lignes suivantes s'affiche:

[2023-03-22 17:35:24+0000] Waiting for the temporary cluster to be registered... OK
[2023-03-22 17:35:37+0000] Please go to https://console.cloud.google.com/home/dashboard?project=example-project-12345 to create the cluster
[2023-03-22 17:35:37+0000] Waiting for preflight checks and cluster to run..

Attention :Laissez la commande s'exécuter pendant la création du cluster d'administrateur. Si vous quittez la commande bmctl register bootstrap avant la création du cluster d'administrateur, celle-ci échoue. Une fois le cluster créé, la commande supprime automatiquement le cluster d'amorçage et se ferme.

Créer le cluster d'administrateur

Console

1. Sur la page Installer l'environnement d'amorçage de la section Environnement d'amorçage depuis le poste de travail administrateur, cliquez sur Vérifier la connexion.

   Si l'opération réussit, la console affiche Connexion établie.

   Vous devez établir la connexion au cluster d'amorçage avant de continuer. Si la connexion n'est pas établie, vérifiez les arguments que vous avez spécifiés dans la commande bmctl register bootstrap:

   • Assurez-vous que la valeur de --name correspond au nom d'amorçage dérivé affiché dans la section Principes de base de l'environnement d'amorçage.

   • Assurez-vous que la valeur de --project-id correspond à l'ID du projet que vous avez sélectionné dans la console.

   Si vous devez modifier le nom du cluster d'amorçage ou l'ID du projet, saisissez Ctrl-C pour quitter bmctl register bootstrap et réexécutez la commande.

2. Cliquez sur Mise en réseau dans la barre de navigation de gauche.

3. Dans la section Plan de contrôle, saisissez les valeurs suivantes dans le champ Adresse IP du nœud du plan de contrôle 1:

   10.200.0.3
   

   Il s'agit de l'adresse IP de la VM abm-admin-cluster-cp dans le réseau VXLAN créé par le script.

4. Dans la section Équilibreur de charge, assurez-vous que l'option Groupée est sélectionnée.

5. Dans la section Adresses IP virtuelles (VIP), saisissez les informations suivantes dans le champ Adresse IP virtuelle du plan de contrôle:

   10.200.0.48
   

6. Cliquez sur Verify and Create (Valider et créer).

   La console affiche des messages d'état pendant la vérification des paramètres et la création du cluster.

gcloud CLI

1. Assurez-vous que les valeurs des variables d'environnement que vous avez définies précédemment sont correctes. Bien que l'exemple de commande utilise des espaces réservés, ceux-ci doivent correspondre aux variables d'environnement utilisées par le script.

   echo $PROJECT_ID
   echo $ADMIN_CLUSTER_NAME
   echo $ON_PREM_API_REGION
   echo $BMCTL_VERSION
   

2. Vérifiez que le cluster d'amorçage a été enregistré en tant que membre du parc:

   gcloud container fleet memberships list \
     --project=PROJECT_ID
   

   Si le cluster d'amorçage n'est pas répertorié, vérifiez son nom et l'ID de projet que vous avez spécifiés dans bmctl register bootstrap. Si vous devez modifier le nom du cluster d'amorçage ou l'ID du projet, saisissez Ctrl-C pour quitter bmctl register bootstrap et réexécuter la commande.

3. Créez le cluster d'administrateur avec l'équilibreur de charge groupé:

   gcloud container bare-metal admin-clusters create ADMIN_CLUSTER_NAME \
     --project=PROJECT_ID \
     --location=ON_PREM_API_REGION \
     --version=BMCTL_VERSION \
     --max-pods-per-node=110 \
     --control-plane-vip=10.200.0.48 \
     --control-plane-load-balancer-port=443 \
     --control-plane-node-configs node-ip=10.200.0.3 \
     --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
     --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
     --lvp-share-path=/mnt/localpv-share \
     --lvp-share-storage-class=local-shared \
     --lvp-node-mounts-config-path=/mnt/localpv-disk \
     --lvp-node-mounts-config-storage-class=local-disks
   

   Dans la commande précédente:

   • --control-plane-vip: est défini sur 10.200.0.48. Il s'agit de l'adresse IP virtuelle (VIP) de l'équilibreur de charge pour le serveur d'API Kubernetes du cluster.

   • --control-plane-node-configs: node-ip est défini sur 10.200.0.3. Il s'agit de l'adresse IP de la VM abm-admin-cluster-cp dans le VXLAN créé par le script.

   Pour obtenir la liste complète des options et de leur description, consultez la documentation de référence de la gcloud CLI.

   La sortie de la commande ressemble à ceci :

   Waiting for operation [projects/example-project-12345/locations/us-west1/operations/operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179] to complete.
   

   Dans l'exemple de résultat, la chaîne operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179 correspond au OPERATION_ID de l'opération de longue durée. Vous pouvez vérifier l'état de l'opération en exécutant la commande suivante dans une autre fenêtre de terminal:

   gcloud container bare-metal operations describe OPERATION_ID \
     --project=PROJECT_ID \
     --location=ON_PREM_API_REGION
   

Les détails du processus de création du cluster sont disponibles sur votre poste de travail administrateur. Avant de créer le cluster, bmctl exécute une série de vérifications préliminaires pour vérifier la configuration. Si les vérifications préliminaires réussissent, un résultat semblable à celui-ci s'affiche:

[2023-03-22 23:12:47+0000] Waiting for cluster kubeconfig to become ready OK
[2023-03-22 23:15:47+0000] Writing kubeconfig file
[2023-03-22 23:15:47+0000] kubeconfig of cluster being created is present at bmctl-workspace/abm-cluster-1/abm-cluster-1-kubeconfig
[2023-03-22 23:15:47+0000] Please restrict access to this file as it contains authentication credentials of your cluster.
[2023-03-22 23:15:47+0000] Waiting for cluster to become ready OK
[2023-03-22 23:20:17+0000] Please run
[2023-03-22 23:20:17+0000] kubectl --kubeconfig bmctl-workspace/abm-cluster-1/abm-cluster-1-kubeconfig get nodes
[2023-03-22 23:20:17+0000] to get cluster nodes status.
[2023-03-22 23:20:17+0000] Waiting for node pools to become ready OK
[2023-03-22 23:20:37+0000] Waiting for metrics to become ready in GCP OK
[2023-03-22 23:25:38+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2023-03-22 23:25:48+0000] Moving admin cluster resources to the created admin cluster
[2023-03-22 23:25:51+0000] Waiting for node update jobs to finish OK
[2023-03-22 23:27:41+0000] Flushing logs... OK
[2023-03-22 23:27:41+0000] Deleting membership... OK
[2023-03-22 23:27:42+0000] Deleting bootstrap cluster.

Vérifier le cluster d'administrateur

Vous trouverez le fichier kubeconfig de votre cluster d'administrateur sur le poste de travail administrateur, dans le répertoire bmctl-workspace du compte racine. Pour vérifier votre déploiement, suivez les étapes ci-dessous.

1. Si le script a créé le cluster d'administrateur, utilisez SSH pour accéder au poste de travail administrateur en tant qu'utilisateur racine:

   gcloud compute ssh root@abm-ws --zone ZONE
   

   Vous pouvez ignorer les messages concernant la mise à jour de la VM et suivre ce tutoriel. Si vous envisagez de conserver les VM en tant qu'environnement de test, vous pouvez mettre à jour l'OS ou passer à la version suivante, comme décrit dans la documentation d'Ubuntu.

2. Définissez la variable d'environnement KUBECONFIG avec le chemin d'accès au fichier de configuration du cluster pour exécuter les commandes kubectl sur le cluster.

   export clusterid=ADMIN_CLUSTER_NAME
   export KUBECONFIG=$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig
   kubectl get nodes
   

   Le résultat ressemble à ce qui suit :

   NAME                   STATUS   ROLES                  AGE   VERSION
   abm-admin-cluster-cp   Ready    control-plane,master   91m   v1.24.2-gke.1900
   

3. Définissez le contexte actuel dans une variable d'environnement:

   export CONTEXT="$(kubectl config current-context)"
   

4. Exécutez la commande gcloud suivante. Cette commande effectue les opérations suivantes :

   • Accorde à votre compte utilisateur le rôle clusterrole/cluster-admin Kubernetes sur le cluster.
   • Il configure le cluster de sorte que vous puissiez exécuter les commandes kubectl sur votre ordinateur local sans avoir à vous connecter en SSH au poste de travail administrateur.
   • permet de vous connecter au cluster dans la console à l'aide de votre identité Google.

   Remplacez YOUR_EMAIL_ADDRESS par l'adresse e-mail associée à votre compte Google Cloud. Exemple : --users=[e-mail].

   gcloud container fleet memberships generate-gateway-rbac  \
       --membership=ADMIN_CLUSTER_NAME \
       --role=clusterrole/cluster-admin \
       --users=YOUR_EMAIL_ADDRESS \
       --project=PROJECT_ID \
       --kubeconfig=$KUBECONFIG \
       --context=$CONTEXT\
       --apply
   

   Le résultat de cette commande ressemble à ce qui suit, qui est tronqué pour des raisons de lisibilité:

   Validating input arguments.
   Specified Cluster Role is: clusterrole/cluster-admin
   Generated RBAC policy is:
   --------------------------------------------
   ...
   
   Applying the generate RBAC policy to cluster with kubeconfig: /root/bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig, context: ADMIN_CLUSTER_NAME-admin@ADMIN_CLUSTER_NAME
   Writing RBAC policy for user: YOUR_EMAIL_ADDRESS to cluster.
   Successfully applied the RBAC policy to cluster.
   

5. Lorsque vous avez terminé l'exploration, saisissez exit pour vous déconnecter du poste de travail administrateur.

6. Exécutez la commande suivante sur votre ordinateur local pour obtenir l'entrée kubeconfig pouvant accéder au cluster via la passerelle de connexion:

   gcloud container fleet memberships get-credentials ADMIN_CLUSTER_NAME
   

   Le résultat ressemble à ce qui suit :

   Starting to build Gateway kubeconfig...
   Current project_id: PROJECT_ID
   A new kubeconfig entry "connectgateway_PROJECT_ID_global_ADMIN_CLUSTER_NAME" has been generated and set as the current context.
   

7. Vous pouvez maintenant exécuter des commandes kubectl via la passerelle de connexion:

   kubectl get nodes
   

   Le résultat ressemble à ce qui suit :

   NAME                   STATUS   ROLES                  AGE   VERSION
   abm-admin-cluster-cp   Ready    control-plane,master   94m   v1.24.2-gke.1900
   

Dans Google Distributed Cloud 1.16 et versions ultérieures, le cluster est automatiquement enregistré dans l'API GKE On-Prem. Cela vous permet d'utiliser la gcloud CLI et la console pour mettre à niveau le cluster d'administrateur.

Créer le cluster d'utilisateur

Lorsque le script a créé le VXLAN L2 pour les VM, il a attribué les adresses IP suivantes dans le réseau 10.200.0.0/24. Vous utilisez ces adresses IP lors de la configuration des paramètres de réseau et de pool de nœuds pour le cluster d'utilisateur.

Nom de la VM	Adresse IP du réseau	Description du nœud
abm-admin-cluster-cp1	10.200.0.3	Nœud du plan de contrôle pour le cluster d'administrateur
abm-user-cluster-cp1	10.200.0.4	Nœud du plan de contrôle pour le cluster d'utilisateur
abm-user-cluster-w1	10.200.0.5	Nœud de calcul pour le cluster d'utilisateur
abm-user-cluster-w2	10.200.0.6	Un autre nœud de calcul pour le cluster d'utilisateur

Vous pouvez utiliser la console Google Cloud, Google Cloud CLI ou Terraform pour créer le cluster d'utilisateur.

Console

Procédez comme suit pour créer un cluster d'utilisateur dans la console:

1. Dans la console, accédez à la page Créer un cluster GKE sur Bare Metal.

   Accéder à la page Créer un cluster GKE sur Bare Metal

2. Assurez-vous que le projet Google Cloud dans lequel vous avez créé le cluster d'administrateur est sélectionné.

3. Cliquez sur Créer un cluster.

4. Dans la boîte de dialogue, cliquez sur Sur site.

5. À côté de Bare Metal, cliquez sur Configurer. La page Conditions préalables s'affiche.

6. Sous Choisissez votre type de cluster, sélectionnez Créer un cluster d'utilisateur pour un cluster d'administrateur existant.

7. Cliquez sur Suivant.

Paramètres de base du cluster

1. Saisissez un nom pour le cluster d'utilisateur ou utilisez le nom par défaut.

2. Assurez-vous que le cluster d'administrateur que vous venez de créer est sélectionné. Vous pouvez utiliser les valeurs par défaut pour les autres paramètres de cette page.

3. Cliquez sur Mise en réseau dans la barre de navigation de gauche.

Mise en réseau

1. Dans la section Plan de contrôle, saisissez les valeurs suivantes dans le champ Adresse IP du nœud du plan de contrôle 1:

   10.200.0.4
   

   Il s'agit de l'adresse IP de la VM abm-user-cluster-cp1 dans le réseau VXLAN créé par le script.

2. Dans la section Équilibreur de charge, utilisez l'équilibreur de charge par défaut, fourni avec MetalLB.

3. Dans la section Nouveau pool d'adresses, saisissez la plage d'adresses IP suivante dans le champ Plage d'adresses IP 1:

   10.200.0.51-10.200.0.70
   

4. Cliquez sur OK.

5. Dans la section Adresses IP virtuelles, saisissez l'adresse IP suivante dans le champ Adresse IP virtuelle du plan de contrôle:

   10.200.0.50
   

6. Saisissez l'adresse IP suivante pour l'adresse IP virtuelle d'entrée:

   10.200.0.51
   

7. Utilisez les adresses IP par défaut indiquées dans la section CIDR des services et des pods.

8. Cliquez sur pool par défaut dans la barre de navigation de gauche.

Créer un pool de nœuds

Votre cluster doit comporter au moins un pool de nœuds pour les nœuds de calcul. Un pool de nœuds est un modèle pour les groupes de nœuds de calcul créés dans ce cluster.

Saisissez l'adresse IP suivante dans le champ Adresse des nœuds 1:

10.200.0.5

Il s'agit de l'adresse IP de la VM abm-user-cluster-w1 dans le réseau VXLAN créé par le script.

Créer le cluster

1. Cliquez sur Verify and Create (Valider et créer) pour créer le cluster d'utilisateur.

   La création du cluster d'utilisateur prend 15 minutes ou plus. La console affiche des messages d'état pendant qu'elle vérifie les paramètres et crée le cluster.

   En cas de problème de configuration, la console affiche un message d'erreur suffisamment clair pour que vous puissiez résoudre le problème de configuration, puis réessayer de créer le cluster.

   Pour en savoir plus sur le processus de création, cliquez sur Afficher les détails afin d'afficher un panneau latéral. Cliquez sur pour fermer le panneau de détails.

   Une fois le cluster créé, la mention État du cluster: en cours d'exécution s'affiche.

   

2. Une fois le cluster créé, cliquez sur Clusters pour revenir à la page Clusters.

gcloud CLI

Utilisez la commande suivante pour créer un cluster d'utilisateur:

gcloud container bare-metal clusters create

Après avoir créé le cluster, vous devez créer au moins un pool de nœuds à l'aide de la commande suivante:

gcloud container bare-metal node-pools create

Pour créer le cluster d'utilisateur:

1. Assurez-vous que les valeurs des variables d'environnement que vous avez définies précédemment sont correctes. Bien que l'exemple de commande utilise des espaces réservés, ceux-ci doivent correspondre aux variables d'environnement utilisées par le script.

   echo $PROJECT_ID
   echo $ADMIN_CLUSTER_NAME
   echo $ON_PREM_API_REGION
   echo $BMCTL_VERSION
   

2. Exécutez la commande suivante pour créer le cluster d'utilisateur. Remplacez les éléments suivants:

   • USER_CLUSTER_NAME: nom du cluster.

   • Assurez-vous que --admin-users est défini sur l'adresse e-mail associée à votre compte Google afin que vous puissiez administrer le cluster.

   Les autres valeurs de l'indicateur ont été renseignées automatiquement. Si nécessaire, faites défiler la page pour vérifier que l'option --admin-cluster-membership présente la valeur correcte pour le nom du cluster d'administrateur, qui correspond au dernier segment du nom de membre entièrement spécifié.

   gcloud container bare-metal clusters create USER_CLUSTER_NAME \
     --project=PROJECT_ID \
     --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
     --location=ON_PREM_API_REGION \
     --version=BMCTL_VERSION \
     --admin-users=YOUR_EMAIL_ADDRESS \
     --metal-lb-address-pools='pool=lb-pool-1,manual-assign=True,addresses=10.200.0.51-10.200.0.70' \
     --control-plane-node-configs='node-ip=10.200.0.4' \
     --control-plane-vip=10.200.0.50 \
     --control-plane-load-balancer-port=443 \
     --ingress-vip=10.200.0.51 \
     --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
     --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
     --lvp-share-path=/mnt/localpv-share \
     --lvp-share-storage-class=local-shared \
     --lvp-node-mounts-config-path=/mnt/localpv-disk \
     --lvp-node-mounts-config-storage-class=local-disks
   

La liste suivante décrit les options:

• --project: ID du projet dans lequel le cluster d'utilisateur sera enregistré. Ce projet est appelé "projet hôte du parc".

• --admin-cluster-membership: nom complet du cluster d'administrateur qui identifie le cluster d'administrateur dans le parc.

• --location: région Google Cloud dans laquelle l'API GKE On-Prem s'exécute et stocke ses métadonnées.

• --version: version de Google Distributed Cloud

• --admin-users: incluez votre adresse e-mail pour recevoir les stratégies de contrôle des accès basé sur les rôles (RBAC) Kubernetes, qui vous donnent un accès administrateur complet au cluster.

• --metal-lb-address-pools: configuration du pool d'adresses pour l'équilibreur de charge MetalLB groupé. La plage d'adresses IP doit se trouver dans le réseau 10.200.0.0/24 créé par le script. La plage d'adresses ne doit pas contenir les adresses IP attribuées aux VM ni au plan de contrôle VIP. Notez, cependant, que l'adresse IP virtuelle d'entrée doit se trouver dans cette plage d'adresses.

• --control-plane-node-configs: configuration du nœud du plan de contrôle pour le cluster d'utilisateur. La valeur de node-ip est 10.200.0.4, qui correspond à l'adresse IP que le script a attribuée à la VM abm-user-cluster-cp1.

• --control-plane-vip: adresse IP virtuelle du plan de contrôle. La valeur 10.200.0.50 se trouve dans le réseau 10.200.0.0/24 créé par le script, mais ne chevauche pas la plage d'adresses IP utilisée pour les pools d'adresses de l'équilibreur de charge MetalLB.

• --control-plane-load-balancer-port: port sur lequel l'équilibreur de charge diffuse le plan de contrôle. Bien qu'il soit possible de configurer une autre valeur, le port 443 est le port standard utilisé pour les connexions HTTPS.

• --ingress-vip: adresse IP virtuelle du service d'entrée. Cette adresse IP doit figurer dans la plage d'adresses IP utilisée pour les pools d'adresses de l'équilibreur de charge MetalLB.

• --island-mode-service-address-cidr-blocks: plage d'adresses IP, au format CIDR, à utiliser pour les services du cluster d'utilisateur. L'exemple de commande utilise 10.96.0.0/20, qui est la valeur par défaut fournie par la console. La plage CIDR doit être comprise entre /24 et /12, où /12 correspond au plus grand nombre d'adresses IP. Nous vous recommandons d'utiliser une plage dans l'espace d'adresses IP pour les réseaux Internet privés, telle que définie dans la RFC 1918.

• --island-mode-pod-address-cidr-blocks: plage d'adresses IP, au format CIDR, à utiliser pour les pods du cluster d'utilisateur. L'exemple de commande utilise 192.168.0.0/16, qui est la valeur par défaut fournie par la console. La plage CIDR doit être comprise entre /18 et /8, où /8 correspond au plus grand nombre d'adresses IP. Nous vous recommandons d'utiliser une plage dans l'espace d'adresses IP pour les réseaux Internet privés, telle que définie dans le document RFC 1918.

• --lvp-share-path: chemin d'accès de la machine hôte dans laquelle les sous-répertoires peuvent être créés. Un PersistentVolume local (PV) est créé pour chaque sous-répertoire.

• --lvp-share-storage-class: StorageClass à utiliser pour créer des volumes persistants. La StorageClass est créée lors de la création du cluster.

• --lvp-node-mounts-config-path: il s'agit du chemin d'accès à la machine hôte où les disques installés peuvent être découverts. Un PersistentVolume local est créé pour chaque installation.

• --lvp-node-mounts-config-storage: classe de stockage avec laquelle les PV sont créés lors de la création du cluster.

Une fois la commande exécutée, un résultat semblable à celui-ci s'affiche:

Waiting for operation [projects/PROJECT_ID/locations/ON_PREM_API_REGION/operations/operation-1678304606537-5f668bde5c57e-341effde-b612ff8a] to complete...

Dans l'exemple de résultat, la chaîne operation-1678304606537-5f668bde5c57e-341effde-b612ff8a correspond au OPERATION_ID de l'opération de longue durée.

Pour connaître l'état de l'opération, copiez le OPERATION_ID de votre résultat dans la commande suivante. Ouvrez une autre fenêtre de terminal et exécutez la commande.

gcloud container bare-metal operations describe OPERATION_ID \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

La création du cluster prend environ 15 minutes ou plus. Lors de la création du cluster, vous pouvez exécuter la commande précédente de temps en temps pour obtenir son état actuel.

Une fois le cluster créé, un résultat semblable aux lignes suivantes s'affiche:

Created Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/ON_PREM_API_REGION/bareMetalClusters/USER_CLUSTER_NAME].

Créer un pool de nœuds

Une fois le cluster créé, exécutez la commande suivante pour créer un pool de nœuds. Remplacez NODE_POOL_NAME par le nom du pool de nœuds et assurez-vous que l'espace réservé pour l'option --cluster est toujours défini sur le nom du cluster d'utilisateur.

gcloud container bare-metal node-pools create NODE_POOL_NAME \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=ON_PREM_API_REGION \
  --node-configs='node-ip=10.200.0.5'

• -node-configs: la valeur attribuée à node-ip est l'adresse IP de la VM abm-user-cluster-w1 dans le réseau VXLAN créé par le script.

Une fois la commande exécutée, un résultat semblable à celui-ci s'affiche:

Waiting for operation [projects/PROJECT_ID/locations/ON_PREM_API_REGION/operations/operation-1678308682052-5f669b0d132cb-6ebd1c2c-816287a7] to complete...

La création du pool de nœuds prend environ cinq minutes. Une fois le pool de nœuds créé, un résultat semblable aux lignes suivantes s'affiche:

Created node pool in Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/ON_PREM_API_REGION/bareMetalClusters/USER_CLUSTER_NAME/bareMetalNodePools/NODE_POOL_NAME].

Autres commandes de cluster d'utilisateur

En plus de créer des clusters, vous pouvez exécuter d'autres commandes de la gcloud CLI, par exemple:

• Pour répertorier vos clusters d'utilisateur:

gcloud container bare-metal clusters list \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

• Pour décrire un cluster d'utilisateur:

gcloud container bare-metal clusters describe USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Pour plus d'informations, consultez la page sur gcloud container bare-metal clusters.

Autres commandes de pool de nœuds

En plus de créer des pools de nœuds, vous pouvez exécuter d'autres commandes de la gcloud CLI, par exemple:

• Pour répertorier les pools de nœuds:

gcloud container bare-metal node-pools list \
    --cluster=USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

• Pour décrire un pool de nœuds:

gcloud container bare-metal node-pools describe NODE_POOL_NAME \
    --cluster=USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Pour en savoir plus, consultez la page sur gcloud container bare-metal node-pools.

Terraform

Vous pouvez utiliser l'exemple de configuration de base suivant pour créer un cluster d'utilisateur avec un équilibreur de charge MetalLB groupé. Pour en savoir plus, consultez la documentation de référence sur google_gkeonprem_bare_metal_cluster.

1. Dans le répertoire dans lequel vous avez cloné anthos-samples, accédez au répertoire où se trouve l'exemple Terraform:

   cd anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb
   

   L'exemple fournit un exemple de fichier de variables à transmettre à main.tf.

2. Créez une copie du fichier terraform.tfvars.sample:

   cp terraform.tfvars.sample terraform.tfvars
   

   
   project_id          = "PROJECT_ID"
   region              = "ON_PREM_API_REGION"
   admin_cluster_name  = "ADMIN_CLUSTER_NAME"
   bare_metal_version  = "VERSION"
   admin_user_emails   = ["YOUR_EMAIL_ADDRESS", "ADMIN_2_EMAIL_ADDRESS"]
   cluster_name        = "abm-user-cluster-metallb"
   control_plane_ips   = ["10.200.0.4"]
   worker_node_ips     = ["10.200.0.5", "10.200.0.6"]
   control_plane_vip   = "10.200.0.50"
   ingress_vip         = "10.200.0.51"
   lb_address_pools    = [
       { name = "lbpool_1", addresses = ["10.200.0.51-10.200.0.70"] }
   ]
   

3. Modifiez les valeurs des paramètres dans terraform.tfvars, puis enregistrez le fichier.

   La liste suivante décrit les variables:

   • project_id: ID du projet dans lequel le cluster d'utilisateur sera enregistré. Ce projet est appelé "projet hôte du parc".

   • region: région Google Cloud que vous avez définie au début du tutoriel. Exécutez echo $ON_PREM_API_REGION pour obtenir la valeur.

   • admin_cluster_name: nom du cluster d'administrateur que vous avez défini au début de ce tutoriel. Exécutez la commande echo $ADMIN_CLUSTER_NAME pour obtenir la valeur.

   • bare_metal_version: version de Google Distributed Cloud pour votre cluster d'utilisateur. Pour utiliser la même version que celle utilisée pour le cluster d'administrateur, exécutez echo $BMCTL_VERSION afin d'obtenir la valeur. Si vous préférez, vous pouvez spécifier une version mineure antérieure au maximum par rapport à la version du cluster d'administrateur. La version du cluster d'utilisateur ne peut pas être ultérieure à la version du cluster d'administrateur.

   • cluster_name: vous pouvez utiliser le nom figurant dans le fichier TVARS pour le cluster d'utilisateur ou spécifier le nom de votre choix. Une fois le cluster créé, le nom ne peut plus être modifié.

   • admin_user_emails: liste des adresses e-mail des utilisateurs auxquels accorder des droits d'administrateur sur le cluster. Veillez à ajouter votre adresse e-mail pour pouvoir administrer le cluster.

     Une fois le cluster créé, l'API GKE On-Prem applique les stratégies de contrôle des accès basé sur les rôles Kubernetes (RBAC) au cluster pour attribuer aux administrateurs le rôle clusterrole/cluster-admin Kubernetes, qui fournit un accès complet à toutes les ressources du cluster dans tous les espaces de noms. Cela permet également aux utilisateurs de se connecter à la console à l'aide de leur identité Google.

   Utilisez les valeurs par défaut définies dans terraform.tvars pour les variables restantes. Le script a utilisé ces valeurs lors de la création des VM et du cluster d'administrateur.

   • control_plane_ips: liste d'une ou de plusieurs adresses IPv4 pour les nœuds du plan de contrôle. Utilisez la valeur par défaut, qui correspond à l'adresse IP que le script a attribuée à la VM abm-user-cluster-cp1.

   • worker_node_ips: liste d'une ou de plusieurs adresses IPv4 pour les machines de nœuds de calcul. Utilisez les valeurs par défaut, qui correspondent aux adresses IP que le script a attribuées aux VM abm-user-cluster-w1 et abm-user-cluster-w2.

   • control_plane_vip: adresse IP virtuelle du plan de contrôle. Utilisez la valeur par défaut, 10.200.0.50, qui se trouve dans le réseau 10.200.0.0/24 créé par le script. Notez que cette adresse IP ne chevauche pas la plage d'adresses IP utilisée pour les pools d'adresses de l'équilibreur de charge MetalLB.

   • ingress_vip: adresse IP virtuelle à configurer sur l'équilibreur de charge pour le proxy d'entrée. Utilisez la valeur par défaut, 10.200.0.51, qui se trouve dans le réseau 10.200.0.0/24 créé par le script. Notez que cette adresse IP figure dans la plage d'adresses IP utilisée pour les pools d'adresses de l'équilibreur de charge MetalLB.

   • lb_address_pools: liste de cartes qui définissent les pools d'adresses pour l'équilibreur de charge MetalLB. Utilisez la valeur par défaut.

4. Enregistrez les modifications dans terraform.tfvars.

5. Initialisez et créez le plan Terraform :

   terraform init
   

   Terraform installe toutes les bibliothèques nécessaires, comme le fournisseur Google Cloud.

6. Examinez la configuration et apportez des modifications si nécessaire:

   terraform plan
   

7. Appliquez le plan Terraform pour créer le cluster d'utilisateur:

   terraform apply
   

   La création du cluster d'utilisateur prend 15 minutes ou plus. Pour afficher le cluster dans la console Google Cloud, accédez à la page Clusters GKE.

Se connecter au cluster d'utilisateur

Lorsque vous créez un cluster d'utilisateur à l'aide de la console ou de la gcloud CLI, celui-ci est configuré avec les mêmes stratégies de contrôle des accès basé sur les rôles Kubernetes (RBAC) que celles que vous avez configurées pour le cluster d'administrateur lors de l'exécution de gcloud container fleet memberships generate-gateway-rbac. Ces stratégies RBAC vous permettent de vous connecter au cluster à l'aide de votre identité Google Cloud, qui est l'adresse e-mail associée à votre compte Google Cloud. Ces règles RBAC vous permettent de vous connecter à la console sans configuration supplémentaire.

Se connecter au cluster dans la console

Si vous avez utilisé la gcloud CLI ou Terraform pour créer le cluster d'utilisateur, accédez à la page Clusters GKE dans la console:

Accéder aux clusters GKE

Assurez-vous que le projet dans lequel vous avez créé le cluster d'utilisateur est sélectionné. Vous devriez voir les clusters d'administrateur et d'utilisateur dans la liste.

Notez que la colonne Type du cluster d'utilisateur comporte la mention Bare metal: Utilisateur. Cela indique que le cluster est géré par l'API GKE On-Prem.

Si vous avez utilisé le script pour créer le cluster d'administrateur, la colonne Type indique Externe. Cela indique que le cluster n'est pas géré par l'API GKE On-Prem. Vous pouvez configurer le cluster d'administrateur à gérer par l'API GKE On-Prem après la création du cluster.

Pour vous connecter à un cluster:

1. Cliquez sur le lien situé sur le nom du cluster, puis dans le panneau latéral, cliquez sur Login (Connexion).

2. Sélectionnez Utilisez votre identité Google pour vous connecter.

3. Cliquez sur Login (Connexion).

Répétez la même procédure pour vous connecter au cluster d'administrateur.

Se connecter au cluster via la ligne de commande

L'API GKE On-Prem configure les stratégies RBAC à votre place en tant que créateur de cluster d'utilisateur. Ces règles vous permettent d'exécuter des commandes kubectl sur votre ordinateur local à l'aide de la passerelle de connexion kubeconfig.

Depuis votre ordinateur local:

1. Obtenez l'entrée kubeconfig qui peut accéder au cluster via la passerelle de connexion.

   gcloud container fleet memberships get-credentials USER_CLUSTER_NAME
   

   Le résultat ressemble à ce qui suit :

   Starting to build Gateway kubeconfig...
   Current project_id: PROJECT_ID
   A new kubeconfig entry "connectgateway_PROJECT_ID_global_USER_CLUSTER_NAME" has been generated and set as the current context.
   

2. Vous pouvez maintenant exécuter des commandes kubectl via la passerelle de connexion:

   kubectl get nodes
   

   Le résultat ressemble à ce qui suit :

   NAME                  STATUS   ROLES                  AGE     VERSION
   abm-user-cluster-cp   Ready    control-plane,master   14m     v1.24.2-gke.1900
   abm-user-cluster-w1   Ready    worker                 8m28s   v1.24.2-gke.1900
   

Ajouter un autre pool de nœuds au cluster d'utilisateur

Console

1. Dans la console, accédez à la page Clusters GKE.

   Accéder aux clusters GKE

2. Dans la liste des clusters, cliquez sur le nom du cluster puis sur Afficher les détails dans le panneau Détails.

3. Cliquez sur l'onglet Nœuds.

4. Cliquez sur Ajouter un pool de nœuds.

5. Saisissez un nom pour le pool de nœuds.

6. Dans le champ Adresse des nœuds 1, saisissez l'adresse IP suivante:

   10.200.0.6
   

   Il s'agit de l'adresse IP de la VM abm-user-cluster-w2 créée par le script.

7. Cliquez sur Créer.

8. Si nécessaire, cliquez à nouveau sur l'onglet Nœuds.

9. Le nouveau pool de nœuds affiche l'état Rapprochement.

10. Cliquez sur en haut à droite pour afficher l'état de la création du pool de nœuds. Vous devrez peut-être actualiser la page pour afficher l'état mis à jour dans la liste des pools de nœuds.

gcloud CLI

Exécutez la commande suivante pour créer un autre pool de nœuds. Remplacez NODE_POOL_NAME_2 par le nom du pool de nœuds et assurez-vous que l'espace réservé pour l'option --cluster est toujours défini sur le nom du cluster d'utilisateur.

gcloud container bare-metal node-pools create NODE_POOL_NAME_2 \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=ON_PREM_API_REGION \
  --node-configs='node-ip=10.200.0.6'

• -node-configs: la valeur attribuée à node-ip est l'adresse IP de la VM abm-user-cluster-w2 dans le réseau VXLAN créé par le script.

Terraform

Si vous avez créé le cluster à l'aide de Terraform, il a été créé avec deux nœuds. Il n'y a donc pas de VM supplémentaire dans le VXLAN disponible pour ajouter un autre nœud. Pour en savoir plus sur l'ajout de pools de nœuds, consultez la documentation de référence sur google_gkeonprem_bare_metal_cluster.

Vous pouvez également vérifier le nouveau nœud à l'aide de kubectl. Vous devez d'abord exécuter la commande gcloud container fleet memberships get-credentials comme indiqué précédemment pour récupérer la configuration du cluster:

kubectl get nodes

Le résultat ressemble à ce qui suit :

NAME                  STATUS   ROLES                  AGE     VERSION
abm-user-cluster-cp   Ready    control-plane,master   24m   v1.24.2-gke.1900
abm-user-cluster-w1   Ready    worker                 18m   v1.24.2-gke.1900
abm-user-cluster-w2   Ready    worker                 52s   v1.24.2-gke.1900

Effectuer un nettoyage

Les sections suivantes incluent des instructions pour supprimer les clusters et les VM que vous avez créés dans ce guide.

Supprimer le cluster d'utilisateur

Console

1. Dans la console, accédez à la page Clusters GKE.

   Accéder aux clusters GKE

2. Dans la liste des clusters, cliquez sur le cluster d'utilisateur.

3. Dans le panneau Détails, cliquez sur Plus de détails.

4. En haut de la fenêtre, cliquez sur Supprimer.

5. Lorsque vous êtes invité à confirmer votre choix, saisissez le nom du cluster et cliquez sur Confirmer.

6. Cliquez sur en haut à droite pour afficher l'état de la suppression. Vous devrez peut-être actualiser la page pour mettre à jour la liste des clusters.

gcloud CLI

Exécutez la commande suivante pour supprimer le cluster:

gcloud container bare-metal clusters delete USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=ON_PREM_API_REGION \
  --force

L'option --force vous permet de supprimer un cluster comportant des pools de nœuds. Sans l'option --force, vous devez d'abord supprimer les pools de nœuds, puis supprimer le cluster.

Pour en savoir plus sur les autres indicateurs, consultez la page sur gcloud container bare-metal clusters delete.

Terraform

Exécutez la commande ci-dessous.

terraform destroy

Attendez que le cluster d'utilisateur soit supprimé avant de supprimer le cluster d'administrateur et les VM.

Supprimer le cluster d'administrateur et les VM

1. Désinscrivez le cluster d'administrateur de l'API GKE On-Prem:

   gcloud container bare-metal admin-clusters unenroll ADMIN_CLUSTER_NAME \
       --project=PROJECT_ID \
       --location=ON_PREM_API_REGION
   

2. Connectez-vous au poste de travail administrateur:

   gcloud compute ssh root@abm-ws --zone ZONE
   

3. Supprimez le cluster d'administrateur:

   bmctl reset -c ADMIN_CLUSTER_NAME
   

   bmctl annule l'enregistrement du cluster du parc, puis le supprime. Attendez que le cluster soit supprimé avant de supprimer les VM.

4. Quittez le poste de travail administrateur.

5. Répertoriez toutes les VM dont le nom contient abm :

   gcloud compute instances list | grep 'abm'
   

6. Vérifiez que vous pouvez supprimer toutes les VM dont le nom contient abm.

   Une fois la vérification effectuée, vous pouvez supprimer les VM abm en exécutant la commande suivante :

   gcloud compute instances list --format="value(name)" | \
     grep 'abm'  | \
     xargs gcloud --quiet compute instances delete --zone ZONE
   

7. Supprimez le compte de service :

   gcloud iam service-accounts delete baremetal-gcr@PROJECT_ID.iam.gserviceaccount.com
   

   Lorsque l'invite de confirmation s'affiche, saisissez y.

   Étapes suivantes

• Créer un service et un objet Ingress
• Planifier l'installation
• Créer des clusters de base