Créer des clusters de base

Il s'agit de la deuxième partie d'un guide qui vous explique comment effectuer une petite installation de démonstration de faisabilité de Google Distributed Cloud. 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 renseigner dans ce document. Vous pouvez ensuite passer au déploiement d'une application.

Comme pour la configuration de l'infrastructure de cette installation simple, les clusters que vous configurez à l'aide de ce document peuvent ne pas convenir à vos besoins et cas d'utilisation de production réels. Pour en savoir plus, découvrir les bonnes pratiques et obtenir des instructions pour les installations de 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 utilisateur, vous devez disposer de 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 à Google Cloud CLI avec un compte disposant des autorisations nécessaires pour créer des comptes de service.

  2. Récupérez les informations dont vous avez besoin pour configurer Google Distributed Cloud, 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'utilisateurs.

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

1. Se connecter à Google Cloud CLI

La configuration de Google Distributed Cloud nécessite plusieurs comptes de service avec des autorisations différentes. Vous devez donc être connecté à 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é account gcloud CLI actuelle lors de cette configuration.

  1. Connectez-vous à gcloud CLI. Vous pouvez utiliser n'importe quel compte Google, mais il doit disposer des autorisations requises. Si vous avez suivi la partie précédente de ce guide, vous 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 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 gcloud CLI sont installés :

    gcloud components update

    Selon la manière dont vous avez installé gcloud CLI, le message suivant peut s'afficher : "Vous ne pouvez pas effectuer cette action, car le gestionnaire de composants de 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 la section Configurer une infrastructure minimale pour modifier les espaces réservés du tableau suivant :

Informations 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
Nom de votre centre de données vSphere DATA_CENTER
Nom de votre cluster vSphere VSPHERE_CLUSTER
Nom ou chemin d'accès de votre pool de ressources vSphere. Pour en savoir plus, consultez 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
Trois adresses IP pour les nœuds de plan de contrôle du cluster d'administrateur. ADMIN_CONTROL_PLANE_NODE_IP_1
ADMIN_CONTROL_PLANE_NODE_IP_2
ADMIN_CONTROL_PLANE_NODE_IP_3
Une adresse IP pour le nœud de plan de contrôle dans le cluster d'utilisateur. USER_CONTROL_PLANE_NODE_IP
Quatre adresses IP pour les nœuds de calcul de votre cluster d'utilisateur. Cela inclut une adresse pour un nœud supplémentaire pouvant être utilisé lors de la mise à niveau et de la mise à jour. USER_NODE_IP_1
USER_NODE_IP_2
USER_NODE_IP_3
USER_NODE_IP_4
Une adresse IP virtuelle (VIP) pour le serveur d'API Kubernetes du cluster d'administration 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 d'administrateur et vos nœuds de cluster DNS_SERVER_IP
L'adresse IP d'un serveur NTP accessible depuis votre poste de travail d'administrateur et vos nœuds de cluster NTP_SERVER_IP
L'adresse IP de la passerelle par défaut pour le sous-réseau contenant votre poste de travail d'administrateur et vos nœuds de cluster DEFAULT_GATEWAY_IP
Masque de réseau pour le sous-réseau contenant votre poste de travail d'administrateur et vos nœuds de cluster
Exemple : 255.255.255.0		 NETMASK
Si votre réseau est protégé par un serveur proxy, l'URL du serveur proxy. Pour en savoir plus, 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 devez les modifier pour éviter le 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
Une plage CIDR pour les services dans le 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 de Google Cloud
ID du projet Cloud 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. Vous créez le poste de travail administrateur à l'aide de l'outil de ligne de commande gkeadm.

Télécharger gkeadm

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

gcloud storage cp gs://gke-on-prem-release/gkeadm/1.30.0-gke.1930/linux/gkeadm ./
chmod +x gkeadm

Vous avez besoin de la version gkeadm (qui est également la version de Google Distributed Cloud) pour créer les 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.30.0 (1.30.0-gke.1930)

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

Créer votre fichier d'identifiants

Créez et enregistrez un fichier nommé credential.yaml dans votre répertoire actuel 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

En exécutant cette commande :

  • Crée votre poste de travail administrateur
  • Crée automatiquement tous les comptes de service supplémentaires dont vous avez besoin pour votre installation.
  • Crée des fichiers de configuration de modèle 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. Exemple :

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

Dans le résultat précédent, l'adresse IP est un exemple. L'adresse IP de votre poste de travail administrateur sera différente. Notez l'adresse IP de votre poste de travail administrateur. Vous en aurez besoin à l'étape suivante.

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 devez trouver à nouveau cette commande, gkeadm génère un fichier nommé gke-admin-ws-... dans le répertoire de votre machine locale sur lequel vous avez exécuté gkeadm create admin-workstation. Il contient des informations sur votre poste de travail administrateur, y compris la commande SSH.

Sur votre poste de travail administrateur, saisissez exit pour mettre fin à la connexion SSH et revenir à votre machine locale.

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

