Créer des clusters de base

Il s'agit de la deuxième partie d'un guide qui vous guide à travers une petite installation de démonstration de faisabilité de GKE sur VMware. La première partie, Configurer une infrastructure minimale, explique comment planifier vos adresses IP et configurer l'infrastructure vSphere et Google Cloud nécessaires à votre déploiement. Ce document s'appuie sur la configuration et la planification que vous avez effectuées dans la section précédente. Il vous explique comment créer un poste de travail administrateur, un cluster d'administrateur et un cluster d'utilisateur dans votre environnement vSphere à l'aide de modèles simples que vous pouvez remplir ici dans ce document. Vous pouvez ensuite déployer une application.

Comme pour la configuration d'infrastructure de cette installation simple, les clusters que vous configurez à l'aide de ce document peuvent ne pas être adaptés à vos besoins de production et cas d'utilisation réels. Pour obtenir plus d'informations, des bonnes pratiques et des instructions concernant les installations en production, consultez les guides d'installation.

Avant de commencer

  1. Assurez-vous d'avoir configuré vos environnements vSphere et Google Cloud comme décrit dans la section Configurer une infrastructure minimale.

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

Présentation de la procédure

Voici les principales étapes de cette configuration:

  1. Connectez-vous à la Google Cloud CLI avec un compte disposant des autorisations nécessaires pour créer des comptes de service.

  2. Rassemblez les informations dont vous avez besoin pour configurer GKE sur VMware, y compris votre nom d'utilisateur et votre mot de passe vCenter, ainsi que les adresses IP que vous avez préparées dans la section précédente.

  3. Créez un poste de travail administrateur disposant des ressources et des outils dont vous avez besoin pour créer des clusters d'administrateur et d'utilisateur, y compris les comptes de service supplémentaires dont vous avez besoin pour terminer la configuration.

  4. Créez un cluster d'administrateur pour gérer et mettre à jour votre cluster d'utilisateur.

  5. Créez un cluster d'utilisateur pour exécuter vos charges de travail.

1. Se connecter à la Google Cloud CLI

La configuration de GKE sur VMware nécessite plusieurs comptes de service avec des autorisations différentes. Bien que vous deviez créer le compte de service d'accès au composant manuellement, l'outil de ligne de commande gkeadm peut créer et configurer les comptes restants pour vous lors de la création du poste de travail administrateur. Pour ce faire, vous devez être connecté à la Google Cloud CLI avec un compte disposant des autorisations nécessaires pour créer et configurer des comptes de service, car gkeadm utilise votre propriété gcloud CLI account lors de cette configuration.

  1. Connectez-vous à la gcloud CLI. Vous pouvez utiliser n'importe quel compte Google, mais celui-ci doit disposer des autorisations requises. Si vous avez suivi la partie précédente de ce guide, vous êtes probablement déjà connecté avec un compte approprié pour créer votre compte de service d'accès au composant.

    gcloud auth login

  2. Vérifiez que la propriété account de la gcloud CLI est correctement définie:

    gcloud config list

    Le résultat affiche la valeur de la propriété account du SDK. Exemple :

    [core]
account = my-name@google.com
disable_usage_reporting = False
Your active configuration is: [default]

  3. Assurez-vous que les derniers composants de la gcloud CLI sont installés:

    gcloud components update

    Selon la manière dont vous avez installé la gcloud CLI, le message suivant peut s'afficher: "Vous ne pouvez pas effectuer cette action, car le gestionnaire de composants de la Google Cloud CLI est désactivé pour cette installation. Vous pouvez exécuter la commande suivante pour obtenir le même résultat pour cette installation:" Suivez les instructions pour copier et coller la commande afin de mettre à jour les composants.

2. Recueillir des informations

Utilisez les informations que vous avez préparées dans Configurer une infrastructure minimale pour modifier les espaces réservés dans le tableau suivant:

