Créer des clusters de base

Cette page est la seconde partie d'un guide qui vous explique comment utiliser le logiciel Google Distributed Cloud (anciennement appelé Google Distributed Cloud Virtual) pour créer une petite installation de démonstration de faisabilité de clusters GKE sur votre matériel bare metal. La première partie, Configurer une infrastructure minimale, vous explique comment configurer votre matériel, planifier les adresses IP et configurer l'infrastructure Google Cloud nécessaire. Ce document s'appuie sur la configuration et la planification de la section précédente et explique comment créer un cluster d'administrateur et un cluster d'utilisateur. Vous pouvez ensuite passer à la section Créer un service et un Ingress.

Cette page s'adresse aux administrateurs, aux architectes et aux opérateurs qui configurent, surveillent et gèrent le cycle de vie de l'infrastructure technologique sous-jacente. Pour en savoir plus sur les rôles courants et les exemples de tâches que nous citons dans le contenu Google Cloud, consultez la section Rôles utilisateur et tâches courantes de l'utilisateur dans GKE Enterprise.

Ce guide vous aide à créer une installation minimale de Google Distributed Cloud. Cette installation minimale peut ne pas convenir à vos besoins de production et à vos cas d'utilisation réels. Pour en savoir plus sur les installations de production, consultez les guides d'installation.

Avant de commencer

  1. Assurez-vous d'avoir configuré le matériel et planifié vos adresses IP comme décrit dans la partie précédente de ce guide, Configurer une infrastructure minimale. Vous pouvez également utiliser le planificateur des exigences réseau dans la section Conditions préalables du flux Créer un cluster d'administrateur sur bare metal dans la console Google Cloud.

  2. Si vous souhaitez utiliser Terraform pour créer le cluster d'utilisateur, vous devez disposer de Terraform sur votre poste de travail administrateur ou sur un autre ordinateur.

    1. Assurez-vous que les derniers composants de Google Cloud CLI sont installés :

      gcloud components update

  3. Pour activer et utiliser l'API GKE On-Prem, procédez comme suit :

    1. Activez l'API dans votre projet :

      gcloud services enable \
    --project PROJECT_ID \
    gkeonprem.googleapis.com

      Remplacez PROJECT_ID par l'ID de votre projet hôte de parc.

      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 à Google Cloud CLI avec le compte ayant accès au projet.

    2. Si c'est la première fois que vous activez l'API GKE On-Prem dans votre projet, vous devez initialiser l'API. Pour ce faire, appelez une commande gcloud CLI qui affiche les versions disponibles que vous pouvez utiliser pour créer un cluster :

      gcloud container bare-metal clusters query-version-config \
    --project=PROJECT_ID \
    --location="us-central1"

Présentation de la procédure

La création de clusters de base comprend les étapes principales suivantes :

  1. Recueillir des informations pour spécifier la configuration de vos clusters.

  2. Créer un cluster d'administrateur pour gérer votre cluster d'utilisateur.

  3. Créer un cluster d'utilisateur pouvant exécuter vos charges de travail.

1. Recueillir des informations

Utilisez les informations que vous avez préparées dans la section Configurer une infrastructure minimale ou celles du planificateur de réseau pour renseigner chaque espace réservé dans le tableau suivant. Les espaces réservés correspondent aux valeurs de champ dans les fichiers de configuration du cluster pour l'installation minimale d'un cluster d'administrateur et d'un cluster d'utilisateur. Certains espaces réservés sont définis sur les valeurs préremplies du fichier de configuration du cluster généré, mais tous les espaces réservés sont modifiables.