À nouveau, obtenez une connexion SSH à votre poste de travail administrateur.

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

ls -1

Le résultat doit inclure les éléments suivants :

  • admin-cluster.yaml, un fichier de configuration de modèle pour la création de votre cluster d'administrateur.
  • user-cluster.yaml, un fichier de configuration de modèle permettant de créer votre cluster d'utilisateurs.
  • 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.
  • Le fichier de clé JSON de votre compte de service de journalisation d'audit.
  • Fichiers de clé JSON de deux comptes de service que gkeadm a créés pour vous : 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éé plus tôt.

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 du fichier de clé du compte de service connect-register
Exemple : connect-register-sa-2203040617.json		 CONNECT_REGISTER_SA_KEY
Nom du fichier de 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 de journalisation 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 avez configuré un poste de travail administrateur avec votre vCenter et d'autres informations, 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.30.0-gke.1930-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 de l'OS dans vSphere.

Exécutez gkectl prepare avec votre fichier de configuration finalisé pour importer des images de l'OS du 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 comme modèles de VM, y compris l'image de votre cluster d'administration.

L'exécution de cette commande peut prendre quelques minutes.

Créez 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 :

admin-cp-vm-1   Ready    control-plane,master ...
admin-cp-vm-2   Ready    control-plane,master ...
admin-cp-vm-3   Ready    control-plane,master ...

Activer l'autorisation RBAC

Pour attribuer le rôle Kubernetes clusterrole/cluster-admin à votre compte utilisateur 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é à des fins 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.

Entre autres, la stratégie RBAC vous permet 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.

Enregistrement automatique dans l'API GKE On-Prem

L'API GKE On-Prem étant 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 (la 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. Enregistrer 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'utilisateurs à 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 bloc 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 votre fichier de configuration de cluster d'utilisateur

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

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

apiVersion: v1
kind: UserCluster
name: "minimal-installation-user-cluster"
gkeOnPremVersion: "1.30.0-gke.1930"
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 le rôle Kubernetes clusterrole/cluster-admin à votre compte utilisateur 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é à des fins 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.

Entre autres, la stratégie RBAC vous permet 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.

Enregistrement automatique dans l'API GKE On-Prem

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

Console

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

    Accéder à "Créer un cluster Google Distributed Cloud"

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

Paramètres de base du cluster

  1. Dans le champ Nom, saisissez un nom pour le cluster d'utilisateurs (par exemple, minimal-installation-user-cluster).

  2. Pour Cluster d'administrateur, sélectionnez minimal-installation-admin-cluster.

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

  4. Pour Version, sélectionnez 1.30.0-gke.1930.

  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 de plan de contrôle, saisissez DEFAULT_GATEWAY_IP pour le champ Passerelle.

  2. Pour Masque de sous-réseau, saisissez NETMASK.

  3. Sous Adresses IP, pour Adresse IP 1, saisissez USER_CONTROL_PLANE_NODE_IP. Laissez le champ Hostname 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, pour Mode d'adresse IP, assurez-vous que Statique est sélectionné.

  2. Dans le champ Passerelle, saisissez DEFAULT_GATEWAY_IP.

  3. Pour 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 Nom d'hôte vides.

  1. Dans le champ CIDR du service, saisissez 10.96.0.0/20. Pour CIDR du pod, saisissez 192.168.0.0/16.

  2. Pour Serveur DNS 1, saisissez DNS_SERVER_IP.

  3. Pour NTP Server 1, saisissez NTP_SERVER_IP.

  4. Laissez le champ Domaine de recherche DNS vide.

  5. Cliquez sur Suivant.

Équilibreur de charge

  1. Pour Type d'équilibreur de charge, sélectionnez Groupé avec MetalLB.

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

  3. Sous Adresses IP, pour Plage d'adresses IP 1, saisissez USER_INGRESS_VIP/32.

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

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

  4. Sous Attribution d'adresses IP, sélectionnez Automatique.

  5. Ne cochez pas la case Éviter les adresses IP présentant des bugs.

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

  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 au moins 15 minutes. La console affiche les messages d'état de vérification des paramètres et de création du 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 façon de les corriger, consultez la page Résoudre les problèmes liés aux clusters inscrits à l'API GKE On-Prem.

Terraform

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

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

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

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

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

    resource "google_gkeonprem_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.30.0-gke.1930"
  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 les bibliothèques nécessaires, telles que le fournisseur Google Cloud.

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

    terraform plan

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

    terraform apply

    Lorsque vous y êtes invité, saisissez yes.

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

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.30.0-gke.1930 \
  --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 à l'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 vmware operations describe OPERATION_ID \
  --project=PROJECT_ID \
  --location=us-central1

Pour plus d'informations, consultez la section Opérations gcloud container vmware.

La création du cluster d'utilisateur prend au moins 15 minutes. 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

Étape suivante

Vous avez maintenant terminé cette installation minimale de Google Distributed Cloud. À titre de suivi facultatif, vous pouvez voir votre installation en action en déployant une application.