Version 1.15. Cette version n'est plus compatible. Pour en savoir plus sur la mise à niveau vers la version 1.16, consultez la section Mettre à niveau des clusters dans la dernière documentation. Pour en savoir plus sur les versions compatibles et non compatibles, consultez la page Historique des versions dans la dernière documentation.

Créer des clusters de base

Cette page est la deuxième partie d'un guide qui vous accompagne tout au long d'une démonstration de faisabilité de la GDCV pour 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 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 GKE sur Bare Metal. Cette installation minimale peut ne pas convenir à vos besoins de production et 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 d'exigences réseau dans la section Prérequis du parcours 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 devez utiliser 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 à l'aide du 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 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 les informations utilisées pour 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 Configurer une infrastructure minimale ou dans le planificateur de réseau pour remplir chaque espace réservé dans le tableau suivant. Les espaces réservés correspondent aux valeurs des champs des 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é 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œuds
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, 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 dans la notation de bloc CIDR à utiliser par les pods du cluster d'administrateur. La valeur de départ recommandée, préremplie dans le fichier de configuration de 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, préremplie dans le fichier de configuration de cluster généré, est `10.96.0.0/20`.	`10.96.0.0/20`
Plage d'adresses IP dans la notation de bloc CIDR à utiliser par les pods du cluster d'utilisateur. La valeur de départ recommandée, préremplie dans le fichier de configuration de cluster généré, est `192.168.0.0/16`.	`192.168.0.0/16`
Plage d'adresses IP dans la notation de bloc CIDR à utiliser par les services sur le cluster d'utilisateur. La valeur de départ recommandée, préremplie dans le fichier de configuration de cluster généré, 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 un cluster d'administrateur minimal et une installation de cluster d'utilisateur. Avant de continuer, assurez-vous d'avoir fourni des valeurs pour chaque espace réservé du tableau de la section Collecter des informations ci-dessus.

Pour créer un cluster d'administrateur pour l'installation minimale, procédez comme suit:

Définissez les identifiants par défaut que GKE sur Bare Metal 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 renseigné avec les valeurs que vous avez saisies dans le tableau de planification à 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

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 validé à l'étape précédente.
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 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 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 ressemble à ceci:

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é par souci 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 stratégie RBAC vous permet, entre autres, de vous connecter à votre cluster dans la console Google Cloud pour afficher plus de détails le concernant.

Vous pouvez éventuellement enregistrer le cluster dans l'API GKE On-Prem. Cette API hébergée par Google Cloud vous permet de gérer le cycle de vie du cluster d'administrateur à l'aide de la console Google Cloud ou de gcloud CLI.
```
gcloud container bare-metal admin-clusters enroll ADMIN_CLUSTER_NAME  \
    --project=PROJECT_ID \
    --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
    --location=us-central1
```

3. Créer un cluster d'utilisateur

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

Si vous utilisez Terraform pour créer le cluster d'utilisateur, celui-ci est automatiquement enregistré dans l'API GKE On-Prem. Cette API hébergée par Google Cloud vous permet de gérer le cycle de vie d'un cluster à l'aide de la console Google Cloud, de gcloud CLI et de Terraform. Si vous utilisez bmctl, vous pouvez éventuellement enregistrer le cluster dans l'API GKE On-Prem après la création du cluster.

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

`bmctl`

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 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 accorder l'autorisation 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 le concernant.

---
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
---
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 validé à l'étape précédente.
Créez le cluster d'utilisateur :
```
bmctl create cluster -c USER_CLUSTER_NAME \
--kubeconfig ADMIN_KUBECONFIG
```
La commande bmctl affiche le résultat à l'écran lorsqu'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 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 ressemble à ceci:

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

Si vous le souhaitez, enregistrez le cluster dans l'API GKE On-Prem:

gcloud container bare-metal clusters enroll USER_CLUSTER_NAME  \
  --project=PROJECT_ID \
  --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
  --location=us-central1

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 une solution Bare Metal.

Accéder à la page Créer un cluster GKE sur une solution Bare Metal
Assurez-vous que PROJECT_ID est sélectionné dans la liste des projets Google Cloud.
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 de cluster d'utilisateur ou utilisez la valeur par défaut.
Assurez-vous que le cluster d'administrateur que vous venez de créer est sélectionné.
Dans le champ Emplacement de l'API GCP, sélectionnez us-central1.
Dans Version GDCV pour Bare Metal, sélectionnez CLUSTER_VERSION ou utilisez la valeur 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 la commande suivante dans le champ Adresse IP 1 du nœud du plan de contrôle:
```
USER_CP_NODE_IP
```
Dans la section Équilibreur de charge, utilisez l'équilibreur de charge par défaut, Bundled with 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 de 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, vous pouvez utiliser les valeurs par défaut si vous n'avez pas modifié les CIDR des services et des pods dans le planificateur.

Si vous avez modifié les CIDR, saisissez ceux que vous souhaitez utiliser:
- CIDR des services:
```
10.96.0.0/20
```
- CIDR du 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 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

Cliquez sur 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 lors de la vérification des paramètres et de la création du cluster.

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

Lorsque le cluster est créé, É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 vérifier 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 de temps en temps la commande précédente pour obtenir l'état actuel.

Une fois le cluster créé, un résultat semblable à celui-ci 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 ressources 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 s'appelle 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 partie TIMESTAMP du nom de 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 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 ressemble à ceci:

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 ressources suivantes:

Se connecter au cluster d'utilisateur

Si vous avez créé le cluster d'utilisateur à l'aide de bmctl, votre adresse e-mail est incluse dans la section clusterSecurity de l'exemple de fichier de configuration utilisateur. Si vous avez créé le cluster à l'aide de Terraform, votre adresse e-mail est incluse dans la section security_config de l'exemple de ressource google_gkeonprem_bare_metal_cluster. Ces exemples configurent pour vous des stratégies de contrôle des accès basées sur les rôles (RBAC) qui effectuent les opérations suivantes:

Vous accorder 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 :
- google_gkeonprem_bare_metal_clusterRessource Terraform
- La passerelle de connexion