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 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 utilisateur avec ce guide peut prendre de 40 minutes à 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 une connectivité au 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 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 rassemblé les informations de base nécessaires pour exécuter des commandes.

  2. Créez les VM et le réseau avec le 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. Effectuez un nettoyage pour supprimer les clusters et les VM que vous avez créés dans ce guide.

1. Préparer votre environnement local

Comme ce guide utilise un script qui configure le réseau à votre place, vous n'avez pas besoin de collecter 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 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 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

      En fonction de la manière dont gcloud CLI a été installé, 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 que kubectl est installé. Si vous devez installer kubectl, exécutez la commande suivante : 
      gcloud components install kubectl
  8. 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.
  9. Exécutez les commandes suivantes pour définir le projet et la zone par défaut. 
    gcloud config set project $PROJECT_ID
gcloud config set compute/zone $ZONE

    Si vous recevez 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 à gcloud CLI avec le compte ayant accès au projet.

  10. Obtenez la liste des versions compatibles que vous pouvez installer : 
    gcloud container bare-metal admin-clusters query-version-config \
    --location=ON_PREM_API_REGION
  11. Sélectionnez une version dans la sortie 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 la plus compatible pour obtenir les dernières fonctionnalités et corrections de Google Distributed Cloud.

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 où 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. Lorsque vous y êtes invité, saisissez 2 pour configurer uniquement l'infrastructure Compute Engine, puis 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érents API et services, le script crée un seul compte de service appelé baremetal-gcr et lui attribue 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 d'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 de 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 dispose d'un accès SSH à toutes les autres VM créées pour les nœuds de cluster.
    5. Crée un réseau superposé VXLAN (Virtual Extensible LAN) pour la connectivité de couche 2 entre les VM. Le réseau VXLAN n'est pas persistant. Par conséquent, si vous redémarrez une instance de VM, le réseau est détruit. Le réseau est configuré pour se trouver sur le sous-réseau 10.200.0.0/24. La connectivité de couche 2 est requise pour l'équilibreur de charge groupé.
    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 pour le compte de service baremetal-gcr sur le poste de travail administrateur.

    7. S'assure 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 génère chaque commande exécutée 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 comme 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. En plus des valeurs que vous avez saisies, notez les différences suivantes avec le 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: us-central1
  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 le contenu 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 du 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 figurant sur le nom du cluster, puis sur Login (Connexion) dans le panneau latéral.

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

    3. Cliquez sur Login (Connexion).

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 :

    NAME                   STATUS   ROLES                  AGE   VERSION
abm-admin-cluster-cp   Ready    control-plane   94m   v1.27.4-gke.1600

  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.

Présentation des principes de base de l'environnement d'amorçage

  1. Dans Google Cloud Console, 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 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 d'amorçage.

  6. Saisissez ADMIN_CLUSTER_NAME comme nom de 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 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 et 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.

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

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

    gcloud auth application-default login

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

  3. 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, dans 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 Groupé 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, au bout de quelques minutes, il n'est toujours pas disponible, vérifiez le nom du cluster d'amorçage et l'ID du projet que vous avez utilisés. Si vous devez modifier le nom du cluster d'amorçage ou l'ID du projet, saisissez Ctrl-C dans l'autre fenêtre de terminal pour quitter bmctl register bootstrap, puis exécutez à nouveau la commande.

  5. Cliquez sur Valider 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 du 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 :

    NAME                   STATUS   ROLES                  AGE   VERSION
abm-admin-cluster-cp   Ready    control-plane   94m   v1.27.4-gke.1600

  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, vous exécutez bmctl register bootstrap pour créer un cluster d'amorçage. Pendant que la commande bmctl register bootstrap s'exécute, vous 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 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 suivre ce tutoriel. Si vous prévoyez de conserver les VM en tant qu'environnement de test, vous pouvez mettre à jour le système d'exploitation ou passer à la version suivante, comme décrit dans la documentation Ubuntu.

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

    gcloud auth application-default login

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

  3. 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 de l'autre fenêtre de terminal doit s'exécuter pendant quelques minutes avant que le cluster d'amorçage s'affiche en tant que membre enregistré. Si, au bout de 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 du projet, saisissez Ctrl-C dans l'autre fenêtre de terminal pour quitter bmctl register bootstrap, puis 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 (VIP) 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 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 correspond à l'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 :

    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.28.300-gke.131  abm-cluster-1  RUNNING

    Une fois le cluster d'administrateur créé, le cluster d'amorçage du 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 :

    NAME                   STATUS   ROLES                  AGE   VERSION
