Créer des clusters d'administrateur et d'utilisateur Google Distributed Cloud Virtual pour Bare Metal sur des VM Compute Engine

Version 1.14 

• Le plus récent
• Version 1.16
• Versions antérieures (non compatibles)

Cette page explique comment créer un cluster d'utilisateur Google Distributed Cloud Virtual pour 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 que pour 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 exécutant des charges de travail d'utilisateur. Un cluster d'administrateur est un cluster Kubernetes qui gère un ou plusieurs clusters d'utilisateur et contribue à leur création, mise à jour et suppression. Un cluster d'administrateur ne se compose que de nœuds de plan de contrôle. Pour en savoir plus, consultez la page Déploiement de clusters d'administrateur et d'utilisateur.

Le script configure un réseau de superposition LAN virtuel (VXLAN) entre les VM et prépare les VM pour la création du cluster. Le script crée éventuellement 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 GKE sur Bare Metal pour créer des clusters d'administrateur.

Grâce au script fourni, vous pouvez tester rapidement GKE sur une solution Bare Metal, sans avoir à préparer de matériel. Les étapes de cette page vous permettent d'obtenir un environnement de test GKE sur Bare Metal fonctionnel qui s'exécute sur Compute Engine.

Important : Ce déploiement n'est fourni qu'à des fins d'évaluation. N'exécutez pas GKE sur une solution Bare Metal sur des VM Compute Engine en production.

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

L'API Anthos 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 Anthos On-Prem s'exécute dans l'infrastructure Google Cloud. Terraform, la console et la 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 Anthos On-Prem doit stocker des métadonnées sur l'état de votre cluster dans Google Cloud, à l'aide de 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 à la charge de travail.

Lorsque vous créez un cluster à l'aide d'un client API Anthos 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. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Make sure that billing is enabled for your Google Cloud project.

6. Notez l'ID du projet, car vous en aurez besoin pour définir une variable d'environnement utilisée dans le script et les commandes de cette page. Si vous avez sélectionné un projet existant, assurez-vous d'être propriétaire ou éditeur du projet.
7. Vous pouvez exécuter le script dans 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. Si nécessaire, mettez à jour les composants de la gcloud CLI:

      gcloud components update

      Selon la méthode d'installation de gcloud CLI, le message suivant peut s'afficher: "Vous ne pouvez pas effectuer cette action, car le gestionnaire de composants de la Google Cloud CLI 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 d'avoir installé kubectl. 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

Pour configurer et exécuter le script, procédez comme suit : 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 Anthos 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 l'une des autres zones Compute Engine.

2. Exécutez les commandes suivantes pour définir 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 du projet que vous avez saisi. Si l'ID du projet est correct, exécutez gcloud auth login pour vous connecter à la gcloud CLI à l'aide du compte ayant accès au projet.

3. Obtenez la liste des versions 1.14 que vous pouvez installer:

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

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
   

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 configure uniquement l'infrastructure de VM.

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

Le script génère chaque commande qu'il exécute, ainsi que son état. Une fois l'opération terminée, le script affiche le résultat suivant 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 les VM uniquement

|---------------------------------------------------------------------------------------------------------|
| 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. Crée un compte de service appelé baremetal-gcr et lui accorde des autorisations supplémentaires pour éviter d'avoir besoin d'utiliser plusieurs comptes de service pour différents services et API.
2. Il 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 via 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é VXLAN (Virtual Extensible LAN) pour la 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 une exigence 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é du compte de service baremetal-gcr sur le poste de travail administrateur.

6. Vous vous assurez 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:
   anthos-bm-gcp-bash/install_admin_cluster.sh

   Afficher sur GitHub

     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. Il s'agit de l'un des outils que vous pouvez utiliser pour créer des clusters d'administrateur.

   Lorsque GKE sur Bare Metal crée des clusters, il déploie 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 pertinents sont déplacés du cluster d'amorçage vers le cluster d'administrateur. Enfin, sauf indication contraire, le cluster d'amorçage est supprimé une fois le cluster créé. Le cluster d'amorçage nécessite Docker pour extraire les images de conteneurs.

Créer le cluster d'administrateur (facultatif)

Preview

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

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 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 du cluster d'administrateur. Lorsque vous créez le cluster d'administrateur, les contrôleurs du cluster d'amorçage provisionnent les nœuds, effectuent des vérifications préliminaires et enregistrent le cluster d'administrateur dans le parc. Il est automatiquement supprimé une fois le cluster créé.

Console

1. Dans la console Google Cloud, accédez à la page des clusters GKE Enterprise.

   Accéder à la page "Clusters GKE Enterprise"

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

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 Configure (Configurer). La page Prérequis affiche les exigences pour le poste de travail administrateur et les machines de nœud de cluster.

   Assurez-vous que l'option Créer un cluster d'administrateur est sélectionnée.