Détails vSphere
Nom d'utilisateur de votre compte vCenter USERNAME
Mot de passe de votre compte vCenter PASSWORD
Votre adresse vCenter Server ADDRESS
Chemin d'accès au certificat CA racine de votre serveur vCenter, sur la machine que vous allez utiliser pour créer votre poste de travail administrateur CA_CERT_PATH
Le nom de votre centre de données vSphere DATA_CENTER
Le nom de votre cluster vSphere VSPHERE_CLUSTER
Nom ou chemin d'accès de votre pool de ressources vSphere. Pour en savoir plus, consultez la page vcenter.resourcePool. RESOURCE_POOL
Nom de votre Datastore vSphere DATASTORE
Le nom de votre réseau vSphere NETWORK
Adresses IP
Une adresse IP pour votre poste de travail administrateur ADMIN_WS_IP
Quatre adresses IP pour les nœuds de votre cluster d'administrateur. Cela inclut l'adresse d'un nœud supplémentaire qui peut être utilisé lors de la mise à niveau. ADMIN_CONTROL_PLANE_NODE_IP_1
ADMIN_CONTROL_PLANE_NODE_IP_2
ADMIN_CONTROL_PLANE_NODE_IP_3
Adresse IP du nœud du plan de contrôle dans le cluster d'utilisateur. USER_CONTROL_PLANE_NODE_IP
Quatre adresses IP pour les nœuds de votre cluster d'utilisateur. Cela inclut l'adresse d'un nœud supplémentaire qui peut être utilisé lors de la mise à niveau. USER_NODE_IP_1
USER_NODE_IP_2
USER_NODE_IP_3
USER_NODE_IP_4
Une adresse IP virtuelle pour le serveur d'API Kubernetes du cluster d'administrateur ADMIN_CONTROL_PLANE_VIP
Une adresse IP virtuelle pour le serveur d'API Kubernetes du cluster d'utilisateur USER_CONTROL_PLANE_VIP
Une adresse IP virtuelle d'entrée pour le cluster d'utilisateur USER_INGRESS_VIP
Deux adresses IP virtuelles pour les services de type LoadBalancer dans votre cluster d'utilisateur. SERVICE_VIP_1
SERVICE_VIP_2
Adresse IP d'un serveur DNS accessible depuis votre poste de travail administrateur et vos nœuds de cluster DNS_SERVER_IP
Adresse IP d'un serveur NTP accessible depuis votre poste de travail administrateur et vos nœuds de cluster NTP_SERVER_IP
Adresse IP de la passerelle par défaut pour le sous-réseau contenant votre poste de travail administrateur et vos nœuds de cluster DEFAULT_GATEWAY_IP
Masque de réseau du sous-réseau qui contient votre poste de travail administrateur et vos nœuds de cluster
Exemple: 255.255.255.0		 NETMASK
Si votre réseau se trouve derrière un serveur proxy, l'URL de ce serveur. Pour plus d'informations, consultez la section proxy. Remplissez-le manuellement dans le fichier de configuration de votre poste de travail administrateur, si nécessaire. PROXY_URL
Plages CIDR pour les services et les pods
Le cluster d'administrateur et le cluster d'utilisateur ont chacun besoin d'une plage CIDR pour les services et d'une plage CIDR pour les pods. Utilisez les valeurs préremplies suivantes, sauf si vous avez besoin de les modifier pour éviter tout chevauchement avec d'autres éléments de votre réseau:
Une plage CIDR pour les services du cluster d'administrateur 10.96.232.0/24
Une plage CIDR pour les pods du cluster d'administrateur 192.168.0.0/16
Plage CIDR pour les services du cluster d'utilisateur 10.96.0.0/20
Une plage CIDR pour les pods du cluster d'utilisateur 192.168.0.0/16
Détails Google Cloud
L'ID du projet Cloud que vous avez choisi PROJECT_ID
Chemin d'accès au fichier de clé JSON du compte de service d'accès au composant que vous avez configuré dans la section précédente, sur la machine que vous allez utiliser pour créer votre poste de travail administrateur. COMPONENT_ACCESS_SA_KEY_PATH
Adresse e-mail associée à votre compte Google Cloud. Exemple : alex@example.com. GOOGLE_ACCOUNT_EMAIL

3. Créer un poste de travail d'administrateur

Avant de pouvoir créer des clusters, vous devez créer un poste de travail administrateur, puis vous y connecter à l'aide de SSH. Le poste de travail administrateur est une VM autonome avec les outils et les ressources dont vous avez besoin pour créer des clusters GKE Enterprise dans votre environnement vSphere. L'outil de ligne de commande gkeadm permet de créer le poste de travail administrateur.

Télécharger gkeadm

Téléchargez gkeadm dans votre répertoire actuel:

gsutil cp gs://gke-on-prem-release/gkeadm/1.28.300-gke.123/linux/gkeadm ./
chmod +x gkeadm

Vous avez besoin de la version gkeadm (qui est également la version de GKE sur VMware) pour créer vos fichiers de configuration de cluster d'administrateur et d'utilisateur. Pour vérifier la version de gkeadm, exécutez la commande suivante:

./gkeadm version

L'exemple de résultat suivant indique la version.

gkeadm 1.28.400 (1.28.300-gke.123)

Bien que vous puissiez télécharger une autre version de gkeadm, ce guide suppose que vous installez la version 1.28.300-gke.123 et l'utilise dans tous les fichiers de configuration et commandes.

