Cette page a été traduite par l'API Cloud Translation.

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

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.
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
```
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:

Recueillez des informations permettant de spécifier la configuration de vos clusters.
Créez un cluster d'administrateur pour gérer votre cluster d'utilisateur.
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:

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

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

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

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

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.

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

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

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

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

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:

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
Assurez-vous que PROJECT_ID est sélectionné dans la liste des projets Google Cloud.
Cliquez sur Créer un cluster.
Dans la boîte de dialogue, cliquez sur Sur site.
À côté de Bare Metal, cliquez sur Configurer. La page Conditions préalables s'affiche.
Sous Choisissez votre type de cluster, sélectionnez Créer un cluster d'utilisateur pour un cluster d'administrateur existant.
Cliquez sur Suivant.

Paramètres de base du cluster

Saisissez USER_CLUSTER_NAME comme nom du cluster d'utilisateur ou utilisez le nom par défaut.
Assurez-vous que le cluster d'administrateur que vous venez de créer est sélectionné.
Dans Emplacement de l'API GCP, sélectionnez us-central1.
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.
Cliquez sur Mise en réseau dans la barre de navigation de gauche.

Mise en réseau

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
```
Dans la section Équilibreur de charge, utilisez l'équilibreur de charge par défaut, fourni avec MetalLB.
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
```
Cliquez sur OK.
Dans la section Adresses IP virtuelles, saisissez l'adresse IP correspondant à l'adresse IP virtuelle du plan de contrôle:
```
USER_CP_VIP
```
Saisissez l'adresse IP de l'adresse IP virtuelle d'entrée:
```
USER_INGRESS_VIP
```
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
```
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

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

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

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.

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

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

Copiez la ressource Terraform dans main.tf et enregistrez le fichier.
Initialisez et créez le plan Terraform :
```
terraform init
```
Terraform installe toutes les bibliothèques nécessaires, comme le fournisseur Google Cloud.
Examinez la configuration et apportez des modifications si nécessaire:
```
terraform plan
```
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).
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é.

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:

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.

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

Créer un service et un objet Ingress
En savoir plus :
- La google_gkeonprem_bare_metal_clusterressource Terraform
- La passerelle de connexion