Informations de base sur le cluster
Nom du cluster d'administrateur que vous créez. L'emplacement et le nom des artefacts de cluster sur le poste de travail administrateur sont basés sur le nom du cluster. L'espace de noms du cluster est dérivé du nom du cluster. ADMIN_CLUSTER_NAME
Nom du cluster d'utilisateur que vous créez. L'emplacement et le nom des artefacts de cluster sur le poste de travail administrateur sont basés sur le nom du cluster. L'espace de noms du cluster est dérivé du nom du cluster. USER_CLUSTER_NAME
Version de bmctl que vous avez téléchargée dans la première partie de ce guide. CLUSTER_VERSION
Informations sur le compte
Chemin d'accès au fichier de clé privée SSH sur votre poste de travail administrateur. Par défaut, le chemin d'accès est
/home/USERNAME/.ssh/id_rsa.		 SSH_PRIVATE_KEY_PATH
ID du projet Google Cloud que vous souhaitez utiliser pour connecter votre cluster à Google Cloud et afficher les journaux et les métriques. Ce projet est également appelé projet hôte du parc. PROJECT_ID
Adresse e-mail associée à votre compte Google Cloud. Exemple : alex@example.com. GOOGLE_ACCOUNT_EMAIL
Adresses IP des machines de nœud
Une adresse IP pour le nœud du plan de contrôle du cluster d'administrateur ADMIN_CP_NODE_IP
Une adresse IP pour le nœud du plan de contrôle du cluster d'utilisateur USER_CP_NODE_IP
Une adresse IP pour le nœud de calcul du cluster d'utilisateur. USER_WORKER_NODE_IP
Adresses IP virtuelles
Adresse IP virtuelle pour le serveur d'API Kubernetes du cluster d'administrateur. ADMIN_CP_VIP
Adresse IP virtuelle pour le serveur d'API Kubernetes du cluster d'utilisateur USER_CP_VIP
Une adresse IP virtuelle à utiliser comme adresse externe pour le proxy d'entrée. USER_INGRESS_VIP
Plage de dix adresses IP à utiliser comme adresses IP externes pour les services de type LoadBalancer. Notez que cette plage inclut l'adresse IP virtuelle d'entrée, qui est requise par MetalLB. Aucune autre adresse IP ne peut chevaucher cette plage. START_IP-END_IP
CIDR de pod et de service
Plage d'adresses IP au format CIDR à utiliser par les pods du cluster d'administrateur. La valeur de départ recommandée, préremplie dans le fichier de configuration du cluster généré, est 192.168.0.0/16. 192.168.0.0/16
Plage d'adresses IP au format CIDR à utiliser par les services du cluster d'administrateur. La valeur de départ recommandée, préremplie dans le fichier de configuration du cluster généré, est 10.96.0.0/20. 10.96.0.0/20
Plage d'adresses IP au format CIDR à utiliser par les pods du cluster d'utilisateur. La valeur de départ recommandée, préremplie dans le fichier de configuration du cluster généré et utilisée comme valeur par défaut dans la console, est 192.168.0.0/16. 192.168.0.0/16
Plage d'adresses IP au format CIDR à utiliser par les services du cluster d'utilisateur. La valeur de départ recommandée, préremplie dans le fichier de configuration du cluster généré et utilisée comme valeur par défaut dans la console, est 10.96.0.0/20. 10.96.0.0/20

2. Créer un cluster d'administrateur

Les étapes suivantes permettent de créer un cluster d'administrateur pour une installation minimale de cluster d'administrateur et de cluster d'utilisateur. Avant de continuer, assurez-vous d'avoir fourni des valeurs pour chaque espace réservé dans le tableau de la section Recueillir des informations précédente.

Lorsque l'API GKE On-Prem (gkeonprem.googleapis.com) est activée pour votre projet, les clusters nouvellement créés sont automatiquement enregistrés auprès de l'API. L'enregistrement a lieu même si spec.gkeOnPremAPI n'est pas spécifié dans le fichier de configuration du cluster. L'enregistrement avec cette API hébergée par Google Cloud vous permet de gérer le cycle de vie de votre cluster à l'aide de la console Google Cloud ou de gcloud CLI.

Pour désactiver l'enregistrement automatique, annulez la mise en commentaire de la section spec.gkeOnPremAPI dans le fichier de configuration du cluster et définissez spec.gkeOnPremAPI.enabled sur false avant de créer le cluster. Le champ spec.gkeOnPremAPI.enabled est modifiable. Vous pouvez donc annuler l'enregistrement de votre cluster à tout moment après sa création.

