crea cluster di base

Questa è la seconda parte di una guida che illustra una piccola installazione proof of concept di GKE su VMware. La prima parte è Configura l'infrastruttura minima, che mostra come pianificare gli indirizzi IP e configurare l'infrastruttura vSphere e Google Cloud necessaria per il deployment. Questo documento si basa sulla configurazione e sulla pianificazione che hai eseguito nella sezione precedente e mostra come creare una workstation di amministrazione, un cluster di amministrazione e un cluster utente nel tuo ambiente vSphere, utilizzando modelli semplici che puoi compilare qui in questo documento. Poi puoi procedere con il deployment di un'applicazione.

Come nel caso di questa semplice installazione, i cluster che configuri utilizzando questo documento potrebbero non essere adatti alle tue esigenze di produzione e ai tuoi casi d'uso effettivi. Per ulteriori informazioni, best practice e istruzioni per le installazioni di produzione, consulta le guide all'installazione.

Prima di iniziare

  1. Assicurati di aver configurato gli ambienti vSphere e Google Cloud come descritto in Configurare un'infrastruttura minima.

  2. Se vuoi utilizzare Terraform per creare il cluster utente, devi utilizzare Terraform sulla workstation di amministrazione o su un altro computer.

Panoramica della procedura

Questi sono i passaggi principali del processo di configurazione:

  1. Accedi a Google Cloud CLI con un account che disponga delle autorizzazioni necessarie per creare account di servizio.

  2. Raccogli le informazioni necessarie per configurare GKE su VMware, inclusi nome utente e password di vCenter e gli indirizzi IP che hai preparato nella sezione precedente.

  3. Crea una workstation di amministrazione che abbia le risorse e gli strumenti necessari per creare cluster di amministrazione e utente, inclusi gli account di servizio aggiuntivi necessari per completare la configurazione.

  4. Crea un cluster di amministrazione per gestire e aggiornare il cluster utente.

  5. Crea un cluster utente per eseguire i carichi di lavoro.

1. Accedi a Google Cloud CLI

La configurazione di GKE su VMware richiede più account di servizio con autorizzazioni diverse. Anche se devi creare l'account di servizio di accesso ai componenti manualmente, lo strumento a riga di comando gkeadm può creare e configurare per te gli account rimanenti come parte della creazione della workstation di amministrazione. Per farlo, tuttavia, devi aver eseguito l'accesso a Google Cloud CLI con un account che disponga delle autorizzazioni necessarie per creare e configurare gli account di servizio, poiché gkeadm utilizza la tua attuale proprietà account di gcloud CLI per eseguire questa configurazione.

  1. Accedi a gcloud CLI. Puoi utilizzare qualsiasi Account Google, ma deve disporre delle autorizzazioni richieste. Se hai seguito la parte precedente di questa guida, è probabile che tu abbia già eseguito l'accesso con un account appropriato per creare il tuo account di servizio per l'accesso ai componenti.

    gcloud auth login

  2. Verifica che la proprietà account dellgcloud CLI sia impostata correttamente:

    gcloud config list

    L'output mostra il valore della proprietà SDK account. Ad esempio:

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

  3. Assicurati di aver installato i componenti più recenti gcloud CLI:

    gcloud components update

    A seconda di come hai installato gcloud CLI, potrebbe essere visualizzato il seguente messaggio: "Non puoi eseguire questa azione perché il gestore dei componenti di Google Cloud CLI è disabilitato per questa installazione. Per ottenere lo stesso risultato per questa installazione, puoi eseguire il comando seguente:"Segui le istruzioni per copiare e incollare il comando al fine di aggiornare i componenti.

2. Raccogliere informazioni

Utilizza le informazioni preparate in Configura l'infrastruttura minima per modificare i segnaposto nella seguente tabella:

Dettagli vSphere
Il nome utente del tuo account vCenter USERNAME
La password del tuo account vCenter PASSWORD
Il tuo indirizzo di vCenter Server ADDRESS
Il percorso del certificato CA radice per vCenter Server, sulla macchina che utilizzerai per creare la workstation di amministrazione CA_CERT_PATH
Il nome del tuo data center vSphere DATA_CENTER
Il nome del tuo cluster vSphere. VSPHERE_CLUSTER
Il nome o il percorso del tuo pool di risorse vSphere. Per maggiori informazioni, consulta vcenter.resourcePool. RESOURCE_POOL
Il nome del tuo datastore vSphere DATASTORE
Il nome della tua rete vSphere. NETWORK
Indirizzi IP
Un unico indirizzo IP per la workstation di amministrazione ADMIN_WS_IP
Quattro indirizzi IP per i nodi del cluster di amministrazione. Questo include un indirizzo per un nodo aggiuntivo che può essere utilizzato durante l'upgrade e l'aggiornamento. ADMIN_CONTROL_PLANE_NODE_IP_1
ADMIN_CONTROL_PLANE_NODE_IP_2
ADMIN_CONTROL_PLANE_NODE_IP_3
Un indirizzo IP per il nodo del piano di controllo nel cluster utente. USER_CONTROL_PLANE_NODE_IP
Quattro indirizzi IP per i nodi del cluster utente. Questo include un indirizzo per un nodo aggiuntivo che può essere utilizzato durante l'upgrade e l'aggiornamento. USER_NODE_IP_1
USER_NODE_IP_2
USER_NODE_IP_3
USER_NODE_IP_4
Un indirizzo IP virtuale (VIP) per il server API Kubernetes del cluster di amministrazione ADMIN_CONTROL_PLANE_VIP
Un VIP per il server API Kubernetes del cluster utente USER_CONTROL_PLANE_VIP
Un VIP in entrata per il cluster utente USER_INGRESS_VIP
Due VIP per i servizi di tipo LoadBalancer nel cluster utente. SERVICE_VIP_1
SERVICE_VIP_2
L'indirizzo IP di un server DNS raggiungibile dalla workstation di amministrazione e dai nodi del cluster DNS_SERVER_IP
L'indirizzo IP di un server NTP raggiungibile dalla workstation di amministrazione e dai nodi del cluster NTP_SERVER_IP
L'indirizzo IP del gateway predefinito per la subnet che include la workstation di amministrazione e i nodi del cluster DEFAULT_GATEWAY_IP
La netmask per la subnet che include la workstation di amministrazione e i nodi del cluster.
Esempio: 255.255.255.0		 NETMASK
Se la rete è protetta da un server proxy, l'URL del server proxy. Per maggiori informazioni, consulta proxy. Compila manualmente questo campo nel file di configurazione della workstation di amministrazione, se necessario. PROXY_URL
Intervalli CIDR per servizi e pod
Sia il cluster di amministrazione sia il cluster utente richiedono ciascuno un intervallo CIDR per i servizi e un intervallo CIDR per i pod. Utilizza i seguenti valori precompilati a meno che tu non debba modificarli per evitare sovrapposizioni con altri elementi della rete:
Un intervallo CIDR per i servizi nel cluster di amministrazione 10.96.232.0/24
Un intervallo CIDR per i pod nel cluster di amministrazione 192.168.0.0/16
Un intervallo CIDR per i servizi nel cluster utente 10.96.0.0/20
Un intervallo CIDR per i pod nel cluster utente 192.168.0.0/16
Dettagli Google Cloud
L'ID del progetto Cloud scelto PROJECT_ID
Il percorso del file di chiavi JSON per l'account di servizio di accesso ai componenti che hai configurato nella sezione precedente, sulla macchina che utilizzerai per creare la workstation di amministrazione. COMPONENT_ACCESS_SA_KEY_PATH
L'indirizzo email associato al tuo account Google Cloud. Ad esempio: alex@example.com. GOOGLE_ACCOUNT_EMAIL

3. Creazione di una workstation di amministrazione

Prima di poter creare cluster, devi creare una workstation di amministrazione e connetterti a questa tramite SSH. La workstation di amministrazione è una VM autonoma con gli strumenti e le risorse necessari per creare cluster GKE Enterprise nel tuo ambiente vSphere. Per creare la workstation di amministrazione, puoi utilizzare lo strumento a riga di comando gkeadm.

Scarica gkeadm

Scarica gkeadm nella directory attuale:

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

Per creare i file di configurazione dei cluster di amministrazione e utente, è necessaria la versione gkeadm (che è anche la versione di GKE su VMware). Per controllare la versione di gkeadm, esegui questo comando:

./gkeadm version

L'output di esempio seguente mostra la versione.

gkeadm 1.28.100 (1.28.100-gke.131)

Anche se puoi scaricare un'altra versione di gkeadm, questa guida presuppone che tu stia installando la versione 1.28.100-gke.131 e che la utilizzi in tutti i comandi e i file di configurazione.

Crea il file delle credenziali

Crea e salva un file denominato credential.yaml nella directory attuale con i seguenti contenuti:

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

Crea il file di configurazione della workstation di amministrazione

Crea e salva un file denominato admin-ws-config.yaml, sempre nella directory corrente, con il seguente contenuto:

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

Crea la tua workstation di amministrazione

Crea la tua workstation di amministrazione utilizzando il seguente comando:

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

Esecuzione del comando seguente:

  • Crea la workstation di amministrazione
  • Crea automaticamente eventuali account di servizio aggiuntivi necessari per l'installazione
  • Crea file di configurazione del modello per i cluster di amministrazione e utente

L'output fornisce informazioni dettagliate sulla creazione della workstation di amministrazione e fornisce un comando che puoi utilizzare per ottenere una connessione SSH alla workstation di amministrazione:

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

Per informazioni più dettagliate sulla creazione di una workstation di amministrazione, consulta Creare una workstation di amministrazione.

Connettiti alla workstation di amministrazione

Utilizza il comando visualizzato nell'output precedente per ottenere una connessione SSH alla workstation di amministrazione. Ad esempio:

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

Se devi trovare di nuovo questo comando, gkeadm genera un file denominato gke-admin-ws-... nella directory sulla tua macchina locale su cui hai eseguito gkeadm create admin-workstation. contenente i dettagli sulla workstation di amministrazione, incluso il comando SSH.

Sulla workstation di amministrazione, inserisci exit per terminare la connessione SSH e tornare alla macchina locale.

Copia la chiave di audit logging sulla workstation di amministrazione

Nella sezione precedente hai creato un file di chiavi JSON per il tuo account di servizio di audit logging.

Copia il file della chiave JSON nella home directory sulla workstation di amministrazione. Ad esempio, sulla tua macchina locale:

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

Visualizza i file sulla workstation di amministrazione

Ancora una volta, ottieni una connessione SSH alla workstation di amministrazione.

Sulla workstation di amministrazione, elenca i file nella home directory:

ls -1

L'output dovrebbe includere:

  • admin-cluster.yaml, un file di configurazione del modello per creare il cluster di amministrazione.
  • user-cluster.yaml, un modello di file di configurazione per la creazione del cluster utente.
  • Il file del certificato vCenter che hai specificato nella configurazione della workstation di amministrazione
  • Il file credential.yaml che hai specificato nella configurazione della workstation di amministrazione.
  • Il file di chiavi JSON per l'account di servizio di audit logging.
  • I file di chiavi JSON per due account di servizio gkeadm creati per te: un account di servizio Connect-Registration e un account di servizio di logging-monitoraggio, nonché il file della chiave per l'account di servizio Accesso ai componenti creato in precedenza.

Ad esempio:

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

Per creare i cluster, devi specificare alcuni di questi nomi file nei file di configurazione. Utilizza i nomi file come valori per i segnaposto della seguente tabella:

Nome file della chiave dell'account di servizio della registrazione della connessione
Esempio: connect-register-sa-2203040617.json		 CONNECT_REGISTER_SA_KEY
Nome file della chiave dell'account di servizio di monitoraggio di Logging
Esempio: log-mon-sa-2203040617.json		 LOG_MON_SA_KEY
Nome file della chiave dell'account di servizio di audit logging
Esempio: audit-logging-key.json		 AUDIT_LOG_SA_KEY
Nome file della chiave dell'account di servizio per l'accesso ai componenti
Esempio: sa-key.json		 COMPONENT_ACCESS_SA_KEY
Nome file del certificato vCenter
Esempio: vc01-cert.pem		 CA_CERT_FILE

4. Crea un cluster di amministrazione