Créer votre fichier d'identifiants

Dans votre répertoire actuel, créez et enregistrez un fichier nommé credential.yaml avec le contenu suivant:

apiVersion: v1
kind: CredentialFile
items:
- name: vCenter
  username: "USERNAME"
  password: "PASSWORD"

Créer le fichier de configuration de votre poste de travail administrateur

Créez et enregistrez un fichier nommé admin-ws-config.yaml, toujours dans votre répertoire actuel, avec le contenu suivant:

gcp:
  componentAccessServiceAccountKeyPath: "COMPONENT_ACCESS_SA_KEY_PATH"
vCenter:
  credentials:
    address: "ADDRESS"
    fileRef:
      path: "credential.yaml"
      entry: "vCenter"
  datacenter: "DATA_CENTER"
  datastore: "DATASTORE"
  cluster: "VSPHERE_CLUSTER"
  network: "NETWORK"
  resourcePool: "RESOURCE_POOL"
  caCertPath: "CA_CERT_PATH"
proxyUrl: ""
adminWorkstation:
  name: "minimal-installation-admin-workstation"
  cpus: 4
  memoryMB: 8192
  diskGB: 50
  dataDiskName: gke-on-prem-admin-workstation-data-disk/minimal-installation-data-disk.vmdk
  dataDiskMB: 512
  network:
    ipAllocationMode: "static"
    hostConfig:
      ip: "ADMIN_WS_IP"
      gateway: "DEFAULT_GATEWAY_IP"
      netmask: "NETMASK"
      dns:
      - "DNS_SERVER_IP"
  proxyUrl: ""
  ntpServer: ntp.ubuntu.com

Créer votre poste de travail administrateur

Créez votre poste de travail administrateur à l'aide de la commande suivante:

./gkeadm create admin-workstation --auto-create-service-accounts

Exécuter cette commande:

  • crée le poste de travail administrateur ;
  • Crée automatiquement les comptes de service supplémentaires dont vous avez besoin pour votre installation
  • Crée des fichiers de configuration de modèles pour vos clusters d'administrateur et d'utilisateur

La sortie donne des informations détaillées sur la création de votre poste de travail administrateur et fournit une commande que vous pouvez utiliser pour obtenir une connexion SSH à votre poste de travail administrateur :

...
Admin workstation is ready to use.
Admin workstation information saved to /usr/local/google/home/me/my-admin-workstation
This file is required for future upgrades
SSH into the admin workstation with the following command:
ssh -i /usr/local/google/home/me/.ssh/gke-admin-workstation ubuntu@172.16.20.49
********************************************************************

Pour en savoir plus sur la création d'un poste de travail administrateur, consultez la section Créer un poste de travail administrateur.

Se connecter au poste de travail administrateur

Utilisez la commande affichée dans le résultat précédent pour obtenir une connexion SSH à votre poste de travail administrateur. Exemple :

ssh -i /usr/local/google/home/me/.ssh/gke-admin-workstation ubuntu@172.16.20.49

Si vous avez besoin de retrouver cette commande, gkeadm génère un fichier nommé gke-admin-ws-... dans le répertoire de l'ordinateur local sur lequel vous avez exécuté gkeadm create admin-workstation. Ce fichier contient des informations sur votre poste de travail administrateur, y compris la commande SSH.

Sur votre poste de travail administrateur, saisissez exit pour interrompre la connexion SSH et revenir à votre ordinateur local.

Copier la clé de journalisation d'audit sur votre poste de travail administrateur

Dans la section précédente, vous avez créé un fichier de clé JSON pour votre compte de service de journalisation d'audit.

Copiez le fichier de clé JSON dans le répertoire d'accueil de votre poste de travail administrateur. Par exemple, sur votre ordinateur local :

scp -i /usr/local/google/home/me/.ssh/gke-admin-workstation audit-logging-key.json ubuntu@172.16.20.49:~

Afficher les fichiers sur votre poste de travail administrateur

Une fois encore, obtenez une connexion SSH à votre poste de travail administrateur.

Sur votre poste de travail administrateur, répertoriez les fichiers du répertoire d'accueil:

ls -1

Le résultat doit inclure:

  • admin-cluster.yaml, un fichier de configuration de modèle pour créer votre cluster d'administrateur.
  • user-cluster.yaml, un fichier de configuration de modèle pour créer votre cluster d'utilisateur.
  • Le fichier de certificat vCenter que vous avez spécifié dans la configuration de votre poste de travail administrateur
  • Le fichier credential.yaml que vous avez spécifié dans la configuration de votre poste de travail administrateur.
  • Fichier de clé JSON pour votre compte de service de journalisation d'audit.
  • Fichiers de clé JSON de deux comptes de service créés par gkeadm: un compte de service connect-register et un compte de service logging-monitoring, ainsi que le fichier de clé du compte de service d'accès au composant que vous avez créé précédemment.

