Créer des clusters d'utilisateur et d'administrateur Google Distributed Cloud de démonstration sur des VM Compute Engine

Découvrez Google Distributed Cloud (logiciel uniquement) pour Bare Metal (anciennement Google Distributed Cloud Virtual, anciennement Anthos Clusters on Bare Metal) en créant des clusters de démonstration sur des machines virtuelles (VM) Compute Engine. La création d'un cluster d'administrateur et d'un cluster d'utilisateur à l'aide de ce guide peut prendre entre 40 minutes et une heure. Les clusters de démonstration que vous créez dans ce guide vous aident à évaluer le processus de provisionnement et d'exploitation des clusters Google Distributed Cloud, mais ils ne sont pas destinés à être utilisés en production.

Ce document vous guide tout au long du processus d'exécution d'un script qui :

  • Provisionne cinq VM Compute Engine pour installer vos clusters de démonstration
  • Configure un réseau VPC pour fournir la connectivité du cluster

Une fois que le script a provisionné les ressources nécessaires, vous utilisez l'un des clients suivants pour créer un cluster d'administrateur et un cluster d'utilisateur associé pouvant héberger des charges de travail : bmctl, la console Google Cloud , Google Cloud CLI ou Terraform.

Présentation de la procédure

Ce guide comprend les étapes principales suivantes :

  1. Préparez votre environnement local afin que le script dispose des variables d'environnement requises et que vous ayez collecté les informations de base nécessaires à l'exécution des commandes.

  2. Créez les VM et le réseau à l'aide du script téléchargé.

  3. Créez le cluster d'administrateur avec l'un des clients compatibles.

  4. Créez le cluster d'utilisateur avec l'un des clients compatibles.

  5. Nettoyez pour supprimer les clusters et les VM que vous avez créés avec ce guide.

1. Préparer votre environnement local

Comme ce guide utilise un script qui configure le réseau pour vous, vous n'avez pas besoin de recueillir beaucoup d'informations ni de planifier quoi que ce soit. Les étapes suivantes permettent de configurer votre environnement local et de collecter les informations de base dont vous avez besoin dans les sections suivantes du guide :

  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.

    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.

    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'en être le propriétaire ou l'éditeur.
  7. Vous pouvez exécuter le script sur Cloud Shell ou sur votre machine locale exécutant Linux ou macOS. Si vous n'utilisez pas Cloud Shell :
    1. Assurez-vous d'avoir installé la dernière version de Google Cloud CLI, l'outil de ligne de commande permettant d'interagir avec Google Cloud. Mettez à jour les composants de gcloud CLI, si nécessaire : 
      gcloud components update

      Selon la manière dont la gcloud CLI a été installée, le message suivant peut s'afficher :

      You cannot perform this action because the Google Cloud CLI component manager is disabled for this installation. You can run the following command to achieve the same result for this installation:

      Suivez les instructions pour copier et coller la commande afin de mettre à jour les composants.

    2. Assurez-vous d'avoir installé kubectl. Si vous devez installer kubectl, exécutez la commande suivante : 
      gcloud components install kubectl
  8. Assurez-vous que votre projet dispose d'un réseau VPC nommé "default".

    Si vous n'avez pas de réseau VPC "par défaut", le script de la section suivante ne pourra pas provisionner les ressources nécessaires. Sauf si vous choisissez de le supprimer ou de le restreindre, chaque nouveau projet démarre avec un réseau VPC en mode automatique nommé "default" qui devrait fonctionner avec le script. Pour en savoir plus, consultez Réseaux VPC.

  9. Assurez-vous que les contraintes de règle d'administration suivantes ne sont pas appliquées :
    • constraints/iam.disableServiceAccountKeyCreation
    • constraints/compute.vmCanIpForward
    • constraints/compute.requireShieldedVm
    • constraints/compute.vmExternalIpAccess

    Si ces contraintes sont appliquées, le script de la section suivante ne pourra pas provisionner les ressources nécessaires. Pour un nouveau projet, ces contraintes sont définies sur "Inactif" (non appliquées) par défaut. Pour en savoir plus, consultez Contraintes liées aux règles d'administration.

  10. 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
    • ADMIN_CLUSTER_NAME : nom choisi pour le cluster d'administrateur.
    • 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 sont créées. Vous pouvez utiliser us-central1-a ou l'une des autres zones Compute Engine.
  11. Exécutez les commandes suivantes pour définir le projet et la zone par défaut. 
    gcloud config set project $PROJECT_ID