Ora che hai una workstation di amministrazione configurata con vCenter e altri dettagli, puoi utilizzarla per creare un cluster di amministrazione nel tuo ambiente vSphere. Assicurati di avere una connessione SSH alla workstation di amministrazione, come descritto in precedenza, prima di iniziare questo passaggio. Tutti i comandi seguenti vengono eseguiti sulla workstation di amministrazione.

Crea il file di configurazione del cluster di amministrazione

Apri admin-cluster.yaml e sostituisci i contenuti con il seguente:

apiVersion: v1
kind: AdminCluster
name: "minimal-installation-admin-cluster"
bundlePath: "/var/lib/gke/bundles/gke-onprem-vsphere-1.28.100-gke.131-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"

Convalida il file di configurazione del cluster di amministrazione

Verifica che il file di configurazione del cluster di amministrazione sia valido e che possa essere utilizzato per la creazione del cluster:

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

Importa immagini sistema operativo in vSphere

Esegui gkectl prepare con il file di configurazione completato per importare le immagini del sistema operativo dei nodi in vSphere:

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

L'esecuzione di questo comando importa le immagini in vSphere e le contrassegna come modelli di VM, inclusa l'immagine per il cluster di amministrazione.

La restituzione del comando potrebbe richiedere alcuni minuti.

Crea il cluster di amministrazione

Crea il cluster di amministrazione:

gkectl create admin --config admin-cluster.yaml

Riprendi la creazione del cluster di amministrazione dopo un errore

Se la creazione del cluster di amministrazione non riesce o viene annullata, puoi eseguire di nuovo il comando create:

gkectl create admin --config admin-cluster.yaml

Individua il file kubeconfig del cluster di amministrazione

Il comando gkectl create admin crea un file kubeconfig denominato kubeconfig nella directory attuale. Avrai bisogno di questo file kubeconfig in un secondo momento per interagire con il cluster di amministrazione.

Verifica che il cluster di amministrazione sia in esecuzione

Verifica che il cluster di amministrazione sia in esecuzione:

kubectl get nodes --kubeconfig kubeconfig

L'output mostra i nodi del cluster di amministrazione. Ad esempio:

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

Abilita autorizzazione RBAC

Per concedere al tuo account utente il ruolo Kubernetes clusterrole/cluster-admin nel cluster, esegui questo comando:

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

L'output di questo comando è simile al seguente, che viene troncato per la leggibilità:

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.

Tra le altre cose, il criterio RBAC ti consente di accedere al cluster nella console Google Cloud utilizzando Google Identity per visualizzare ulteriori dettagli sul cluster.

Registrazione automatica nell'API GKE On-Prem

Poiché l'API GKE On-Prem è abilitata nel tuo progetto, il cluster viene automaticamente registrato nell'API GKE On-Prem. La registrazione del tuo cluster di amministrazione nell'API GKE On-Prem ti consente di utilizzare gli strumenti standard, la console Google Cloud, Google Cloud CLI o Terraform per creare, eseguire l'upgrade, aggiornare ed eliminare i cluster utente gestiti dal cluster di amministrazione. La registrazione del cluster consente anche di eseguire i comandi gcloud per ricevere informazioni sul cluster.

5. Creazione di un cluster utente

Questa sezione fornisce i passaggi per creare il cluster utente utilizzando la console, gkectl, Terraform o gcloud CLI.

gkectl

Assicurati di avere una connessione SSH alla workstation di amministrazione, come descritto in precedenza, prima di iniziare questa procedura. Tutti i comandi seguenti vengono eseguiti sulla workstation di amministrazione.

Crea il file dei blocchi IP del cluster utente

  1. Crea un file denominato user-ipblock.yaml.

  2. Copia e incolla i seguenti contenuti in user-ipblock.yaml e salva il file:

    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"

Crea il file di configurazione del cluster utente

  1. Crea un file denominato user-cluster.yaml nella stessa directory in cui si trova user-ipblock.yaml.

  2. Copia e incolla i seguenti contenuti in user-cluster.yaml e salva il file:

apiVersion: v1
kind: UserCluster
name: "minimal-installation-user-cluster"
gkeOnPremVersion: "1.28.100-gke.131"
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

Convalida la configurazione e crea il cluster

  1. Verifica che il file di configurazione del cluster utente sia valido e che possa essere utilizzato per la creazione del cluster:

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

  2. Crea il cluster utente:

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

    La creazione del cluster richiede circa 30 minuti.