Exemple :

admin-cluster.yaml
admin-ws-config.yaml
audit-logging-key.json
sa-key.json
connect-register-sa-2203040617.json
credential.yaml
log-mon-sa-2203040617.json
logs
vc01-cert.pem
user-cluster.yaml

Vous devrez spécifier certains de ces noms de fichiers dans vos fichiers de configuration pour créer des clusters. Utilisez les noms de fichiers comme valeurs pour les espaces réservés dans le tableau suivant:

Nom de fichier de la clé de compte de service Connect-register
Exemple: connect-register-sa-2203040617.json		 CONNECT_REGISTER_SA_KEY
Nom de fichier de la clé du compte de service Logging-monitoring
Exemple: log-mon-sa-2203040617.json		 LOG_MON_SA_KEY
Nom du fichier de clé du compte de service pour les journaux d'audit
Exemple: audit-logging-key.json		 AUDIT_LOG_SA_KEY
Nom du fichier de clé du compte de service d'accès au composant
Exemple: sa-key.json		 COMPONENT_ACCESS_SA_KEY
Nom du fichier de certificat vCenter
Exemple: vc01-cert.pem		 CA_CERT_FILE

4. Créer un cluster d'administrateur

Maintenant que vous disposez d'un poste de travail administrateur configuré avec vCenter et d'autres détails, vous pouvez l'utiliser pour créer un cluster d'administrateur dans votre environnement vSphere. Avant de commencer cette étape, assurez-vous de disposer d'une connexion SSH à votre poste de travail administrateur, comme décrit précédemment. Toutes les commandes suivantes sont exécutées sur le poste de travail administrateur.

Créer le fichier de configuration de votre cluster d'administrateur

Ouvrez admin-cluster.yaml et remplacez le contenu par ce qui suit:

apiVersion: v1
kind: AdminCluster
name: "minimal-installation-admin-cluster"
bundlePath: "/var/lib/gke/bundles/gke-onprem-vsphere-1.28.300-gke.123-full.tgz"
vCenter:
  address: "ADDRESS"
  datacenter: "DATA_CENTER"
  cluster: "VSPHERE_CLUSTER"
  resourcePool: "RESOURCE_POOL"
  datastore: "DATASTORE"
  caCertPath: "CA_CERT_FILE"
  credentials:
    fileRef:
      path: "credential.yaml"
      entry: "vCenter"
network:
  hostConfig:
    dnsServers:
    - "DNS_SERVER_IP"
    ntpServers:
    - "NTP_SERVER_IP"
  serviceCIDR: "10.96.232.0/24"
  podCIDR: "192.168.0.0/16"
  vCenter:
    networkName: "NETWORK"
  controlPlaneIPBlock:
    netmask: "NETMASK"
    gateway: "DEFAULT_GATEWAY_IP"
    ips:
    - ip: "ADMIN_CONTROL_PLANE_NODE_IP_1"
      hostname: "admin-cp-vm-1"
    - ip: "ADMIN_CONTROL_PLANE_NODE_IP_2"
      hostname: "admin-cp-vm-2"
    - ip: "ADMIN_CONTROL_PLANE_NODE_IP_3"
      hostname: "admin-cp-vm-3"
loadBalancer:
  vips:
    controlPlaneVIP: "ADMIN_CONTROL_PLANE_VIP"
  kind: "MetalLB"
adminMaster:
  cpus: 4
  memoryMB: 16384
  replicas: 3
antiAffinityGroups:
  enabled: false
componentAccessServiceAccountKeyPath: "COMPONENT_ACCESS_SA_KEY"
gkeConnect:
  projectID: "PROJECT_ID"
  registerServiceAccountKeyPath: "CONNECT_REGISTER_SA_KEY"
stackdriver:
  projectID: "PROJECT_ID"
  clusterLocation: "us-central1"
  enableVPC: false
  serviceAccountKeyPath: "LOG_MON_SA_KEY"
  disableVsphereResourceMetrics: false
cloudAuditLogging:
  projectID: "PROJECT_ID"
  clusterLocation: us-central1
  serviceAccountKeyPath: "AUDIT_LOG_SA_KEY"

Valider le fichier de configuration du cluster d'administrateur

Vérifiez que le fichier de configuration de votre cluster d'administrateur est valide et qu'il peut être utilisé pour créer un cluster :

gkectl check-config --config admin-cluster.yaml

Importer des images d'OS dans vSphere

