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

Version 1.16 

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

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 de 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 facilite la création, la mise à jour et la suppression de clusters d'utilisateur. Un cluster d'administrateur ne comprend que des 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 en superposition Virtual Extensible LAN (VXLAN) entre les VM et les prépare pour la création du cluster. Le script peut éventuellement 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 GKE sur une solution Bare Metal pour la création de 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. Suivez les étapes décrites sur cette page pour obtenir un environnement de test GKE sur Bare Metal 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 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 la gcloud CLI sont des clients de l'API. Ils utilisent celle-ci 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, à 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 de données spécifiques à la charge 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. Le projet hôte du parc ne peut plus être modifié une fois le cluster créé.

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. 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 de 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 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. Si nécessaire, mettez à jour les composants de la gcloud CLI:

      gcloud components update

      Selon le mode d'installation de la gcloud CLI, le message suivant peut s'afficher: "Vous ne pouvez pas effectuer cette action, car le gestionnaire de composants de la gcloud 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 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

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 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 l'une des autres zones 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 à l'aide du compte ayant accès au projet.

3. Obtenez la liste des versions de GKE sur Bare Metal que vous pouvez installer:

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

   Certaines instructions de ce document dépendent de l'API GKE On-Prem, qui est compatible avec un sous-ensemble de versions de GKE sur Bare Metal 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 corrections de GKE sur Bare Metal.

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 chiffre 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 leur é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 de 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. 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 de 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 en superposition Virtual Extensible LAN (VXLAN) 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. Il 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. Le script exécute ensuite 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 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 des 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, le cluster d'amorçage est supprimé une fois le cluster créé. 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 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. Une fois créé, le cluster d'amorçage est automatiquement supprimé.

Console

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

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

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

3. Dans la barre de navigation de gauche, cliquez sur 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 dérivé du préfixe 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 de GKE sur Bare Metal 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 de cluster dont l'API GKE 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

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

Pour créer le cluster d'amorçage, utilisez les étapes de la section suivante plutôt que 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. Dans la première fenêtre de terminal, vous allez exécuter la commande gcloud CLI pour 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 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 envisagez de conserver les VM dans un 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 afin de sélectionner votre compte Google pour 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 à partir du poste de travail administrateur, cliquez sur Vérifier la connexion.

   En cas de réussite, 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 réexécuter 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 la commande 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 variables d'environnement que vous avez définies précédemment possèdent les valeurs 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 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: 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 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 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 affichés 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 message 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, 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 tous les messages concernant la mise à jour de la VM et suivre ce tutoriel. Si vous envisagez de conserver les VM dans un 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 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 :

   • Attribue à votre compte utilisateur le rôle Kubernetes clusterrole/cluster-admin sur le cluster.
   • Il configure le cluster afin que vous puissiez exécuter des 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é par souci 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 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 GKE sur Bare Metal 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. Ces adresses IP sont utilisées 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

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 une solution Bare Metal.

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

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

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

4. Cliquez sur Suivant.

Paramètres de base du cluster

1. Saisissez un nom pour le cluster d'utilisateur ou utilisez celui 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 commande 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 Nodes address 1 (Adresse de 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 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 lors de la vérification des paramètres et de la création du cluster.

   En cas de problème de configuration, la console affiche un message d'erreur qui devrait être suffisamment clair pour que vous puissiez résoudre le problème de configuration et réessayer 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 variables d'environnement que vous avez définies précédemment possèdent les valeurs 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 d'indicateur ont été renseignées automatiquement. Faites défiler la page si nécessaire pour vérifier que la valeur de l'option --admin-cluster-membership correspond au 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 entièrement spécifié 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 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 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 à 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 du nœud de plan de contrôle pour le cluster d'utilisateur. La valeur de node-ip est 10.200.0.4, qui correspond à l'adresse IP attribuée par le script à 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 elle 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 être comprise 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 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.

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 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. Lors de la création du cluster, vous pouvez exécuter de temps en temps la commande précédente 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 est l'adresse IP de la VM abm-user-cluster-w1 dans le 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 maximum. 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 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 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
   

   
   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 de 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 que vous avez 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 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 indiquer 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.

     Lorsque le cluster est créé, l'API GKE On-Prem applique au cluster les stratégies de contrôle des accès basé sur les rôles (RBAC) pour accorder 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 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 attribuées par le script 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 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 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. Vous pouvez afficher le cluster dans la console Google Cloud sur 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 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 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é. Les clusters d'administrateur et d'utilisateur doivent figurer dans la liste.

Notez que la colonne Type indique Bare Metal: User pour le cluster d'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 sur 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 GKE 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 de la passerelle de connexion kubeconfig.

Sur 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 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. Par conséquent, aucune VM supplémentaire dans le VXLAN n'est 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 contiennent des instructions pour supprimer les clusters et les VM que vous avez créés avec 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, 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 options, 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 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 --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