Pour créer un cluster d'administrateur pour l'installation minimale :

  1. Définissez les identifiants par défaut que Google Distributed Cloud peut utiliser pour créer le cluster à l'aide de la commande suivante :

    gcloud auth application-default login

  2. Pour générer un fichier de configuration de cluster, exécutez la commande suivante à partir du répertoire /baremetal sur votre poste de travail administrateur :

    bmctl create config -c ADMIN_CLUSTER_NAME \
    --enable-apis --create-service-accounts --project-id=PROJECT_ID

  3. 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 saisies dans le tableau de planification de la section précédente. 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 spécification NodePool a été supprimée. Les nœuds de calcul ne sont pas autorisés pour un cluster d'administrateur.
    gcrKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-gcr.json
sshPrivateKeyPath: SSH_PRIVATE_KEY_PATH
gkeConnectAgentServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-connect.json
gkeConnectRegisterServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-register.json
cloudOperationsServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-cloud-ops.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: CLUSTER_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: ADMIN_CP_NODE_IP
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 10.96.0.0/20
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: ADMIN_CP_VIP
  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: 250
  # GKEOnPremAPI (Optional) Specify if you wish to explicitly enable/disable the cloud hosted gkeonprem
  # API to enable/disable cluster lifecycle management from gcloud UI and Terraform.
  # gkeOnPremAPI:
    # enabled: false
    # location is the Cloud location for the cluster resource metadata where the cluster will be enrolled.
    # location: us-central1

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

  5. Pour créer le cluster d'administrateur, exécutez la commande suivante à partir du répertoire /baremetal sur votre poste de travail 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/ADMIN_CLUSTER_NAME/log sur le poste de travail administrateur.

    La création du cluster peut prendre plusieurs minutes.

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

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

    Si votre cluster est en cours d'exécution, la réponse se présente comme suit :

    NAME     STATUS  ROLES          AGE  VERSION
node-01  Ready   control-plane  16h  v1.25.7-gke.1000

  7. Pour attribuer le rôle Kubernetes clusterrole/cluster-admin à votre compte utilisateur sur le cluster, exécutez la commande gcloud suivante :

    gcloud container fleet memberships generate-gateway-rbac \
    --membership=ADMIN_CLUSTER_NAME \
    --role=clusterrole/cluster-admin \
    --users=GOOGLE_ACCOUNT_EMAIL \
    --project=PROJECT_ID \
    --kubeconfig=bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig \
    --context=ADMIN_CLUSTER_NAME-admin@ADMIN_CLUSTER_NAME \
    --apply

    Le résultat de cette commande ressemble à ce qui suit, qui est tronqué pour des raisons de lisibilité :

    Validating input arguments.
Specified Cluster Role is: clusterrole/cluster-admin
Generated RBAC policy is:
--------------------------------------------
...

Applying the generate RBAC policy to cluster with kubeconfig: /root/bmctl-workspace/<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>/<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>-kubeconfig, context: <var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>-admin@<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>
Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
Successfully applied the RBAC policy to cluster.

    La règle RBAC vous permet, entre autres, de vous connecter à votre cluster dans la console Google Cloud pour afficher plus de détails sur le cluster.

3. Créer un cluster d'utilisateur

Les étapes suivantes permettent de créer un cluster d'utilisateur pour une installation minimale de cluster d'administrateur et de cluster d'utilisateur. Avant de continuer, assurez-vous d'avoir fourni des valeurs pour chaque espace réservé dans le tableau de la section Recueillir des informations.

Pour créer un cluster d'utilisateur pour l'installation minimale :

bmctl

Lorsque l'API GKE On-Prem (gkeonprem.googleapis.com) est activée pour votre projet, les clusters nouvellement créés sont automatiquement enregistrés auprès de l'API. L'enregistrement a lieu même si spec.gkeOnPremAPI n'est pas spécifié dans le fichier de configuration du cluster. Lorsque votre cluster est enregistré avec cette API hébergée par Google Cloud, vous pouvez utiliser la console Google Cloud ou gcloud CLI pour gérer le cycle de vie du cluster.