Exécutez gkectl prepare avec votre fichier de configuration terminé pour importer des images d'OS de nœud dans vSphere:

gkectl prepare --config admin-cluster.yaml --skip-validation-all

L'exécution de cette commande importe les images dans vSphere et les marque en tant que modèles de VM, y compris l'image de votre cluster d'administrateur.

Le retour de cette commande peut prendre quelques minutes.

Créer le cluster d'administrateur

Créez le cluster d'administrateur :

gkectl create admin --config admin-cluster.yaml

Reprendre la création du cluster d'administrateur après un échec

Si la création du cluster d'administrateur échoue ou est annulée, vous pouvez exécuter à nouveau la commande create :

gkectl create admin --config admin-cluster.yaml

Localiser le fichier kubeconfig du cluster d'administrateur

La commande gkectl create admin crée un fichier kubeconfig nommé kubeconfig dans le répertoire actuel. Vous aurez besoin de ce fichier kubeconfig ultérieurement pour interagir avec votre cluster d'administrateur.

Vérifier que votre cluster d'administrateur est en cours d'exécution

Vérifiez que votre cluster d'administrateur est en cours d'exécution :

kubectl get nodes --kubeconfig kubeconfig

Le résultat affiche les nœuds du cluster d'administrateur. Exemple :

gke-admin-master-hdn4z            Ready    control-plane,master ...
gke-admin-node-7f46cc8c47-g7w2c   Ready ...
gke-admin-node-7f46cc8c47-kwlrs   Ready ...

Activer l'autorisation RBAC

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

gcloud container fleet memberships generate-gateway-rbac \
    --membership=minimal-installation-admin-cluster \
    --role=clusterrole/cluster-admin \
    --users=GOOGLE_ACCOUNT_EMAIL \
    --project=PROJECT_ID \
    --kubeconfig=kubeconfig \
    --context=minimal-installation-admin-cluster \
    --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: kubeconfig, context: minimal-installation-admin-cluster
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 à l'aide de votre identité Google pour afficher plus de détails sur le cluster.

Inscription automatique à l'API GKE On-Prem

Comme l'API GKE On-Prem est activée dans votre projet, le cluster est automatiquement enregistré dans l'API GKE On-Prem. L'enregistrement de votre cluster d'administrateur dans l'API GKE On-Prem vous permet d'utiliser des outils standards (console Google Cloud, Google Cloud CLI ou Terraform) pour créer, mettre à niveau, mettre à jour et supprimer des clusters d'utilisateur gérés par le cluster d'administrateur. L'enregistrement de votre cluster vous permet également d'exécuter des commandes gcloud pour obtenir des informations sur votre cluster.

5. Créer un cluster d'utilisateur

Cette section explique comment créer le cluster d'utilisateur à l'aide de la console, de gkectl, de Terraform ou de gcloud CLI.

gkectl

Avant de commencer cette procédure, assurez-vous de disposer d'une connexion SSH à votre poste de travail administrateur, comme décrit précédemment. Toutes les commandes suivantes sont exécutées sur le poste de travail administrateur.

Créer le fichier de blocage d'adresses IP de votre cluster d'utilisateur

  1. Créez un fichier nommé user-ipblock.yaml.

  2. Copiez le contenu suivant et collez-le dans user-ipblock.yaml, puis enregistrez le fichier:

    blocks:
  - netmask: "NETMASK"
    gateway: "DEFAULT_GATEWAY_IP"
    ips:
    - ip: "USER_NODE_IP_1"
      hostname: "user-vm-1"
    - ip: "USER_NODE_IP_2"
      hostname: "user-vm-2"
    - ip: "USER_NODE_IP_3"
      hostname: "user-vm-3"
    - ip: "USER_NODE_IP_4"
      hostname: "user-vm-4"

Créer le fichier de configuration de votre cluster d'utilisateur

  1. Créez un fichier nommé user-cluster.yaml dans le même répertoire que user-ipblock.yaml.

  2. Copiez le contenu suivant et collez-le dans user-cluster.yaml, puis enregistrez le fichier:

apiVersion: v1
kind: UserCluster
name: "minimal-installation-user-cluster"
gkeOnPremVersion: "1.28.300-gke.123"
enableControlplaneV2: true
network:
  hostConfig:
    dnsServers:
    - "DNS_SERVER_IP"
    ntpServers:
    - "NTP_SERVER_IP"
  ipMode:
    type: "static"
    ipBlockFilePath: "user-ipblock.yaml"
  serviceCIDR: "10.96.0.0/20"
  podCIDR: "192.168.0.0/16"
  controlPlaneIPBlock:
    netmask: "NETMASK"
    gateway: "DEFAULT_GATEWAY_IP"
    ips:
    - ip: "USER_CONTROL_PLANE_NODE_IP"
      hostname: "cp-vm-1"