Individua il file kubeconfig del cluster utente

Il comando gkectl create cluster crea un file kubeconfig denominato USER_CLUSTER_NAME-kubeconfig nella directory attuale. Questo file kubeconfig sarà necessario in un secondo momento per interagire con il cluster utente.

Verifica che il cluster utente sia in esecuzione

Verifica che il cluster utente sia in esecuzione:

kubectl get nodes --kubeconfig USER_CLUSTER_KUBECONFIG

Sostituisci USER_CLUSTER_KUBECONFIG con il percorso del file kubeconfig del cluster utente.

L'output mostra i nodi del cluster utente. Ad esempio:

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

Abilita autorizzazione RBAC

Per concedere al tuo account utente il ruolo Kubernetes clusterrole/cluster-admin nel cluster, esegui questo comando:

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

L'output di questo comando è simile al seguente, che viene troncato per la leggibilità:

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.

Tra le altre cose, il criterio RBAC ti consente di accedere al cluster nella console Google Cloud utilizzando Google Identity per visualizzare ulteriori dettagli sul cluster.

Registrazione automatica nell'API GKE On-Prem

Poiché l'API GKE On-Prem è abilitata nel tuo progetto, il cluster viene automaticamente registrato nell'API GKE On-Prem. Ciò consente di utilizzare la console o gcloud CLI per visualizzare i dettagli del cluster e gestire il ciclo di vita del cluster. Ad esempio, puoi eseguire i comandi can gcloud per ricevere informazioni sul cluster utente.

Console

  1. Nella console, vai alla pagina Cluster Anthos.

    Vai a Cluster Anthos

  2. Seleziona il progetto Google Cloud in cui vuoi creare il cluster. Il progetto selezionato viene utilizzato anche come progetto host del parco risorse. Deve essere lo stesso progetto in cui è registrato il cluster di amministrazione. Dopo la creazione, il cluster utente viene registrato automaticamente nel parco risorse del progetto selezionato.

  3. Fai clic su Crea cluster.

  4. Nella finestra di dialogo, fai clic su On-premise.

  5. Accanto a VMware vSphere, fai clic su Configura.

Le sezioni seguenti illustrano la procedura per configurare il cluster utente.

Prerequisiti

  1. Acquisisci familiarità con le informazioni riportate nella pagina Prerequisiti.

  2. In fondo alla pagina, fai clic su Avanti.

Impostazioni di base del cluster

  1. In Nome, inserisci un nome per il cluster utente, ad esempio minimal-installation-user-cluster.

  2. In Cluster di amministrazione, seleziona minimal-installation-admin-cluster.

  3. Nel campo Posizione API Google Cloud, seleziona us-central1.

  4. In Versione, seleziona 1.28.100-gke.131.

  5. Non è necessario aprire la sezione Autorizzazione o la sezione Configurazione di vCenter.

  6. Tocca Avanti.

Piano di controllo

  1. In IP dei nodi del piano di controllo, per Gateway, inserisci DEFAULT_GATEWAY_IP.

  2. In Subnet mask, inserisci NETMASK.

  3. In Indirizzi IP, in Indirizzo IP 1, inserisci USER_CONTROL_PLANE_NODE_IP. Lascia vuoto il campo Hostname 1 (Nome host 1).

  4. Tocca Avanti.

Networking

In questa sezione devi specificare gli indirizzi IP per i nodi, i pod e i servizi del cluster. Un cluster utente deve avere un indirizzo IP per ogni nodo e un indirizzo IP aggiuntivo per un nodo temporaneo, necessario durante gli upgrade, gli aggiornamenti e la riparazione automatica del cluster. Per maggiori informazioni, consulta Quanti indirizzi IP ha bisogno un cluster utente?.

  1. In IP dei nodi worker, per Modalità IP, assicurati che sia selezionata l'opzione Statico.

  2. In Gateway, inserisci DEFAULT_GATEWAY_IP.

  3. In Subnet mask, inserisci NETMASK.

  4. In Indirizzi IP, inserisci i seguenti indirizzi:

  • USER_NODE_IP_1
  • USER_NODE_IP_2
  • USER_NODE_IP_3
  • USER_NODE_IP_4