Pour désactiver l'enregistrement automatique, annulez la mise en commentaire de la section spec.gkeOnPremAPI dans le fichier de configuration du cluster et définissez spec.gkeOnPremAPI.enabled sur false avant de créer le cluster. Le champ spec.gkeOnPremAPI.enabled est modifiable. Vous pouvez donc annuler l'enregistrement de votre cluster à tout moment après sa création.

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

    bmctl create config -c USER_CLUSTER_NAME \
  --project-id=PROJECT_ID

  2. Vérifiez le fichier de configuration du cluster d'utilisateur :

    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é.
    • 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 console Google Cloud pour afficher plus de détails sur le cluster.
    ---
apiVersion: v1
kind: Namespace
metadata:
  name: cluster-USER_CLUSTER_NAME
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: USER_CLUSTER_NAME
  namespace: cluster-USER_CLUSTER_NAME
spec:
  type: user
  profile: default
  anthosBareMetalVersion: CLUSTER_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: USER_CP_NODE_IP
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 10.96.0.0/20
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: USER_CP_VIP
      ingressVIP: USER_INGRESS_VIP
    addressPools:
    - name: pool1
      addresses:
      - START_IP-END_IP
  clusterOperations:
    projectID: PROJECT_ID
    location: us-central1
  clusterSecurity:
    authorization:
      clusterAdmin:
        gcpAccounts:
        - GOOGLE_ACCOUNT_EMAIL
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 250
  # GKEOnPremAPI (Optional) Specify if you wish to explicitly enable/disable the cloud hosted gkeonprem
  # API to enable/disable cluster lifecycle management from gcloud UI and Terraform.
  # gkeOnPremAPI:
    # enabled: false
    # location is the Cloud location for the cluster resource metadata where the cluster will be enrolled.
    # location: us-central1
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-USER_CLUSTER_NAME
spec:
  clusterName: USER_CLUSTER_NAME
  nodes:
  - address: USER_WORKER_NODE_IP

  3. 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/USER_CLUSTER_NAME/USER_CLUSTER_NAME.yaml, et remplacez son contenu par celui de l'exemple que vous avez vérifié à l'étape précédente.

  4. Créez le cluster d'utilisateur :

    bmctl create cluster -c USER_CLUSTER_NAME \
--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/USER_CLUSTER_NAME/log sur le poste de travail administrateur.

    La création du cluster peut prendre plusieurs minutes.

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

    kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-kubeconfig \
  get nodes

    Si votre cluster est en cours d'exécution, la réponse se présente comme suit :

    NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

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 PROJECT_ID est sélectionné dans la liste des projets Google Cloud.

  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 USER_CLUSTER_NAME comme nom du cluster d'utilisateur ou utilisez le nom par défaut.

  2. Assurez-vous que le cluster d'administrateur nouvellement créé est sélectionné.

  3. Dans Emplacement de l'API GCP, sélectionnez us-central1.

  4. Dans Version Google Distributed Cloud, sélectionnez CLUSTER_VERSION ou utilisez la version par défaut. Vous pouvez utiliser les valeurs par défaut pour les autres paramètres de cette page.

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

Mise en réseau

  1. Dans la section Plan de contrôle, saisissez les informations suivantes dans le champ Adresse IP du nœud de plan de contrôle 1 :

    USER_CP_NODE_IP

  2. Dans la section Équilibreur de charge, utilisez l'équilibreur de charge par défaut, Groupé avec MetalLB.

  3. Accédez à la section Nouveau pool d'adresses. Saisissez la plage d'adresses IP 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 pour l'adresse IP virtuelle du plan de contrôle:

    USER_CP_VIP

  6. Saisissez l'adresse IP pour l'adresse IP virtuelle d'entrée :

    USER_INGRESS_VIP

  7. Dans la section CIDR des services et des pods, si vous n'avez pas modifié les CIDR des services et des pods dans le planificateur, vous pouvez utiliser les valeurs par défaut.

    Si vous avez modifié les CIDR, saisissez ceux que vous souhaitez utiliser :

    • CIDR des services :
    10.96.0.0/20
    • CIDR des pods :
    192.168.0.0/16

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

Créer un pool de nœuds