loadBalancer:
  vips:
    controlPlaneVIP: "USER_CONTROL_PLANE_VIP"
    ingressVIP: "USER_INGRESS_VIP"
  kind: "MetalLB"
  metalLB:
    addressPools:
    - name: "uc-address-pool"
      addresses:
      - "USER_INGRESS_VIP/32"
      - "SERVICE_VIP_1/32"
      - "SERVICE_VIP_2/32"
enableDataplaneV2: true
nodePools:
- name: "uc-node-pool"
  cpus: 4
  memoryMB: 8192
  replicas: 3
  enableLoadBalancer: true
antiAffinityGroups:
  enabled: false
gkeConnect:
  projectID: "PROJECT_ID"
  registerServiceAccountKeyPath: "CONNECT_REGISTER_SA_KEY"
stackdriver:
  projectID: "PROJECT_ID"
  clusterLocation: "us-central1"
  enableVPC: false
  serviceAccountKeyPath: "LOG_MON_SA_KEY"
  disableVsphereResourceMetrics: false
autoRepair:
  enabled: true

Valider la configuration et créer le cluster

  1. Vérifiez que le fichier de configuration de votre cluster utilisateur est valide et qu'il peut être utilisé pour créer un cluster :

    gkectl check-config --kubeconfig kubeconfig --config user-cluster.yaml

  2. Créez le cluster d'utilisateur :

    gkectl create cluster --kubeconfig kubeconfig --config user-cluster.yaml

    La création du cluster prend environ 30 minutes.

Localiser le fichier kubeconfig du cluster d'utilisateur

La commande gkectl create cluster crée un fichier kubeconfig nommé USER_CLUSTER_NAME-kubeconfig dans le répertoire actuel. Vous aurez besoin de ce fichier kubeconfig ultérieurement pour interagir avec votre cluster d'utilisateur.

Vérifier que votre cluster d'utilisateur est en cours d'exécution

Vérifiez que votre cluster d'utilisateur est en cours d'exécution :

kubectl get nodes --kubeconfig USER_CLUSTER_KUBECONFIG

Remplacez USER_CLUSTER_KUBECONFIG par le chemin d'accès du fichier kubeconfig de votre cluster d'utilisateur.

Le résultat affiche les nœuds du cluster d'utilisateur. Exemple :

cp-vm-1     Ready    control-plane,master
user-vm-1   Ready
user-vm-2   Ready
user-vm-3   Ready

Activer l'autorisation RBAC

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

gcloud container fleet memberships generate-gateway-rbac \
  --membership=minimal-installation-user-cluster \
  --role=clusterrole/cluster-admin \
  --users=GOOGLE_ACCOUNT_EMAIL \
  --project=PROJECT_ID \
  --kubeconfig=USER_CLUSTER_KUBECONFIG \
  --context=minimal-installation-user-cluster \
  --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: kubeconfig, context: minimal-installation-admin-cluster
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 à l'aide de votre identité Google pour afficher plus de détails sur le cluster.

Inscription automatique à l'API GKE On-Prem

Comme l'API GKE On-Prem est activée dans votre projet, le cluster est automatiquement enregistré dans l'API GKE On-Prem. Cela vous permet d'utiliser la console ou la gcloud CLI pour afficher les détails du cluster et gérer son cycle de vie. Par exemple, vous pouvez exécuter les commandes gcloud pour obtenir des informations sur votre cluster d'utilisateur.

Console

  1. Dans la console Google Cloud, accédez à la page Créer un cluster GKE sur VMware.

    Accéder à la page "Créer un cluster GKE sur VMware"

  2. Sélectionnez le projet Google Cloud dans lequel vous souhaitez créer le cluster. Le projet sélectionné est également utilisé comme projet hôte du parc. Il doit s'agir du même projet que celui dans lequel le cluster d'administrateur est enregistré. Une fois le cluster d'utilisateur créé, il est automatiquement enregistré dans le parc du projet sélectionné.

Les sections suivantes vous guident dans la configuration du cluster d'utilisateur.

Prérequis

  1. Familiarisez-vous avec les informations de la page Prérequis.

  2. Au bas de la page, cliquez sur Suivant.

