Créer des clusters d'utilisateur et d'administrateur Anthos sur bare metal sur des VM Compute Engine

Version 1.13 

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

Cette page explique comment créer un cluster d'utilisateur Anthos 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 de cluster d'administrateur et d'utilisateur, ainsi que pour un poste de travail administrateur.

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

Un cluster d'utilisateur est un cluster Kubernetes qui exécute vos charges de travail conteneurisées. Il se compose de nœuds de plan de contrôle et de nœuds de calcul. Les clusters d'utilisateur doivent contenir un ou plusieurs nœuds de calcul qui exécutent 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 est constitué uniquement de nœuds de plan de contrôle. Pour en savoir plus, consultez Déploiement d'un cluster d'administrateur et d'utilisateur.

Le script configure un réseau de superposition LAN virtuel extensible (VXLAN) entre les VM et prépare les VM pour la création du cluster. Si vous le souhaitez, le script crée un cluster d'administrateur. Vous pouvez également choisir de créer vous-même le cluster d'administrateur pour en savoir plus sur les outils fournis par les clusters Anthos sur bare metal.

Le script fourni vous permet d'essayer des clusters Anthos sur bare metal rapidement et sans avoir à préparer de matériel. En suivant les étapes décrites sur cette page, vous disposerez d'un environnement de test de clusters Anthos sur bare metal s'exécutant sur Compute Engine.

Important : Ce déploiement n'est fourni qu'à des fins d'évaluation. N'exécutez pas de clusters Anthos sur 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 d'applications Google Cloud standards. L'API Anthos On-Prem s'exécute dans l'infrastructure de Google Cloud. Terraform, la console et gcloud CLI sont des clients de l'API. Ils 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 les 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 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. Le projet hôte du parc ne peut plus être modifié une fois le cluster créé.

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'en être le propriétaire ou l'éditeur.
7. Vous pouvez exécuter le script sur Cloud Shell ou sur votre ordinateur local exécutant Linux ou macOS. Si vous n'utilisez pas Cloud Shell :
   1. Assurez-vous d'avoir installé la dernière version de Google Cloud CLI, l'outil de ligne de commande permettant d'interagir avec Google Cloud, y compris les composants bêta de gcloud CLI.
   2. Si vous ne disposez pas encore des composants bêta, exécutez la commande suivante pour les installer:

      gcloud components install beta

   3. Si nécessaire, mettez à jour les composants de gcloud CLI:

      gcloud components update

      En fonction de l'installation de gcloud CLI, le message suivant peut s'afficher: "Impossible d'effectuer cette action, car le gestionnaire de composants de 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.

   4. Assurez-vous d'avoir installé kubectl. Si vous devez installer kubectl, exécutez la commande suivante:

      gcloud components install kubectl

Créez l'infrastructure de 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 la zone et le projet par défaut.

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

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

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

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

4. Sélectionnez une version à partir du 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 où 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 VM et installe le cluster d'administrateur.
   • Saisissez 2 pour que le script configure uniquement l'infrastructure de la VM.

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

Le script affiche chaque commande qu'il exécute et son état. Une fois l'opération terminée, le script génère le résultat suivant, selon que vous avez choisi d'installer le cluster d'administrateur:

Cluster d'administrateur créé

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

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

Configurer uniquement les VM

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

À propos du script

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

À propos du script

Le script automatise les étapes manuelles suivantes:

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

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

3. Il crée les VM suivantes :
   • Une VM pour le poste de travail administrateur. Le poste de travail administrateur aura accès à tous les autres nœuds de cluster via SSH.
   • Une VM pour le nœud du 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 du plan de contrôle du cluster d'utilisateur.
   Le script vérifie également que SSH est activé sur toutes les VM.
4. crée un réseau superposé virtuel 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é sur le sous-réseau 10.200.0.0/24. La connectivité de couche 2 est requise pour l'équilibreur de charge groupé.
5. Installe les outils suivants sur le poste de travail administrateur :
   • bmctl
   • kubectl
   • Docker

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

6. Elle garantit que root@10.200.0.x à partir du poste de travail administrateur effectue 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 également 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 décidez que le script créera le cluster d'administrateur, il utilisera 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 des clusters Anthos sur bare metal créent des clusters, il déploie un cluster Kubernetes dans Docker (kind) sur le poste de travail administrateur. Ce cluster amorçable héberge les contrôleurs Kubernetes nécessaires pour créer des clusters et est utilisé pour créer le cluster d'administrateur. Lors de la 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 la création du cluster terminée. Le cluster d'amorçage nécessite Docker d'extraire des 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 Valider le cluster d'administrateur. Sinon, suivez les étapes de cette section pour créer un cluster d'amorçage et un 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 le genre Docker (kind) sur le poste de travail administrateur. Ce cluster bootstrap héberge les contrôleurs Kubernetes nécessaires à la création du cluster d'administrateur. Lorsque vous créez le cluster d'administrateur, les contrôleurs du cluster d'amorçage provisionnent les nœuds, exécutent des vérifications préliminaires et enregistrent le cluster d'administrateur dans le parc. Le cluster d'amorçage est automatiquement supprimé une fois le cluster créé.