Votre cluster doit comporter au moins un pool de nœuds pour les nœuds de calcul. Un pool de nœuds représente le modèle des groupes de nœuds de calcul créés dans ce cluster.

Saisissez l'adresse IP du nœud de calcul du cluster d'utilisateur dans le champ Adresse des nœuds 1 :

USER_WORKER_NODE_IP

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.

CLI gcloud

Cette section explique comment créer un cluster d'utilisateur et un pool de nœuds à l'aide de gcloud CLI.

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

    gcloud container bare-metal clusters create USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=us-central1 \
  --admin-cluster-membership=ADMIN_CLUSTER_NAME \
  --admin-cluster-membership-project=PROJECT_ID \
  --admin-cluster-membership-location=global \
  --version=CLUSTER_VERSION \
  --admin-users=GOOGLE_ACCOUNT_EMAIL \
  --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
  --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
  --metal-lb-address-pools='pool=lb-pool-1,manual-assign=True,addresses=START_IP-END_IP' \
  --control-plane-node-configs='node-ip=USER_CP_NODE_IP' \
  --control-plane-vip=USER_CP_VIP \
  --control-plane-load-balancer-port=443 \
  --ingress-vip=USER_INGRESS_VIP \
  --lvp-share-path=/mnt/localpv-share \
  --lvp-share-storage-class=local-shared \
  --lvp-node-mounts-config-path=/mnt/localpv-disk \
  --lvp-node-mounts-config-storage-class=local-disks

    La 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 connaître l'état de l'opération à l'aide de la commande suivante :

    gcloud container bare-metal operations describe OPERATION_ID \
  --project=PROJECT_ID \
  --location=us-central1

    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/us-central1/bareMetalClusters/USER_CLUSTER_NAME].

  2. Une fois le cluster créé, exécutez la commande suivante pour créer un pool de nœuds sur le cluster nouvellement créé.

    gcloud container bare-metal node-pools create node-pool-1 \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=us-central1 \
  --node-configs node-ip=USER_WORKER_NODE_IP

Pour en savoir plus et obtenir d'autres exemples, consultez les sections suivantes :

Terraform

Cette section explique comment créer un cluster d'utilisateur et un pool de nœuds à l'aide de Terraform.

  1. Créez un répertoire et un nouveau fichier dans ce répertoire. Le nom du fichier doit comporter l'extension .tf. Dans ce guide, le fichier est appelé main.tf.

    mkdir DIRECTORY && cd DIRECTORY && touch main.tf

  2. Vérifiez la ressource Terraform du cluster d'utilisateur :

    L'exemple de ressource Terraform suivant est renseigné avec les valeurs que vous avez saisies dans le tableau de planification de la section précédente.

    resource "google_gkeonprem_bare_metal_cluster"  "cluster-basic" {
  provider = google-beta
  name = "USER_CLUSTER_NAME"
  project = "PROJECT_ID"
  location = "us-central1"
  admin_cluster_membership = "projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME"
  bare_metal_version = "CLUSTER_VERSION"
  network_config {
    island_mode_cidr {
      service_address_cidr_blocks = ["10.96.0.0/20"]
      pod_address_cidr_blocks = ["192.168.0.0/16"]
    }
  }
  control_plane {
    control_plane_node_pool_config {
      node_pool_config {
        labels = {}
        operating_system = "LINUX"
        node_configs {
          labels = {}
          node_ip = "USER_CP_NODE_IP"
        }
      }
    }
  }
  load_balancer {
    port_config {
      control_plane_load_balancer_port = 443
    }
    vip_config {
      control_plane_vip = "USER_CP_VIP"
      ingress_vip = "USER_INGRESS_VIP"
    }
    metal_lb_config {
      address_pools {
        pool = "pool1"
        addresses = [
          "START_IP-END_IP"
        ]
        avoid_buggy_ips = true
        manual_assign = true
      }
    }
  }
  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"
    }
  }
  security_config {
    authorization {
      admin_users {
        username = "GOOGLE_ACCOUNT_EMAIL"
      }
    }
  }
}