6. Dans la barre de navigation de gauche, cliquez sur Install Bootstrap Environment (Installer l'environnement d'amorçage).

7. Saisissez ADMIN_CLUSTER_NAME comme nom de cluster d'administrateur. Notez que le nom du cluster d'amorçage est dérivé en ajoutant le préfixe bootstrap- au nom du cluster d'administrateur.

8. Sélectionnez VERSION comme version du 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 de GKE sur Bare Metal que vous installez doit correspondre à la version bmctl.

9. 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 Anthos On-Prem s'exécute et la région dans laquelle les éléments suivants sont stockés:

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

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

Pour créer le cluster d'amorçage, utilisez les étapes de la section suivante au lieu de celles affichées dans la console. 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. Connectez-vous en SSH au poste de travail administrateur en tant qu'utilisateur racine:

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

   Vous pouvez ignorer tous les messages concernant la mise à jour de la VM et suivre ce tutoriel. Si vous prévoyez de conserver les VM en tant qu'environnement de test, vous pouvez mettre à jour le système d'exploitation ou passer à la version suivante, comme décrit dans la documentation 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 l'ADC.

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 à celui-ci 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 échouera. 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.

   La connexion au cluster d'amorçage doit être établie 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 exécuter à nouveau 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 l'adresse suivante dans le champ Adresse IP 1 du nœud du plan de contrôle:

   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 Bundled est sélectionnée.

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

   10.200.0.48
   

6. Cliquez sur Valider et créer.

   La console affiche des messages d'état pendant qu'elle vérifie les paramètres et crée le 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 ne figure pas dans la liste, vérifiez son nom et l'ID du projet que vous avez spécifié sur 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: défini sur 10.200.0.48. Il s'agit de l'adresse IP virtuelle 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 réseau VXLAN créé par le script.

   Pour obtenir la liste complète des indicateurs et leur description, consultez la documentation de référence de 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 connaître 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 générés sur votre poste de travail administrateur. Avant de créer le cluster, bmctl effectue 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, procédez comme suit.

1. Si le script a créé le cluster d'administrateur, connectez-vous en SSH au poste de travail administrateur en tant qu'utilisateur racine:

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

   Vous pouvez ignorer tous les messages concernant la mise à jour de la VM et suivre ce tutoriel. Si vous prévoyez de conserver les VM en tant qu'environnement de test, vous pouvez mettre à jour le système d'exploitation ou passer à la version suivante, comme décrit dans la documentation 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 celui-ci.

   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 :

   • Attribue à votre compte utilisateur le rôle Kubernetes clusterrole/cluster-admin sur le cluster.
   • Il configure le cluster pour que vous puissiez exécuter les commandes kubectl sur votre ordinateur local sans avoir à vous connecter en SSH au poste de travail administrateur.
   • Vous 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 permettant d'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 désormais exécuter des commandes kubectl via la passerelle Connect:

   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
   

8. Si le script a créé le cluster d'administrateur, exécutez la commande suivante pour enregistrer le cluster dans l'API Anthos On-Prem:

   gcloud container bare-metal admin-clusters enroll ADMIN_CLUSTER_NAME  \
       --project=PROJECT_ID \
       --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
       --location=ON_PREM_API_REGION
   

   Si vous avez créé le cluster, il est automatiquement enregistré dans l'API Anthos On-Prem.

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, la Google Cloud CLI ou Terraform pour créer le cluster d'utilisateur.

Console

Pour créer un cluster d'utilisateur dans la console, procédez comme suit:

1. Dans la console, accédez à la page des clusters GKE Enterprise.

   Accéder à la page "Clusters GKE Enterprise"

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

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 Configure (Configurer). La page Prérequis s'affiche.

6. Sous Choisir 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 la valeur 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 la valeur suivante dans le champ Adresse IP 1 du nœud du plan de contrôle:

   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, Bundled with 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 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 représente le modèle des groupes de nœuds de calcul créés dans ce cluster.

Saisissez l'adresse IP suivante dans le champ Adresse de nœud 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 (Vérifier 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 le résoudre, puis réessayez de créer le cluster.

   Pour afficher des informations supplémentaires 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 des détails.

   Lorsque le cluster est créé, É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

Exécutez 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 pour pouvoir administrer le cluster.

   Les autres valeurs de signalement ont été renseignées pour vous. Si nécessaire, faites défiler la page pour vérifier que la valeur de l'option --admin-cluster-membership est correcte pour le nom du cluster d'administrateur, qui est le dernier segment du nom d'appartenance complet.

   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 indicateurs:

• --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 Anthos On-Prem s'exécute et stocke ses métadonnées.

• --version: version de GKE sur Bare Metal.

• --admin-users: incluez votre adresse e-mail pour bénéficier des 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 faire partie du 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 à l'adresse IP virtuelle du plan de contrôle. Notez toutefois que l'adresse IP virtuelle d'entrée doit se trouver dans cette plage d'adresses.