Console

1. Dans la console Google Cloud, accédez à la page Clusters d'Anthos.

   Accéder à la page "Clusters Anthos"

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 Configurer. La page Conditions préalables affiche les conditions requises pour votre poste de travail administrateur et vos 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é du préfixe bootstrap- en préfixe au nom du cluster d'administrateur.

8. 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 des clusters Anthos 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:

   • Les 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, le projet et l'emplacement du cluster permettent d'identifier le cluster de manière unique dans Google Cloud.

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

gcloud CLI

Ouvrez une nouvelle fenêtre de terminal. Vous utiliserez la deuxième fenêtre de terminal pour vous connecter au poste de travail administrateur et créer le cluster d'amorçage. Vous utiliserez la première fenêtre de terminal pour exécuter la commande 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 que racine:

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

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

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

   gcloud auth application-default login
   

   Suivez les instructions pour sélectionner votre compte Google pour le service 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 aux lignes suivantes s'affiche:

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

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

Créer le cluster d'administrateur

Console

1. Sur la page Installer l'environnement d'amorçage dans la section Environnement d'amorçage à partir du 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 pour --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 du nœud de plan de contrôle 1:

   10.200.0.3
   

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

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

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

   10.200.0.48
   

6. Cliquez sur Valider et créer.

   La console affiche des messages d'état lorsqu'elle valide 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, ils doivent correspondre aux variables d'environnement utilisées par le script.

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

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

   gcloud container fleet memberships list \
     --project=PROJECT_ID
   

   Si le cluster d'amorçage n'est pas répertorié, vérifiez le nom du cluster d'amorçage et l'ID de projet que vous avez spécifié à 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écutez la commande.

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

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

   Dans la commande précédente:

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

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

   Pour obtenir la liste complète des options et de leur description, consultez la documentation de référence de 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 est le OPERATION_ID de l'opération de longue durée. Vous pouvez consulter l'état de l'opération en exécutant la commande suivante dans une autre fenêtre de terminal:

   gcloud beta 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 exécute une série de vérifications préliminaires pour vérifier la configuration. Si les vérifications préliminaires réussissent, vous obtenez un résultat semblable au suivant:

[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 que racine:

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

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

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

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

   Le résultat ressemble à ce qui suit :

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

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

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

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

   • Accorde à votre compte utilisateur le rôle clusterrole/cluster-admin Kubernetes sur le cluster.
   • Configure le cluster pour 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é pour plus 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é, 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 qui peut 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
   

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 beta 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

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.

Lorsque le script a créé le VXLAN L2 pour les VM, il a attribué les adresses IP suivantes sur le réseau 10.200.0.0/24. Ces adresses IP sont utilisées lors de la configuration des paramètres réseau et de pool de nœuds du 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 du cluster d'administrateur
abm-utilisateur-cluster-cp1	10.200.0.4	Nœud du plan de contrôle pour le cluster d'utilisateur
abm-utilisateur-cluster-w1	10.200.0.5	Nœud de calcul pour le cluster d'utilisateur
abm-utilisateur-cluster-w2	10.200.0.6	Un autre nœud de calcul pour le cluster d'utilisateur

Vous pouvez utiliser Google Cloud Console, 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 Anthos.

   Accéder à la page "Clusters Anthos"

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 apparaître 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 Configurer.

6. Cliquez sur Paramètres de base du cluster dans la barre de navigation de gauche.

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 commande suivante dans le champ Adresse IP du nœud de plan de contrôle 1:

   10.200.0.4
   

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

2. Dans la section Équilibreur de charge, utilisez l'équilibreur de charge par défaut Bundleed 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 dans le champ Adresse IP virtuelle d'entrée:

   10.200.0.51
   

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

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

Créer un pool de nœuds

Votre cluster doit comporter au moins un pool de nœuds pour les nœuds de calcul. Un pool de nœuds 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 des nœuds 1:

10.200.0.5

Il s'agit de l'adresse IP de la VM abm-user-cluster-w1 dans le 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 pendant qu'elle valide les paramètres et crée le cluster.

   En cas de problème de configuration, la console affiche un message d'erreur qui doit être suffisamment clair pour vous permettre de résoudre le problème de configuration, 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 de 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

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

gcloud beta 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 beta 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, ils 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 que vous puissiez administrer le cluster.

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

   gcloud beta 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 ces options:

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

• --admin-cluster-membership: nom du cluster d'administrateur entièrement spécifié 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 d'Anthos clusters on Bare Metal.

• --admin-users: incluez votre adresse e-mail pour laquelle les stratégies de contrôle des accès basées sur les rôles (RBAC) Kubernetes 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 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 attribuée par le script à la VM abm-user-cluster-cp1.

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

• --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 se trouver 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 a utilisé 10.96.0.0/20, qui est la valeur par défaut fournie par la console. La plage CIDR doit être comprise entre /24 et /12, où /12 correspond au plus grand nombre d'adresses IP. Nous vous recommandons d'utiliser une plage dans l'espace d'adresses IP pour les Internet privés, comme défini dans la RFC 1918.

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

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

• --lvp-share-storage-class: ressource 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écouverts. Un PersistentVolume local (PV) 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, vous devriez obtenir le résultat suivant:

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 est le 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 beta container bare-metal operations describe OPERATION_ID \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

La création du cluster prend environ 15 minutes. Lors de 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éé, vous devriez voir le résultat suivant:

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'indicateur --cluster est toujours défini sur le nom du cluster d'utilisateur.

gcloud beta 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.

Après avoir exécuté la commande, vous devriez obtenir le résultat suivant:

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

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

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 beta container bare-metal clusters list \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

• Pour décrire un cluster d'utilisateur:

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

Pour en savoir plus, consultez la page concernant gcloud beta 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 beta container bare-metal node-pools list \
    --cluster=USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

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

gcloud beta 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 beta container bare-metal node-pools.

Terraform

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

1. Dans le répertoire dans lequel vous avez cloné anthos-samples, accédez au répertoire 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 et 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 d'Anthos clusters on Bare Metal pour votre cluster d'utilisateur. Pour utiliser la même version que celle utilisée pour le cluster d'administrateur, exécutez echo $BMCTL_VERSION afin d'obtenir la valeur. Si vous préférez, vous pouvez spécifier une version mineure inférieure à la version mineure du cluster d'administrateur. La version du cluster d'utilisateur ne peut pas être ultérieure à la version du cluster d'administrateur.

   • cluster_name: vous pouvez utiliser le nom indiqué dans le fichier VATRS du 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 auxquels des droits d'administrateur doivent être accordés 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ées sur les rôles Kubernetes (RBAC) au cluster pour attribuer aux utilisateurs administrateurs le rôle Kubernetes clusterrole/cluster-admin, qui fournit un accès complet à toutes les ressources du cluster dans tous les espaces de noms. Les utilisateurs peuvent également 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 est l'adresse IP que le script a attribuée à la VM abm-user-cluster-cp1.

   • worker_node_ips: liste d'une ou de plusieurs adresses IPv4 pour les machines de nœuds de calcul. Utilisez les valeurs par défaut, qui sont les adresses IP attribuées par le script 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 MetallLB. 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 requises, par exemple le fournisseur Google Cloud.

6. Vérifiez 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 Anthos.

Se connecter au cluster d'utilisateur

Lorsque vous créez un cluster d'utilisateur à l'aide de la console ou de gcloud CLI, le cluster est configuré avec les mêmes règles de contrôle des accès basées sur les rôles (RBAC) de Kubernetes que celles que vous avez configurées pour le cluster d'administrateur lorsque vous avez exécuté gcloud container fleet memberships generate-gateway-rbac. Ces stratégies RBAC vous permettent de vous connecter au cluster à l'aide de votre identité Google Cloud, qui est l'adresse e-mail associée à votre compte Google Cloud. Ces 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é gcloud CLI pour créer le cluster d'utilisateur, accédez à la page "Clusters Anthos" dans la console:

Accéder à la page "Clusters Anthos"

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

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

La colonne Type du cluster d'administrateur indique Externe. 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 pour qu'il soit géré par l'API Anthos On-Prem.

Pour vous connecter à un cluster:

1. Cliquez sur le lien du nom du cluster, puis sur le bouton 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 ordinateur local à l'aide du kubeconfig de la passerelle Connect.

Depuis votre ordinateur local:

1. Obtenez l'entrée kubeconfig pouvant 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 maintenant 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 Clusters d'Anthos.

   Accéder à la page "Clusters Anthos"

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 du nœud 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. Cliquer 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 que l'état actualisé s'affiche 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 beta 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 correspond à 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. Il n'existe donc pas de VM supplémentaire dans le VXLAN pour ajouter un 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

Supprimer le cluster d'utilisateur

Console

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

   Accéder à la page "Clusters Anthos"

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

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

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

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

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

gcloud CLI

Exécutez la commande suivante pour supprimer le cluster:

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

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

Pour en savoir plus sur les autres indicateurs, consultez la page gcloud beta 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ésenregistrez le cluster d'administrateur de l'API Anthos On-Prem:

   gcloud beta 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, 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 souhaitez 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
   

   Lorsque vous y êtes invité, saisissez y.

   Étapes suivantes

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