gcloud config set compute/zone $ZONE

    Si une erreur PERMISSION_DENIED s'affiche, 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 à gcloud CLI avec le compte ayant accès au projet.

  12. Obtenez la liste des versions compatibles que vous pouvez installer : 
    gcloud container bare-metal admin-clusters query-version-config \
    --location=ON_PREM_API_REGION
  13. 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

    Nous vous recommandons de sélectionner la version compatible la plus récente pour bénéficier des dernières fonctionnalités et corrections de Google Distributed Cloud.

    14. 2. Créer les VM et le réseau

    Dans cette section, vous allez télécharger et exécuter le script install_admin_cluster.sh.

    1. 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

    2. Exécutez le script :

      bash install_admin_cluster.sh

    3. À l'invite, saisissez 2 pour configurer uniquement l'infrastructure Compute Engine et confirmez votre sélection lorsque vous y êtes invité.

      Le script crée des VM Compute Engine, un réseau VXLAN, et configure le poste de travail administrateur et les nœuds de cluster. Ce processus prend environ cinq minutes.

      Pour en savoir plus sur ce script, cliquez sur le lien suivant :

      À propos du script

      Vous pouvez afficher le script dans le dossier anthos-bm-gcp-bash du dépôt GitHub anthos-samples. Le script automatise les étapes manuelles suivantes :

      1. Active les API Google Cloud suivantes : 
        anthos.googleapis.com
anthosaudit.googleapis.com
anthosgke.googleapis.com
cloudresourcemanager.googleapis.com
connectgateway.googleapis.com
container.googleapis.com
compute.googleapis.com
gkeconnect.googleapis.com
gkehub.googleapis.com
gkeonprem.googleapis.com
serviceusage.googleapis.com
stackdriver.googleapis.com
monitoring.googleapis.com
logging.googleapis.com
kubernetesmetadata.googleapis.com
iam.googleapis.com
opsconfigmonitoring.googleapis.com
      2. Au lieu de créer plusieurs comptes de service pour différentes API et différents services, le script crée un seul compte de service appelé baremetal-gcr et lui accorde les rôles IAM suivants :
        • roles/gkehub.admin
        • roles/gkehub.connect
        • roles/logging.logWriter
        • roles/monitoring.dashboardEditor
        • roles/monitoring.metricWriter
        • roles/monitoring.viewer
        • roles/opsconfigmonitoring.resourceMetadata.writer
        • roles/serviceusage.serviceUsageViewer
        • roles/stackdriver.resourceMetadata.writer
      3. Crée les VM suivantes :
        • Une VM pour le poste de travail administrateur.
        • 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.
      4. Vérifie que SSH est activé sur toutes les VM et que le poste de travail administrateur a accès à toutes les autres VM créées pour les nœuds de cluster.
      5. Crée un réseau de superposition VXLAN (Virtual Extensible LAN) pour la connectivité de couche 2 entre les VM. Le VXLAN n'est pas persistant. Par conséquent, si vous redémarrez une instance de VM, le réseau est détruit. Le réseau est configuré pour se trouver sur le sous-réseau 10.200.0.0/24. La connectivité de couche 2 est requise pour l'équilibreur de charge fourni.
      6. 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.

      7. Assurez-vous que root@10.200.0.x fonctionne à partir du poste de travail administrateur en effectuant les tâches suivantes :
        1. Génération d'une nouvelle clé SSH sur la machine d'administration
        2. Ajout de la clé publique à toutes les autres VM du déploiement

      Le script affiche chaque commande qu'il exécute et son état. Une fois l'opération terminée, le script génère ce qui suit :

      ✅ Successfully set up SSH access from admin workstation to cluster node VMs.