• --control-plane-node-configs: configuration de 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 que vous puissiez 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 faire partie de 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 utilisait 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'adressage IP des réseaux Internet privés, tel que défini dans le document 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 utilisait 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'adressage IP des réseaux Internet privés, tel que défini dans le document RFC 1918.

• --lvp-share-path: chemin d'accès à la machine hôte dans lequel les sous-répertoires peuvent être créés. Un PersistentVolume (PV) local 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: chemin d'accès de la machine hôte où les disques installés peuvent être détectés. Un PersistentVolume (PV) 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.

Après avoir exécuté la commande, 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 sortie 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. Pendant la création du cluster, vous pouvez exécuter la commande précédente de temps en temps pour obtenir l'état actuel.

Une fois le cluster créé, un résultat semblable à celui-ci 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 correspond à l'adresse IP de la VM abm-user-cluster-w1 dans le VXLAN créé par le script.

Après avoir exécuté la commande, 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 à celui-ci 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 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 en savoir plus, consultez la page gcloud container bare-metal clusters.

Autres commandes de pool de nœuds

Outre la création de pools de nœuds, vous pouvez exécuter d'autres commandes de 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, procédez comme suit:

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 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 de google_gkeonprem_bare_metal_cluster.

1. Dans le répertoire dans lequel vous avez cloné anthos-samples, accédez au répertoire dans lequel 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
   

   anthos-onprem-terraform/abm_user_cluster_metallb/terraform.tfvars.sample

   Afficher sur GitHub

   
   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 GKE sur Bare Metal pour votre cluster d'utilisateur. Pour utiliser la même version que celle du cluster d'administrateur, exécutez echo $BMCTL_VERSION afin d'obtenir la valeur. Si vous préférez, vous pouvez spécifier une version inférieure d'au moins une version mineure à la version du cluster d'administrateur. La version du cluster d'utilisateur ne peut pas être supérieure à celle du cluster d'administrateur.

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

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

     Une fois le cluster créé, l'API Anthos On-Prem applique les stratégies de contrôle des accès basé sur les rôles (RBAC) de Kubernetes au cluster pour attribuer aux administrateurs le rôle Kubernetes clusterrole/cluster-admin. Celui-ci 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 attribuée par le script à 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 (VIP) 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 se trouve dans la plage d'adresses IP utilisée pour les pools d'adresses de l'équilibreur de charge MetalLB.

   • lb_address_pools: liste des mappages 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 modifiez-la 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. Vous pouvez afficher le cluster dans la console Google Cloud sur la page Clusters Anthos.

Se connecter au cluster d'utilisateur

Lorsque vous créez un cluster d'utilisateur à l'aide de la console ou de 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 définies 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 Google Cloud Identity, qui est l'adresse e-mail associée à votre compte Google Cloud. Ces stratégies 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 pour créer le cluster d'utilisateur, accédez à la page des clusters GKE Enterprise dans la console:

Accéder à la page "Clusters GKE Enterprise"

Assurez-vous que le projet dans lequel vous avez créé le cluster d'utilisateur est sélectionné. Les clusters d'administrateur et d'utilisateur doivent figurer dans la liste.

Notez que Anthos (Bare metal: User) apparaît dans la colonne Type du cluster d'utilisateur. Cela indique que le cluster est géré par l'API Anthos On-Prem.

La colonne Type indique Externe pour le cluster d'administrateur. Cela indique que le cluster n'est pas géré par l'API Anthos On-Prem.

Bien que le cluster d'administrateur ait été créé par le script à l'aide de bmctl, vous pouvez configurer le cluster d'administrateur à gérer par l'API Anthos On-Prem.

Pour vous connecter à un cluster:

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

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 Anthos On-Prem configure les stratégies RBAC pour vous en tant que créateur de cluster d'utilisateur. Ces règles vous permettent d'exécuter des commandes kubectl sur votre bureau local à l'aide du kubeconfig de la passerelle Connect.

Depuis votre ordinateur local:

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

   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 désormais exécuter des commandes kubectl via la passerelle Connect:

   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 Google Cloud, accédez à la page des clusters GKE Enterprise.

   Accéder à la page "Clusters GKE Enterprise"

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 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 VXLAN créé par le script.

Terraform

Si vous avez créé le cluster à l'aide de Terraform, celui-ci a été créé avec deux nœuds. Aucune VM supplémentaire dans le VXLAN n'est donc 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 de 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

Supprimer le cluster d'utilisateur

Console

1. Dans la console, accédez à la page des clusters GKE Enterprise.

   Accéder à la page "Clusters GKE Enterprise"

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, puis 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 contenant 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 gcloud container bare-metal clusters delete.

Terraform

Exécutez la commande suivante :

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 Anthos 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 dans le 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
   

7. Supprimez le compte de service :

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

   À l'invite de confirmation, saisissez y.

   Étapes suivantes

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