Créer des clusters de base

Cette page est la deuxième partie d'un guide qui 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 montre 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 vous montre comment créer un cluster d'administrateur et un cluster d'utilisateur. Vous pouvez ensuite passer à la section Créer un service et une entrée.

Ce guide vous aide à créer une installation minimale de Google Distributed Cloud. Cette installation minimale peut ne pas être adaptée à vos besoins de production réels et à vos cas d'utilisation réels. Pour en savoir plus sur les installations en 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 de la configuration réseau de la section Prérequis du flux Créer un cluster d'administrateur GKE sur Bare Metal dans la console Google Cloud.

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

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

      gcloud components update
      
  3. Procédez comme suit pour activer et utiliser l'API GKE On-Prem:

    1. Activez l'API dans votre projet:

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

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

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

    2. Si vous activez l'API GKE On-Prem pour la première fois dans votre projet, vous devez initialiser l'API. Pour ce faire, appelez une commande de la 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 principales étapes suivantes:

  1. Recueillez des informations permettant de spécifier la configuration de vos clusters.

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

  3. Créez 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 fournies par Network Planner pour remplir chaque espace réservé du tableau suivant. Les espaces réservés correspondent aux valeurs des champs 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 de 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é de son nom. 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é de son nom. USER_CLUSTER_NAME
La 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œuds
Une adresse IP pour le nœud de 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 utilisables comme adresses IP externes pour les services de type LoadBalancer. Notez que cette plage inclut l'adresse IP virtuelle d'entrée, requise par MetalLB. Aucune autre adresse IP ne peut chevaucher cette plage. START_IP-END_IP
CIDR des pods et des services
Plage d'adresses IP au format de bloc CIDR à utiliser par les pods du cluster d'administrateur. La valeur de départ recommandée, qui est 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 de bloc CIDR à utiliser par les services sur le cluster d'administrateur. La valeur de départ recommandée, qui est 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 de bloc CIDR à utiliser par les pods du cluster d'utilisateur. La valeur de départ recommandée, qui est préremplie dans le fichier de configuration du cluster généré et qui est la valeur par défaut dans la console, est 192.168.0.0/16. 192.168.0.0/16
Plage d'adresses IP au format de bloc CIDR à utiliser par les services sur le cluster d'utilisateur. La valeur de départ recommandée, qui est préremplie dans le fichier de configuration du cluster généré et qui est la 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 d'un cluster d'administrateur et d'un cluster d'utilisateur. Assurez-vous d'avoir fourni des valeurs pour chaque espace réservé du tableau dans la section Collecter des informations précédente avant de continuer.

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 lorsque spec.gkeOnPremAPI n'est pas spécifié dans le fichier de configuration du cluster. L'inscription à 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 de 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 rempli 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 extrait 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 de votre poste de travail administrateur:

    bmctl create cluster -c ADMIN_CLUSTER_NAME
    

    La commande bmctl affiche les résultats à l'écran pendant qu'elle exécute des 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 du poste de travail administrateur.

    La création du cluster peut prendre plusieurs minutes.

  6. Vérifiez que votre cluster a été créé et qu'il 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 à votre compte utilisateur le rôle Kubernetes clusterrole/cluster-admin 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 d'utilisateur. Assurez-vous d'avoir fourni des valeurs pour chaque espace réservé du tableau de la section Collecter des informations précédente avant de continuer.

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 lorsque spec.gkeOnPremAPI n'est pas spécifié dans le fichier de configuration du cluster. Lorsque votre cluster est enregistré auprès de cette API hébergée par Google Cloud, vous pouvez gérer son cycle de vie à l'aide de la console Google Cloud ou de la 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.

  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 rempli 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 extrait 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 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-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 les résultats à l'écran pendant qu'elle exécute des 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 du poste de travail administrateur.

    La création du cluster peut prendre plusieurs minutes.

  5. Vérifiez que votre cluster a été créé et qu'il 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

Procédez comme suit pour créer un cluster d'utilisateur dans la console:

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

    Accéder à la page Créer un cluster GKE sur 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 préalables s'affiche.

  6. Sous Choisissez 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 que vous venez de créer 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 valeurs suivantes dans le champ Adresse IP du nœud du plan de contrôle 1:

    USER_CP_NODE_IP
    
  2. Dans la section Équilibreur de charge, utilisez l'équilibreur de charge par défaut, fourni 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 correspondant à l'adresse IP virtuelle du plan de contrôle:

    USER_CP_VIP
    
  6. Saisissez l'adresse IP de 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-les:

    • CIDR des services:
    10.96.0.0/20
    
    • CIDR de pod:
    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 est un modèle pour les 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 Nodes address 1 (Adresse des nœuds 1) :

USER_WORKER_NODE_IP

Créer le cluster

  1. Cliquez sur Verify and Create (Valider et créer) pour créer le cluster d'utilisateur.

    La création du cluster d'utilisateur prend 15 minutes ou plus. La console affiche des messages d'état pendant qu'elle vérifie les paramètres et crée le 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, puis réessayer de créer le cluster.

    Pour en savoir plus sur le processus de création, cliquez sur Afficher les détails afin d'afficher un panneau latéral. Cliquez sur pour fermer le panneau de détails.

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

    Cluster de captures d&#39;écran prêt

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

gcloud CLI

Cette section explique comment créer un cluster d'utilisateur et un pool de nœuds à l'aide de la 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 correspond au 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 environ 15 minutes ou plus. Lors de la création du cluster, vous pouvez exécuter la commande précédente de temps en temps pour obtenir son état actuel.

    Une fois le cluster créé, un résultat semblable aux lignes suivantes 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 celui-ci.

    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 obtenir plus d'informations et d'autres exemples, consultez les pages 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 de fichier doit comporter l'extension .tf. Dans ce guide, le fichier est nommé 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 à 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 toutes les bibliothèques nécessaires, comme le fournisseur Google Cloud.

  5. Examinez la configuration et apportez des modifications si nécessaire:

    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
    

    La valeur TIMESTAMP 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 qu'il 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 obtenir plus d'informations et d'autres exemples, consultez les pages suivantes:

Se connecter au cluster d'utilisateur

Quel que soit l'outil utilisé pour créer le cluster d'utilisateur, votre adresse e-mail reçoit les 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'emplacement 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 sur la page Paramètres de base du cluster dans la section Autorisation.

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

Les stratégies RBAC attribuées à votre adresse e-mail effectuent les opérations suivantes:

  • vous attribuer le rôle Kubernetes clusterrole/cluster-admin sur le cluster ;

  • vous permettre 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.

  • 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. Obtenez l'entrée kubeconfig qui peut accéder au cluster via la passerelle de connexion.

    gcloud container fleet memberships get-credentials USER_CLUSTER_NAME  \
    --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 pour le cluster d'administrateur. Vous devrez exécuter ces commandes sur le poste de travail administrateur.

Étapes suivantes