✅ GCE Infrastructure setup 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-cp  | 10.200.0.3            | 🌟 Ready for use as control plane for the admin cluster |
| abm-user-cluster-cp   | 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         |
|---------------------------------------------------------------------------------------------------------|

    3. Créez le cluster d'administrateur :

    bmctl

    Pour créer un cluster d'administrateur avec bmctl, accédez à la VM du poste de travail administrateur dans une fenêtre de terminal et exécutez les commandes à partir de cette fenêtre :

    1. Utilisez SSH pour accéder à la VM du poste de travail administrateur, abm-ws, en tant qu'utilisateur racine :

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

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

      gcloud auth application-default login

      Suivez les instructions pour sélectionner votre compte Google pour ADC.

    3. Générez un fichier de configuration de cluster :

      bmctl create config -c ADMIN_CLUSTER_NAME --project-id=PROJECT_ID

    4. Vérifiez le fichier de configuration du cluster d'administrateur :

      Le fichier de configuration de cluster suivant est renseigné avec les valeurs que vous avez fournies précédemment. Outre les valeurs que vous avez saisies, notez les différences suivantes par rapport au fichier de configuration généré :

      • Les commentaires ont été supprimés de cet exemple pour améliorer la lisibilité.
      • Le script crée un seul compte de service avec toutes les autorisations requises et télécharge la clé bm-gcr.json référencée dans le fichier de configuration.
      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
  profile: default
  anthosBareMetalVersion: BMCTL_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      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:
    projectID: PROJECT_ID
    location: ON_PREM_API_REGION
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 110

    5. Remplacez le contenu du fichier de configuration généré sur votre poste de travail administrateur par le contenu de l'exemple précédent.

      Ouvrez le fichier généré, bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME.yaml, et remplacez son contenu par celui de l'exemple que vous avez vérifié à l'étape précédente.

    6. Créez le cluster d'administrateur :

      bmctl create cluster -c ADMIN_CLUSTER_NAME

      La commande bmctl affiche le résultat à l'écran lorsqu'elle exécute les vérifications préliminaires et crée le cluster. Les informations détaillées sont écrites dans les journaux du dossier baremetal/bmctl-workspace/abm-user-cluster-metallb/log sur le poste de travail administrateur.

      La création du cluster peut prendre plusieurs minutes.

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

      Accéder aux clusters GKE

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

    8. Connectez-vous au cluster d'administrateur :

      1. Cliquez sur le lien du nom du cluster, puis sur Se connecter dans le panneau latéral.

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

      3. Cliquez sur Login (Connexion).

    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. Utilisez SSH pour accéder au poste de travail administrateur en tant qu'utilisateur racine :

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

    2. Vérifiez que votre cluster d'administrateur a été créé et est en cours d'exécution :

      kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes

      Le résultat ressemble à ce qui suit :

      none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81

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

    Console

    Pour créer un cluster d'administrateur dans la console, vous devez exécuter bmctl register bootstrap à partir de la VM du poste de travail administrateur pour créer un cluster d'amorçage. Pendant l'exécution de la commande bmctl register bootstrap, vous effectuez des étapes dans la console pour créer le cluster d'administrateur.

    Saisir les paramètres de base de l'environnement d'amorçage

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

      Accéder aux clusters GKE

    2. Cliquez sur Créer.

    3. Dans la boîte de dialogue Créer un cluster, sélectionnez Sur site, puis cliquez sur Configurer pour le bare metal :

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

    5. Dans la barre de navigation de gauche, cliquez sur Installer l'environnement de démarrage.

    6. Saisissez ADMIN_CLUSTER_NAME comme nom du cluster d'administrateur.

    7. Sélectionnez BMCTL_VERSION comme version pour 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 Google Distributed Cloud que vous installez doit correspondre à la version bmctl.

    8. 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, ainsi que la région dans laquelle les éléments suivants sont stockés :

      • Métadonnées du cluster d'utilisateur 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

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

    Pour créer le cluster bootstrap, suivez les étapes de la section suivante au lieu de celles affichées dans la console. Laissez la page de la console affichée, car vous allez y créer le cluster d'administrateur.

    Créer le cluster d'amorçage

    Lorsque vous utilisez un client d'API GKE On-Prem, tel que la console, pour créer un cluster d'administrateur, vous devez créer un cluster d'amorçage sur le poste de travail administrateur. Le cluster d'amorçage héberge les contrôleurs Kubernetes nécessaires à la création du cluster d'administrateur.

    1. À partir de la ligne de commande, utilisez SSH pour accéder à la VM du poste de travail administrateur en tant qu'utilisateur racine :

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

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

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

      gcloud auth application-default login

      Suivez les instructions pour sélectionner votre compte Google pour ADC.

    3. Accédez au répertoire baremetal/ et exécutez la commande suivante pour créer le cluster d'amorçage.

      Le nom du cluster d'amorçage est dérivé en ajoutant bootstrap- au nom du cluster d'administrateur.

      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, vous obtenez un résultat semblable à celui-ci :

      [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..

    Créez le cluster d'administrateur :

    1. Sur la page Installer l'environnement d'amorçage de la section Amorcer l'environnement depuis le 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 pour 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 de projet, saisissez Ctrl-C pour quitter bmctl register bootstrap et exécutez à nouveau la commande.

    Mise en réseau

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

    2. Dans la section Plan de contrôle, saisissez les informations suivantes 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.

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

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

      10.200.0.48

      L'étape suivante dépend de la disponibilité du cluster d'amorçage. La commande bmctl register bootstrap dans la fenêtre du terminal doit s'exécuter pendant quelques minutes avant que le cluster d'amorçage ne s'affiche en tant que membre enregistré. Si, après quelques minutes, il n'est toujours pas disponible, vérifiez le nom et l'ID de projet du cluster d'amorçage que vous avez utilisés. Si vous devez modifier le nom du cluster d'amorçage ou l'ID de projet, saisissez Ctrl-C dans l'autre fenêtre de terminal pour quitter bmctl register bootstrap et exécutez à nouveau la commande.

    5. Cliquez sur Vérifier et créer.

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

      Une fois le cluster d'administrateur créé, le cluster d'amorçage sur le poste de travail administrateur est supprimé. La sortie de la commande bmctl register bootstrap dans l'autre fenêtre de terminal ressemble à ceci :

      ...
[2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK
[2024-04-15 23:16:38+0000] Please run
[2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes
[2024-04-15 23:16:38+0000] to get cluster nodes status.
[2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK
[2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK
[2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster
[2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK
[2024-04-15 23:24:30+0000] Flushing logs... OK
[2024-04-15 23:24:30+0000] Unregistering bootstrap cluster.
[2024-04-15 23:24:30+0000] Deleting membership... OK
[2024-04-15 23:24:32+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. Utilisez SSH pour accéder au poste de travail administrateur en tant qu'utilisateur racine :

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

    2. Vérifiez que votre cluster d'administrateur a été créé et est en cours d'exécution :

      kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes

      Le résultat ressemble à ce qui suit :

      none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81

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

    CLI gcloud

    Les instructions suivantes nécessitent deux fenêtres de terminal. Dans une fenêtre de terminal, exécutez bmctl register bootstrap pour créer un cluster d'amorçage. Pendant l'exécution de la commande bmctl register bootstrap, exécutez gcloud container bare-metal admin-clusters create dans une autre fenêtre de terminal pour créer le cluster d'administrateur.

    Créer le cluster d'amorçage

    Lorsque vous utilisez un client d'API GKE On-Prem, tel que gcloud CLI, pour créer un cluster d'administrateur, vous devez créer un cluster d'amorçage sur le poste de travail administrateur. Le cluster d'amorçage héberge les contrôleurs Kubernetes nécessaires à la création du cluster d'administrateur.

    1. À partir de la ligne de commande, utilisez SSH pour accéder à la VM du poste de travail administrateur en tant qu'utilisateur racine :

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

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

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

      gcloud auth application-default login

      Suivez les instructions pour sélectionner votre compte Google pour ADC.

    3. Accédez au répertoire baremetal/ et exécutez la commande suivante pour créer le cluster d'amorçage.

      Le nom du cluster d'amorçage est dérivé en ajoutant bootstrap- au nom du cluster d'administrateur.

      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, vous obtenez un résultat semblable à celui-ci :

      [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..

    Créez le cluster d'administrateur :

    1. Dans une nouvelle fenêtre de terminal, 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

      La commande gcloud container bare-metal admin-clusters create de l'étape suivante dépend de la disponibilité du cluster d'amorçage. La commande bmctl register bootstrap dans l'autre fenêtre de terminal doit s'exécuter pendant quelques minutes avant que le cluster d'amorçage ne s'affiche en tant que membre enregistré. Si, après quelques minutes, il n'est toujours pas listé, vérifiez le nom du cluster d'amorçage et l'ID de projet que vous avez utilisés. Si vous devez modifier le nom du cluster d'amorçage ou l'ID de projet, saisissez Ctrl-C dans l'autre fenêtre de terminal pour quitter bmctl register bootstrap et exécutez à nouveau la commande.

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

      Assurez-vous que les valeurs que vous spécifiez correspondent aux variables d'environnement que vous avez spécifiées précédemment pour le script.

      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 cette commande :

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

      • --control-plane-node-configs : La valeur de node-ip est définie 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 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 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

      Lorsque l'opération gcloud container bare-metal admin-clusters create se termine correctement, le résultat ressemble à ce qui suit :

      none{:.devsite-disable-click-to-copy} Created Anthos on bare metal Admin Cluster [https://gkeonprem.googleapis.com/v1/projects/anonuser-anonproject/locations/us-central1/bareMetalAdminClusters/gce-admin-gcloud-001]. NAME LOCATION VERSION MEMBERSHIP STATE abm-cluster-1 us-central1 1.31.300-gke.81 abm-cluster-1 RUNNING

      Une fois le cluster d'administrateur créé, le cluster d'amorçage sur le poste de travail administrateur est supprimé. La sortie de la commande bmctl register bootstrap dans l'autre fenêtre de terminal ressemble à ceci :

      ...
[2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK
[2024-04-15 23:16:38+0000] Please run
[2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes
[2024-04-15 23:16:38+0000] to get cluster nodes status.
[2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK
[2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK
[2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster
[2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK
[2024-04-15 23:24:30+0000] Flushing logs... OK
[2024-04-15 23:24:30+0000] Unregistering bootstrap cluster.
[2024-04-15 23:24:30+0000] Deleting membership... OK
[2024-04-15 23:24:32+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. Utilisez SSH pour accéder au poste de travail administrateur en tant qu'utilisateur racine :

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

    2. Vérifiez que votre cluster d'administrateur a été créé et est en cours d'exécution :

      kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes

      Le résultat ressemble à ce qui suit :

      none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81

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

    Terraform

    Les instructions suivantes nécessitent deux fenêtres de terminal. Dans une fenêtre de terminal, exécutez bmctl register bootstrap pour créer un cluster d'amorçage. Pendant l'exécution de la commande bmctl register bootstrap, exécutez les commandes Terraform dans une autre fenêtre de terminal pour créer le cluster d'administrateur.

    Modifier les exemples de fichiers de cluster d'utilisateur pour qu'ils fonctionnent avec un cluster d'administrateur

    Le dépôt anthos-samples n'inclut pas d'exemple spécifique à la création d'un cluster d'administrateur Google Distributed Cloud. Les étapes suivantes vous expliquent comment créer un cluster d'administrateur en modifiant un exemple Terraform de cluster d'utilisateur existant.

    1. Dans le répertoire dans lequel vous avez cloné anthos-samples, exécutez la commande suivante pour copier les exemples de fichiers de l'exemple de cluster d'utilisateur MetalLB dans un nouveau dossier pour votre cluster d'administrateur :

      cp -r anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb \
    anthos-samples/anthos-onprem-terraform/abm_admin_cluster_basic

    2. Accédez au répertoire abm_admin_cluster_basic :

      cd anthos-samples/anthos-onprem-terraform/abm_admin_cluster_basic

    3. Modifiez les fichiers Terraform :

      • variables.tf :

        • Définissez une variable pour les adresses IP des nœuds du plan de contrôle (bien que nous n'en utilisions qu'une seule pour cette démonstration). Cette variable doit être semblable à l'entrée variable "control_plane_ips" { ... }.

        • Définissez une variable pour l'adresse IP virtuelle du plan de contrôle. Cette variable doit être semblable à l'entrée variable "control_plane_vip" { ... }.

      • terraform.tfvars :

        • Attribuez des valeurs de variables aux paramètres de cluster d'administrateur suivants :

          • Adresses IP des nœuds du plan de contrôle : 10.200.0.3

          • Adresse IP virtuelle du plan de contrôle : 10.200.0.48

      • main.tf :

        • Remplacez la ressource google_gkeonprem_bare_metal_cluster par la ressource google_gkeonprem_bare_metal_admin_cluster.

        • Supprimez la ressource google_gkeonprem_bare_metal_node_pool et la section lifecycle associée.

        • Mettez à jour la ressource pour utiliser les variables nouvellement définies.

      Voici un exemple de fichier main.tf modifié pour créer un cluster d'administrateur :

      /**
* Copyright 2023 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#[START anthos_onprem_terraform_bare_metal_admin_cluster_basic_main]

module "enable_google_apis_primary" {
  source     = "terraform-google-modules/project-factory/google//modules/project_services"
  version    = "~> 14.0"
  project_id = var.project_id
  activate_apis = [
    "anthos.googleapis.com",
    "anthosaudit.googleapis.com",
    "anthosgke.googleapis.com",
    "cloudresourcemanager.googleapis.com",
    "compute.googleapis.com",
    "connectgateway.googleapis.com",
    "container.googleapis.com",
    "file.googleapis.com",
    "gkehub.googleapis.com",
    "iam.googleapis.com",
    "kubernetesmetadata.googleapis.com",
    "logging.googleapis.com",
    "monitoring.googleapis.com",
    "opsconfigmonitoring.googleapis.com",
    "serviceusage.googleapis.com",
    "stackdriver.googleapis.com"
  ]
  disable_services_on_destroy = false
}

# Enable GKE OnPrem API
resource "google_project_service" "default" {
  project            = var.project_id
  service            = "gkeonprem.googleapis.com"
  disable_on_destroy = false
}

# Create a baremetal admin cluster and enroll it with the gkeonprem API
resource "google_gkeonprem_bare_metal_admin_cluster" "admin-cluster-basic" {
  name                     = var.admin_cluster_name
  description              = "Bare metal admin cluster"
  provider                 = google
  depends_on               = [google_project_service.default]
  location                 = var.region
  bare_metal_version       = var.bare_metal_version
  network_config {
    island_mode_cidr {
      service_address_cidr_blocks = ["0.96.0.0/20"]
      pod_address_cidr_blocks     = ["192.168.0.0/16"]
    }
  }
  node_config {
    max_pods_per_node = 250
  }
  control_plane {
    control_plane_node_pool_config {
      node_pool_config {
        operating_system = "LINUX"
        dynamic "node_configs" {
          for_each = var.admin_cp_ips
          content {
            node_ip = node_configs.value
          }
        }
      }
    }
  }
  load_balancer {
    port_config {
      control_plane_load_balancer_port = 443
    }
    vip_config {
      control_plane_vip = var.admin_cp_vip
    }
  }
  storage {
    lvp_share_config {
      lvp_config {
        path = "/mnt/localpv-share"
        storage_class = "local-shared"
      }
      shared_path_pv_count = 5
    }
    lvp_node_mounts_config {
      path = "/mnt/localpv-disk"
      storage_class = "local-disks"
    }
  }

  dynamic "security_config" {
    for_each = length(var.admin_user_emails) == 0 ? [] : [1]
    content {
      authorization {
        dynamic "admin_users" {
          for_each = var.admin_user_emails
          content {
            username = admin_users.value
          }
        }
      }
    }
  }

  lifecycle {
    ignore_changes = [
      annotations["onprem.cluster.gke.io/user-cluster-resource-link"],
      annotations["alpha.baremetal.cluster.gke.io/cluster-metrics-webhook"],
      annotations["baremetal.cluster.gke.io/operation"],
      annotations["baremetal.cluster.gke.io/operation-id"],
      annotations["baremetal.cluster.gke.io/start-time"],
      annotations["baremetal.cluster.gke.io/upgrade-from-version"]
    ]
  }
}

#[END anthos_onprem_terraform_bare_metal_admin_cluster_basic_main]

      Pour en savoir plus sur la ressource Terraform pour les clusters d'administrateur, consultez la section google_gkeonprem_bare_metal_admin_cluster dans le registre Terraform.

    Créer le cluster d'amorçage

    Lorsque vous utilisez un client d'API GKE On-Prem, tel que Terraform, pour créer un cluster d'administrateur, vous devez créer un cluster d'amorçage sur le poste de travail administrateur. Le cluster d'amorçage héberge les contrôleurs Kubernetes nécessaires à la création du cluster d'administrateur.

    1. À partir de la ligne de commande, utilisez SSH pour accéder à la VM du poste de travail administrateur en tant qu'utilisateur racine :

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

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

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

      gcloud auth application-default login

      Suivez les instructions pour sélectionner votre compte Google pour ADC.

    3. Accédez au répertoire baremetal/ et exécutez la commande suivante pour créer le cluster d'amorçage.

      Le nom du cluster d'amorçage est dérivé en ajoutant bootstrap- au nom du cluster d'administrateur.

      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, vous obtenez un résultat semblable à celui-ci :

      [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..

    Créez le cluster d'administrateur :

    1. Initialisez et créez le plan Terraform :

      terraform init

      Terraform installe les bibliothèques nécessaires, telles que le fournisseur Google Cloud .

    2. Examinez la configuration et apportez les modifications nécessaires :

      terraform plan

    3. Appliquez le plan Terraform pour créer le cluster d'administrateur :

      terraform apply

      La création du cluster d'administrateur prend au moins 15 minutes. Une fois la création du cluster terminée, un message semblable à celui-ci s'affiche :

      ...
google_gkeonprem_bare_metal_admin_cluster.admin-cluster-basic: Still creating... [20m10s elapsed]
google_gkeonprem_bare_metal_admin_cluster.admin-cluster-basic: Creation complete after 20m11s
[id=projects/anonuser-anonproject/locations/us-central1/bareMetalAdminClusters/gce-admin-terra002]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

      Une fois le cluster d'administrateur créé, le cluster d'amorçage sur le poste de travail administrateur est supprimé. La sortie de la commande bmctl register bootstrap dans l'autre fenêtre de terminal ressemble à ceci :

      ...
[2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK
[2024-04-15 23:16:38+0000] Please run
[2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes
[2024-04-15 23:16:38+0000] to get cluster nodes status.
[2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK
[2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK
[2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster
[2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK
[2024-04-15 23:24:30+0000] Flushing logs... OK
[2024-04-15 23:24:30+0000] Unregistering bootstrap cluster.
[2024-04-15 23:24:30+0000] Deleting membership... OK
[2024-04-15 23:24:32+0000] Deleting bootstrap cluster.

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

      Accéder aux clusters GKE

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

    5. Connectez-vous au cluster d'administrateur :

      1. Cliquez sur le lien du nom du cluster, puis sur Se connecter dans le panneau latéral.

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

      3. Cliquez sur Login (Connexion).

    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. Utilisez SSH pour accéder au poste de travail administrateur en tant qu'utilisateur racine :

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

    2. Vérifiez que votre cluster d'administrateur a été créé et est en cours d'exécution :

      kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes

      Le résultat ressemble à ce qui suit :

      none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81

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

    4. Créer le cluster d'utilisateur

    Vous pouvez utiliser la console Google Cloud , la Google Cloud CLI ou Terraform pour créer le cluster d'utilisateur. Pour plus de simplicité, utilisez abm-user-cluster-metallb pour le nom du cluster utilisateur, afin de correspondre au nom codé en dur dans les scripts Terraform.

    bmctl

    1. Utilisez SSH pour accéder à la VM du poste de travail administrateur, abm-ws, en tant qu'utilisateur racine :

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

    2. Générez un fichier de configuration de cluster :

      bmctl create config -c abm-user-cluster-metallb \
    --project-id=PROJECT_ID

    3. Dans le fichier de configuration de cluster d'utilisateur suivant, définissez votre adresse e-mail dans la section clusterSecurity et vérifiez les autres paramètres :

      Le fichier de configuration de cluster suivant est renseigné avec les valeurs que vous avez saisies précédemment dans le tableau de planification. Outre les valeurs que vous avez saisies, notez les différences suivantes par rapport au fichier de configuration généré :

      • Les commentaires ont été supprimés de cet exemple pour améliorer la lisibilité.
      • La section "Identifiants" a été supprimée, comme c'est le cas pour les clusters d'utilisateur.
      • Le type de cluster, spec.type, a été défini sur user.
      • Le champ spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts a été ajouté pour attribuer le rôle clusterrole/cluster-admin à votre compte. Ce champ vous permet, entre autres, de vous connecter à votre cluster dans la consoleGoogle Cloud pour afficher plus de détails sur le cluster.
      ---
apiVersion: v1
kind: Namespace
metadata:
  name: cluster-abm-user-cluster-metallb
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: abm-user-cluster-metallb
  namespace: cluster-abm-user-cluster-metallb
spec:
  type: user
  profile: default
  anthosBareMetalVersion: BMCTL_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: 10.200.0.4
  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.50
      ingressVIP: 10.200.0.51
    addressPools:
    - name: pool1
      addresses:
      - 10.200.0.51-10.200.0.70
  clusterOperations:
    projectID: PROJECT_ID
    location: ON_PREM_API_REGION
  clusterSecurity:
    authorization:
      clusterAdmin:
        gcpAccounts:
        - YOUR_EMAIL_ADDRESS
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 250
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-abm-user-cluster-metallb
spec:
  clusterName: abm-user-cluster-metallb
  nodes:
  - address: 10.200.0.5

    4. Remplacez le contenu du fichier de configuration généré sur votre poste de travail administrateur par le contenu de l'exemple précédent.

      Ouvrez le fichier généré, bmctl-workspace/abm-user-cluster-metallb/abm-user-cluster-metallb.yaml, et remplacez son contenu par celui de l'exemple que vous avez vérifié à l'étape précédente.

    5. Créez le cluster d'utilisateur :

      bmctl create cluster -c abm-user-cluster-metallb \
  --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig

      La commande bmctl affiche le résultat à l'écran lorsqu'elle exécute les vérifications préliminaires et crée le cluster. Les informations détaillées sont écrites dans les journaux du dossier baremetal/bmctl-workspace/abm-user-cluster-metallb/log sur le poste de travail administrateur.

      La création du cluster peut prendre plusieurs minutes.

    6. Dans la console Google Cloud , accédez à la page Clusters GKE.

      Accéder aux clusters GKE

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

    7. Connectez-vous au cluster d'utilisateur :

      1. Cliquez sur le lien du nom du cluster, puis sur Se connecter 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.

    Console

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

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

      Accéder à la page "Créer un cluster bare metal"

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

    3. Cliquez sur Créer un cluster.

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

    5. À côté de Bare metal, cliquez sur Configurer. La page Conditions requises s'affiche.

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

    7. Cliquez sur Suivant.

    Paramètres de base du cluster

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

    2. Assurez-vous que le cluster d'administrateur nouvellement créé 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

    Le script que vous avez exécuté pour créer des VM et le cluster d'administrateur a également créé un VXLAN de couche 2 avec des adresses IP dans le sous-réseau 10.200.0.0/24.

    1. Dans la section Plan de contrôle, saisissez les informations suivantes 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, Groupé avec MetalLB.

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

      10.200.0.51-10.200.0.70

    4. Cliquez sur OK.

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

      10.200.0.50

    6. Saisissez l'adresse IP suivante comme 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 d'utilisateur doit comporter au moins un pool de nœuds pour les nœuds de calcul.

    1. 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 Vérifier et créer pour créer le cluster d'utilisateur.

      La création du cluster d'utilisateur prend au moins 15 minutes. La console affiche les messages d'état de vérification des paramètres et de création du cluster.

      En cas de problème de configuration, la console affiche un message d'erreur suffisamment clair pour que vous puissiez résoudre le problème de configuration et tenter à nouveau 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.

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

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

    3. Connectez-vous au cluster d'utilisateur :

      1. Cliquez sur le lien du nom du cluster, puis sur Se connecter 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.

    CLI gcloud

    Pour créer le cluster d'utilisateur :

    1. Exécutez la commande suivante pour créer le cluster d'utilisateur :

      gcloud container bare-metal clusters create abm-user-cluster-metallb \
    --project=PROJECT_ID \
    --admin-cluster-membership=projects/PROJECT_ID/locations/ON_PREM_API_REGION/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

      Une fois la commande exécutée, un résultat semblable aux lignes suivantes 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 est le OPERATION_ID de l'opération de longue durée.

    2. Pour connaître l'état de l'opération, 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

      Remplacez OPERATION_ID par la chaîne correspondante issue du résultat de l'étape précédente.

      La création du cluster prend au moins 15 minutes. Pendant la création du cluster, vous pouvez exécuter la commande précédente de temps en temps pour obtenir l'état actuel.

      Une fois le cluster créé, un résultat de ce type s'affiche :

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

      Pour en savoir plus sur la commande gcloud container bare-metal clusters create, y compris la description de chaque option, consultez la page Créer des clusters Bare Metal de conteneurs pour la ressource de clusters dans la documentation de référence de gcloud CLI.

    Créer un pool de nœuds

    Une fois le cluster créé, vous pouvez créer un pool de nœuds pour celui-ci.

    Pour créer un pool de nœuds :

    1. Exécutez la commande suivante pour créer un pool de nœuds :

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

      Remplacez NODE_POOL_NAME par le nom du pool de nœuds.

      Une fois la commande exécutée, un résultat semblable aux lignes suivantes s'affiche :

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

      La création du pool de nœuds prend environ cinq minutes. Une fois le pool de nœuds créé, un résultat semblable à celui-ci s'affiche :

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

    2. Accédez à la page Clusters Kubernetes dans la console :

      Accéder à la page "Créer un cluster bare metal"

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

    3. Connectez-vous au cluster d'utilisateur :

      1. Cliquez sur le lien du nom du cluster, puis sur Se connecter 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.

    Terraform

    Vous pouvez utiliser l'exemple de configuration de base suivant pour créer un cluster d'utilisateur avec l'équilibreur de charge MetalLB fourni. Pour plus d'informations, 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 fichier de variables à transmettre à main.tf.

    2. Faites une copie du fichier terraform.tfvars.sample :

      cp terraform.tfvars.sample terraform.tfvars

    3. Vérifiez les valeurs dans l'exemple suivant :

      Le fichier de variables Terraform suivant, terraform.tfvars.sample, est prérempli avec les adresses IP et les valeurs que vous avez saisies dans les sections précédentes de ce guide.

      
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"] }
]

      Remplacez ADMIN_2_EMAIL_ADDRESS par une adresse e-mail associée à votre compte Google Cloud ou supprimez-la lorsque vous modifiez le fichier de variables.

      Pour en savoir plus sur les arguments de cet exemple pour lesquels vous définissez des variables, consultez la documentation de référence sur les arguments dans la documentation Terraform pour les clusters d'utilisateur Bare Metal.

    4. Remplacez le contenu de votre copie du fichier de variables par le contenu de l'exemple précédent.

    5. Initialisez et créez le plan Terraform :

      terraform init

      Terraform installe les bibliothèques nécessaires, telles que le fournisseur Google Cloud .

    6. Examinez la configuration et apportez les modifications nécessaires :

      terraform plan

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

      terraform apply

      La création du cluster d'utilisateur prend au moins 15 minutes. Vous pouvez afficher le cluster dans la console Google Cloud sur la page Clusters GKE.

    8. Dans la console Google Cloud , accédez à la page Clusters GKE.

      Accéder aux clusters GKE

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

    9. Connectez-vous au cluster d'utilisateur :

      1. Cliquez sur le lien du nom du cluster, puis sur Se connecter 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.

    5. Effectuer un nettoyage

    Suivez les instructions ci-dessous pour supprimer les clusters et les VM que vous avez créés avec ce guide.

    Supprimer le cluster d'utilisateur

    bmctl

    • Pour supprimer le cluster d'utilisateur avec bmctl, exécutez la commande suivante à partir de la VM du poste de travail administrateur, abm-ws :

      bmctl reset \
    --cluster abm-user-cluster-metallb \
    --admin-kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig

    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 Afficher les détails.

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

    5. Lorsque vous êtes invité à confirmer l'opération, saisissez le nom du cluster, puis cliquez sur Supprimer.

    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.

    CLI gcloud

    • Pour supprimer le cluster, exécutez la commande suivante :

      gcloud container bare-metal clusters delete abm-user-cluster-metallb \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION \
    --force

      L'option --force vous permet de supprimer un cluster qui comporte 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 options, consultez gcloud container bare-metal clusters delete.

    Terraform

    La commande terraform destroy met fin aux ressources qui ont été créées lorsque vous avez exécuté terraform apply pour créer le cluster d'utilisateur.

    • Exécutez la commande suivante à partir du répertoire où se trouvent les exemples de fichiers de cluster d'utilisateur Terraform, tels que main.tf :

      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 :

      exit

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

      gcloud compute instances list | grep 'abm'

    6. Vérifiez que vous êtes prêt à 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 compute instances delete --quiet --zone ZONE

    7. Exécutez la commande suivante pour supprimer le compte de service, puis saisissez y lorsque vous y êtes invité :

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

      Étape suivante