Paramètres de base du cluster

  1. Dans le champ Nom, saisissez un nom pour le cluster d'utilisateur. Par exemple, minimal-installation-user-cluster.

  2. Dans le champ Cluster d'administration, sélectionnez minimal-installation-admin-cluster.

  3. Dans le champ GCP API Location (Emplacement de l'API GCP), sélectionnez us-central1.

  4. Dans le champ Version, sélectionnez 1.28.300-gke.123.

  5. Vous n'avez pas besoin d'ouvrir la section Autorisation ni la section Configuration vCenter.

  6. Cliquez sur Suivant.

Plan de contrôle

  1. Sous Adresses IP des nœuds du plan de contrôle, saisissez DEFAULT_GATEWAY_IP dans le champ Passerelle.

  2. Dans le champ Masque de sous-réseau, saisissez NETMASK.

  3. Sous Adresses IP, dans le champ Adresse IP 1, saisissez USER_CONTROL_PLANE_NODE_IP. Laissez le champ Hostname 1 (Nom d'hôte 1) vide.

  4. Cliquez sur Suivant.

Mise en réseau

Dans cette section, vous spécifiez les adresses IP des nœuds, des pods et des services de votre cluster. Un cluster d'utilisateur doit disposer d'une adresse IP pour chaque nœud et d'une adresse IP supplémentaire pour un nœud temporaire, nécessaire lors des mises à niveau, des mises à jour et de la réparation automatique du cluster. Pour en savoir plus, consultez la section De combien d'adresses IP un cluster d'utilisateur a-t-il besoin ?.

  1. Sous Adresses IP des nœuds de calcul, assurez-vous que l'option Statique est sélectionnée pour Mode IP.

  2. Pour Passerelle, saisissez DEFAULT_GATEWAY_IP.

  3. Dans le champ Masque de sous-réseau, saisissez NETMASK.

  4. Sous Adresses IP, saisissez les adresses suivantes:

  • USER_NODE_IP_1
  • USER_NODE_IP_2
  • USER_NODE_IP_3
  • USER_NODE_IP_4

Laissez les champs Hostname (Nom d'hôte) vides.

  1. Dans le champ CIDR des services, saisissez 10.96.0.0/20. Dans le champ CIDR du pod, saisissez 192.168.0.0/16.

  2. Dans le champ Serveur DNS 1, saisissez DNS_SERVER_IP.

  3. Dans le champ NTP Server 1 (NTP Server 1), saisissez NTP_SERVER_IP.

  4. Laissez le champ Domaine de recherche DNS vide.

  5. Cliquez sur Suivant.

Équilibreur de charge

  1. Dans le champ Type d'équilibreur de charge, sélectionnez Bundled with MetalLB.

  2. Sous Pools d'adresses, utilisez le nom par défaut.

  3. Sous Adresses IP, saisissez USER_INGRESS_VIP/32 dans le champ Plage d'adresses IP 1.

    Cliquez sur Ajouter une plage d'adresses IP. Pour Plage d'adresses IP 1, saisissez SERVICE_VIP_1/32.

    Cliquez sur Ajouter une plage d'adresses IP. Pour Plage d'adresses IP 2, saisissez SERVICE_VIP_2/32.

  4. Pour Attribution des adresses IP, sélectionnez Automatique.

  5. Laissez la case Éviter les adresses IP présentant des bugs décochée.

  6. Sous Adresses IP virtuelles, pour Adresse IP virtuelle du plan de contrôle, saisissez USER_CONTROL_PLANE_VIP. Le champ Adresse IP virtuelle d'entrée est déjà renseigné.

  7. Cliquez sur Continuer.

Fonctionnalités

  1. Conservez les valeurs par défaut.

  2. Cliquez sur Suivant.

Pools de nœuds

  1. Conservez les valeurs par défaut.

  2. Cliquez sur Vérifier et terminer 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 dans votre centre de données.

    Si une erreur se produit lors de la vérification des paramètres, la console affiche un message d'erreur qui doit être suffisamment clair pour résoudre le problème de configuration avant de retenter de créer le cluster.

    Pour en savoir plus sur les erreurs possibles et sur la manière de les corriger, consultez la page Résoudre les problèmes liés aux clusters enregistrés dans l'API GKE On-Prem.

Terraform

Cette section explique comment créer un cluster d'utilisateur et un pool de nœuds à l'aide de Terraform. Pour obtenir plus d'informations et d'autres exemples, consultez les ressources suivantes:

  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 s'appelle 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_vmware_cluster" "cluster-basic" {
  name = "minimal-installation-user-cluster"
  project = "PROJECT_ID"
  location = "us-central1"
  admin_cluster_membership = "projects/PROJECT_ID/locations/global/memberships/minimal-installation-admin-cluster"
  description = "User cluster config with MetalLB, static IPs, and Controlplane V2"
  enable_control_plane_v2 = "true"
  on_prem_version = "1.28.300-gke.123"
  control_plane_node {
    cpus = 4
    memory = 8192
    replicas = 1
  }
  network_config {
    service_address_cidr_blocks = ["10.96.0.0/20"]
    pod_address_cidr_blocks = ["192.168.0.0/16"]
    host_config {
      dns_servers = ["DNS_SERVER_IP"]
      ntp_servers = ["NTP_SERVER_IP"]
    }
    static_ip_config {
      ip_blocks {
        netmask = "NETMASK"
        gateway = "DEFAULT_GATEWAY_IP"
        ips {
          ip = "USER_NODE_IP_1"
          hostname = "user-vm-1"
        }
        ips {
          ip = "USER_NODE_IP_2"
          hostname = "user-vm-2"
        }
        ips {
          ip = "USER_NODE_IP_3"
          hostname = "user-vm-3"
        }
        ips {
          ip = "USER_NODE_IP_4"
          hostname = "user-vm-4"
        }
      }
    }
    control_plane_v2_config {
      control_plane_ip_block {
        netmask = "NETMASK"
        gateway = "DEFAULT_GATEWAY_IP"
        ips {
          ip = "USER_CONTROL_PLANE_NODE_IP"
          hostname = "cp-vm-1"
        }
      }
    }
  }
  load_balancer {
    vip_config {
      control_plane_vip = "USER_CONTROL_PLANE_VIP"
      ingress_vip = "USER_INGRESS_VIP"
    }
    metal_lb_config {
      address_pools {
        pool = "uc-address-pool"
        manual_assign = "true"
        addresses = ["USER_INGRESS_VIP/32", "SERVICE_VIP_1/32", "SERVICE_VIP_2/32"]
      }
    }
  }
  authorization {
    admin_users {
    username = "GOOGLE_ACCOUNT_EMAIL"
  }
}
  provider = google-beta
}

resource "google_gkeonprem_vmware_node_pool" "my-node-pool-1" {
  name = "uc-node-pool"
  project = "PROJECT_ID"
  vmware_cluster = "minimal-installation-user-cluster"
  location = "us-central1"
  config {
    replicas = 3
    image_type = "ubuntu_containerd"
    enable_load_balancer = "true"
  }
  depends_on = [
    google_gkeonprem_vmware_cluster.cluster-basic
  ]
  provider = google-beta
}

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

gcloud

Créez le cluster :

gcloud container vmware clusters create minimal-installation-user-cluster \
  --project=PROJECT_ID \
  --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/minimal-installation-admin-cluster \
  --location=us-central1 \
  --version=1.28.300-gke.123 \
  --admin-users=GOOGLE_ACCOUNT_EMAIL \
  --service-address-cidr-blocks=10.96.0.0/20 \
  --pod-address-cidr-blocks=192.168.0.0/16 \
  --metal-lb-config-address-pools='pool=uc-address-pool,avoid-buggy-ips=False,manual-assign=False,addresses=USER_INGRESS_VIP/32;SERVICE_VIP_1/32;SERVICE_VIP_2/32' \
  --control-plane-vip=USER_CONTROL_PLANE_VIP \
  --ingress-vip=USER_INGRESS_VIP \
  --static-ip-config-ip-blocks='gateway=DEFAULT_GATEWAY_IP,netmask=NETMASK,ips=USER_NODE_IP_1;USER_NODE_IP_2;USER_NODE_IP_3;USER_NODE_IP_4' \
  --dns-servers=DNS_SERVER_IP \
  --ntp-servers=NTP_SERVER_IP \
  --enable-control-plane-v2 \
  --enable-dataplane-v2 \
  --control-plane-ip-block='gateway=DEFAULT_GATEWAY_IP,netmask=NETMASK,ips=USER_CONTROL_PLANE_NODE_IP'

La sortie de la commande ressemble à ceci :

Waiting for operation [projects/example-project-12345/locations/us-central1/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 vmware operations describe OPERATION_ID \
  --project=PROJECT_ID \
  --location=us-central1

Pour plus d'informations, consultez la page gcloud container vmware operation.

La création du cluster d'utilisateur prend 15 minutes ou plus. Vous pouvez afficher le cluster dans la console sur la page de présentation des clusters Google Kubernetes Engine.

Créez un pool de nœuds:

gcloud container vmware node-pools create  uc-node-pool \
  --cluster=minimal-installation-user-cluster \
  --project=PROJECT_ID \
  --location=us-central1 \
  --image-type=ubuntu_containerd  \
  --boot-disk-size=40 \
  --cpus=4 \
  --memory=8192 \
  --replicas=3 \
  --enable-load-balancer

Étapes suivantes

Vous avez maintenant terminé cette installation minimale de GKE sur VMware. En guise de suivi facultatif, vous pouvez voir votre installation en action en déployant une application.