abm-admin-cluster-cp   Ready    control-plane   94m   v1.27.4-gke.1600

  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, vous exécutez bmctl register bootstrap pour créer un cluster d'amorçage. Pendant l'exécution de la commande bmctl register bootstrap, vous exécutez les commandes Terraform dans une autre fenêtre de terminal pour créer le cluster d'administrateur.

Modifier des 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 VIP 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 tel qu'il peut se présenter lorsqu'il est 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 an anthos 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              = "Anthos 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 suivre ce tutoriel. Si vous prévoyez de conserver les VM en tant qu'environnement de test, vous pouvez mettre à jour le système d'exploitation ou passer à la version suivante, comme décrit dans la documentation Ubuntu.

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

    gcloud auth application-default login

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

  3. 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 de ce type 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 du 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 figurant sur le nom du cluster, puis sur Login (Connexion) dans le panneau latéral.

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

    3. Cliquez sur Login (Connexion).

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 :

    NAME                   STATUS   ROLES                  AGE   VERSION
abm-admin-cluster-cp   Ready    control-plane   94m   v1.27.4-gke.1600

  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 créer le cluster d'utilisateur à l'aide de la console Google Cloud, de Google Cloud CLI ou de Terraform. Pour plus de simplicité, utilisez abm-user-cluster-metallb comme nom du cluster d'utilisateur, afin de faire correspondre le 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 du cluster suivant est renseigné avec les valeurs que vous avez saisies dans le tableau de planification 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 afin d'améliorer la lisibilité.
    • La section "Identifiants" a été supprimée, comme c'est le cas pour les clusters d'utilisateurs.
    • Le type de cluster, spec.type, a été défini sur user.
    • Le champ spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts a été ajouté pour accorder le clusterrole/cluster-admin à votre compte. Ce champ vous permet, entre autres, de vous connecter à votre cluster dans la console Google 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: us-central1
  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 lors de l'exécution des vérifications préliminaires et de la création du cluster. Les informations détaillées sont écrites dans les journaux du dossier baremetal/bmctl-workspace/abm-user-cluster-metallb/log du poste de travail administrateur.

    La création du cluster peut prendre plusieurs minutes.

  6. Dans Google Cloud 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 et le cluster d'utilisateur doivent apparaître dans la liste.

  7. Connectez-vous au cluster d'utilisateur :

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

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

    3. Cliquez sur Login (Connexion).

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

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 Prérequis s'affiche.

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

  7. Cliquez sur Suivant.

Paramètres de base du cluster

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

  2. Assurez-vous que le cluster d'administrateur que vous venez de créer est sélectionné. Vous pouvez conserver les valeurs par défaut des 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 réseau VXLAN créé par le script.

  2. Dans la section Équilibreur de charge, utilisez l'équilibreur de charge par défaut, intégré à 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 plages 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 disposer d'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 réseau 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 qui doit être suffisamment clair pour résoudre le problème de configuration avant de retenter de créer le cluster.

    Pour afficher des informations supplémentaires sur le processus de création, cliquez sur Afficher les détails pour afficher un panneau latéral. Cliquez sur pour fermer le panneau de 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 figurant sur le nom du cluster, puis sur Login (Connexion) dans le panneau latéral.

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

    3. Cliquez sur Login (Connexion).

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

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 dans la sortie de l'étape précédente.

    La création du cluster prend environ 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 le cluster.

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 Créer un cluster Bare Metal 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'utilisateurs est sélectionné. Le cluster d'administrateur et le cluster d'utilisateur doivent apparaître dans la liste.

  3. Connectez-vous au cluster d'utilisateur :

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

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

    3. Cliquez sur Login (Connexion).

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

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 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 exemple de 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 de l'exemple suivant :

    Le fichier de variables Terraform suivant, terraform.tfvars.sample, est prérempli avec des adresses IP et des 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 sur les clusters d'utilisateurs Google Distributed Cloud.

  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. 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 au moins 15 minutes. Vous pouvez afficher le cluster dans la console Google Cloud sur la page Clusters GKE.

  8. Dans Google Cloud 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 et le cluster d'utilisateur doivent apparaître dans la liste.

  9. Connectez-vous au cluster d'utilisateur :

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

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

    3. Cliquez sur Login (Connexion).

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

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 dans l'angle supérieur droit 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 comportant des pools de nœuds. Sans l'indicateur --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 créées lorsque vous avez exécuté terraform apply pour créer le cluster d'utilisateurs.

  • 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 et, lorsque vous y êtes invité, saisissez y :

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

    Étape suivante