Lascia vuoti i campi Hostname (Nome host).

  1. In CIDR servizio, inserisci 10.96.0.0/20. In CIDR pod, inserisci 192.168.0.0/16.

  2. In DNS Server 1, inserisci DNS_SERVER_IP.

  3. In NTP Server 1, inserisci NTP_SERVER_IP.

  4. Lascia vuoto il campo Dominio di ricerca DNS.

  5. Tocca Avanti.

Bilanciatore del carico

  1. In Tipo di bilanciatore del carico, seleziona Abbinato a MetalLB.

  2. In Pool di indirizzi, utilizza il nome predefinito.

  3. In Indirizzi IP, per Intervallo di indirizzi IP 1, inserisci USER_INGRESS_VIP/32.

    Fai clic su Aggiungi intervallo di indirizzi IP. In Intervallo di indirizzi IP 1, inserisci SERVICE_VIP_1/32

    Fai clic su Aggiungi intervallo di indirizzi IP. In Intervallo di indirizzi IP 2, inserisci SERVICE_VIP_2/32

  4. In Assegnazione di indirizzi IP, seleziona Automatico.

  5. Lascia deselezionata l'opzione Evita indirizzi IP con bug.

  6. In IP virtuali, per VIP piano di controllo inserisci USER_CONTROL_PLANE_VIP. Il campo Viper in entrata è già compilato.

  7. Fai clic su Continua.

Funzionalità

  1. Lascia invariate tutte le impostazioni predefinite.

  2. Tocca Avanti.

Pool di nodi

  1. Lascia invariate tutte le impostazioni predefinite.

  2. Fai clic su Verifica e completa per creare il cluster utente. La creazione del cluster utente richiede almeno 15 minuti. La console visualizza messaggi di stato durante la verifica delle impostazioni e la creazione del cluster nel data center.

    Se si verifica un errore durante la verifica delle impostazioni, nella console viene visualizzato un messaggio di errore sufficientemente chiaro da permetterti di risolvere il problema di configurazione e riprovare a creare il cluster.

    Per maggiori informazioni sui possibili errori e su come correggerli, consulta Risolvere i problemi dei cluster registrati nell'API GKE On-Prem.

Terraform

Questa sezione mostra come creare un cluster utente e un pool di nodi utilizzando Terraform. Per ulteriori informazioni e altri esempi, consulta quanto segue:

  1. Crea una directory e un nuovo file all'interno di quella directory. Il nome del file deve avere l'estensione .tf. In questa guida, il file è denominato main.tf.

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

  2. Verifica la risorsa Terraform del cluster utente:

    Il seguente esempio di risorsa Terraform viene compilato con i valori inseriti nella tabella di pianificazione della sezione precedente.

    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.100-gke.131"
  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. Copia la risorsa Terraform in main.tf e salva il file.

  4. Inizializza e crea il piano Terraform:

    terraform init

    Terraform installa tutte le librerie necessarie, ad esempio il provider Google Cloud.

  5. Rivedi la configurazione e apporta modifiche, se necessario:

    terraform plan

  6. Applica il piano Terraform per creare il cluster utente:

    terraform apply

    Quando richiesto, inserisci yes.

    La creazione del cluster utente di base e del pool di nodi richiede circa 15 minuti (o più, a seconda della rete).

gcloud

Crea il 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.100-gke.131 \
  --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'

L'output del comando è simile al seguente:

Waiting for operation [projects/example-project-12345/locations/us-central1/operations/operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179] to complete.

Nell'output di esempio, la stringa operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179 è la stringa OPERATION_ID dell'operazione a lunga esecuzione. Puoi trovare lo stato dell'operazione con il seguente comando:

gcloud container vmware operations describe OPERATION_ID \
  --project=PROJECT_ID \
  --location=us-central1

Per maggiori informazioni, consulta la pagina relativa alle operazioni di gcloud container vmware.

La creazione del cluster utente richiede almeno 15 minuti. Puoi visualizzare il cluster nella console sulla pagina Cluster Anthos.

Crea un pool di nodi:

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

Passaggi successivi

Hai completato questa installazione minima di GKE su VMware. Come follow-up facoltativo, puoi vedere l'installazione in azione eseguendo il deployment di un'applicazione.