resource "google_gkeonprem_bare_metal_node_pool" "node-pool-default" {
  provider = google-beta
  name =  "node-pool-1"
  bare_metal_cluster = google_gkeonprem_bare_metal_cluster.cluster-basic.name
  project = "PROJECT_ID"
  location = "us-central1"
  node_pool_config {
    operating_system = "LINUX"
    node_configs {
      node_ip = "USER_WORKER_NODE_IP"
    }
  }
}

  3. Copiez la ressource Terraform dans main.tf et enregistrez le fichier.

  4. Initialisez et créez le plan Terraform :

    terraform init

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

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

    terraform plan

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

    terraform apply

    Lorsque vous y êtes invité, saisissez yes.

    La création du cluster d'utilisateur et du pool de nœuds de base prend environ 15 minutes (ou plus, selon votre réseau).

  7. Pour créer un fichier kubeconfig pour le cluster d'utilisateur, exécutez la commande suivante sur le poste de travail administrateur :

    bmctl get credentials --cluster USER_CLUSTER_NAME \
--admin-kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig

    Le résultat de la commande affiche le nom du fichier kubeconfig pour le cluster d'utilisateur, par exemple :

    bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig

    L'élément TIMESTAMP figurant dans le nom du fichier indique la date et l'heure de création du fichier.

    Comme ce fichier contient les identifiants d'authentification de votre cluster, vous devez le stocker dans un emplacement sécurisé avec accès limité.

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

    kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig \
    get nodes

    Si votre cluster est en cours d'exécution, la réponse se présente comme suit :

    NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

Pour en savoir plus et obtenir d'autres exemples, consultez les sections suivantes :

Se connecter au cluster d'utilisateur

Quel que soit l'outil que vous avez utilisé pour créer le cluster d'utilisateur, votre adresse e-mail bénéficie des stratégies de contrôle des accès basé sur les rôles (RBAC) qui vous permettent de vous connecter au cluster avec des droits d'administrateur complets. L'endroit où votre adresse e-mail est spécifiée dépend de l'outil :

  • bmctl : votre adresse e-mail est incluse dans la section clusterSecurity de l'exemple de fichier de configuration utilisateur.

  • Terraform : votre adresse e-mail est incluse dans la section security_config de l'exemple de ressource google_gkeonprem_bare_metal_cluster.

  • La console : en tant que créateur du cluster, votre adresse e-mail est automatiquement incluse dans la section Autorisation de la page Paramètres de base du cluster.

Bien que seule votre adresse e-mail soit spécifiée, vous pouvez inclure d'autres adresses e-mail pour accorder l'accès administrateur au cluster à d'autres utilisateurs.

Les stratégies RBAC attribuées à votre adresse e-mail :

  • Vous attribuent le rôle clusterrole/cluster-admin Kubernetes sur le cluster.

  • Vous permettent de vous connecter au cluster dans la console Google Cloud à l'aide de votre identité Google. Vous pouvez afficher le cluster sur la page Clusters GKE de la console.

  • Vous permettent d'exécuter des commandes kubectl sur votre ordinateur local à l'aide du fichier kubeconfig de la passerelle de connexion.

Pour obtenir le fichier kubeconfig de la passerelle de connexion, exécutez les commandes suivantes à partir de votre ordinateur local :

  1. Récupèrent l'entrée kubeconfig qui peut accéder au cluster via la passerelle de connexion.

    gcloud container fleet memberships get-credentials USER_CLUSTER_NAME  \
--project=PROJECT_ID

    Le résultat ressemble à ce qui suit :

    Starting to build Gateway kubeconfig...
Current project_id: PROJECT_ID
A new kubeconfig entry "connectgateway_PROJECT_ID_global_USER_CLUSTER_NAME" has been generated and set as the current context.

  2. Vous pouvez maintenant exécuter des commandes kubectl via la passerelle de connexion :

    kubectl get nodes

    Le résultat ressemble à ce qui suit :

    NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

    De nombreuses commandes kubectl nécessitent le fichier kubeconfig du cluster d'administrateur. Vous devrez exécuter ces commandes sur le poste de travail administrateur.

Étape suivante