Creare cluster di base

Questa è la seconda parte di una guida che illustra la procedura di installazione di un piccolo proof of concept di Google Distributed Cloud. La prima parte sono Configurare un'infrastruttura minima che ti mostra come pianificare gli indirizzi IP e configurare la connessione vSphere necessaria e l'infrastruttura Google Cloud per il tuo deployment. Questo documento si basa sulla configurazione e pianificazione che hai fatto nella sezione precedente, che ti mostra come creare una workstation di amministrazione, un cluster di amministrazione e un cluster utente nella piattaforma vSphere utilizzando semplici modelli che puoi compilare qui in questo documento. Tu può quindi procedere con il deployment di un'applicazione.

Come per la configurazione dell'infrastruttura di questa semplice installazione, i cluster configurazione utilizzando questo documento potrebbe non essere adatta alla tua produzione effettiva esigenze e casi d'uso. Per ulteriori informazioni, best practice e istruzioni per le installazioni di produzione, consulta 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 avere Terraform sulla tua workstation di amministrazione o su un altro computer.

Panoramica della procedura

Di seguito sono riportati i passaggi principali necessari per questa 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 Google Distributed Cloud, inclusi il nome utente e la password di vCenter e gli indirizzi IP che hai preparato nella sezione precedente.

3. Crea una workstation di amministrazione con 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 tuoi carichi di lavoro.

1. Accedi a Google Cloud CLI

La configurazione di Google Distributed Cloud richiede più account di servizio con autorizzazioni diverse. Devi quindi aver eseguito l'accesso a Google Cloud CLI con un account che dispone delle autorizzazioni necessarie per creare e configurare account di servizio, poiché gkeadm utilizza l'attuale gcloud CLI account proprietà quando esegui questa configurazione.

1. Accedi all'interfaccia a riga di comando gcloud. Puoi utilizzare qualsiasi Account Google, ad eccezione di deve avere autorizzazioni richieste. Se hai seguito la parte precedente di questa guida, probabilmente hai già eseguito l'accesso con un account appropriato per creare il tuo componente di accesso all'account di servizio.

   gcloud auth login
   

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

   gcloud config list
   

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

   [core]
   account = [e-mail]
   disable_usage_reporting = False
   Your active configuration is: [default]
   

3. Assicurati di aver installato i componenti più recenti dell'interfaccia a riga di comando gcloud:

   gcloud components update
   

   A seconda di come hai installato gcloud CLI, potresti vedere il seguente messaggio: "Non puoi eseguire questa azione perché gli Il gestore dei componenti dell'interfaccia a riga di comando Cloud è disabilitato per questa installazione. Puoi eseguire il comando seguente per ottenere lo stesso risultato per questa installazione:" Segui le istruzioni per copiare e incollare il comando da aggiornare tra i componenti.

2. Raccogliere informazioni

Utilizza le informazioni che hai preparato in Configurare un'infrastruttura minima per modificare i segnaposto nella tabella seguente:

Attenzione: i segnaposto modificabili in questa tabella non sono permanenti. Tutti i valori inseriti nella tabella vengono reimpostati se chiudi o aggiorni la scheda del browser o se esci da questa pagina. Se i segnaposto nella tabella non sono modificabili, potresti dover aggiornare la pagina.

Dettagli vSphere
Il nome utente del tuo account vCenter	USERNAME
La password del tuo account vCenter	PASSWORD
Il tuo indirizzo vCenter Server	ADDRESS
Il percorso del certificato CA principale per il server vCenter, 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 cluster vSphere	VSPHERE_CLUSTER
Il nome o il percorso del pool di risorse vSphere. Per ulteriori informazioni, consulta vcenter.resourcePool.	RESOURCE_POOL
Il nome del tuo datastore vSphere	DATASTORE
Il nome della tua rete vSphere	NETWORK
Indirizzi IP
Un indirizzo IP per la tua workstation di amministrazione	ADMIN_WS_IP
Tre indirizzi IP per i nodi del control plane del cluster di amministrazione.	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 worker del cluster utente. È incluso un 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 dall'amministratore nodi della workstation e del cluster	NTP_SERVER_IP
L'indirizzo IP del gateway predefinito per la subnet contenente la workstation di amministrazione e i nodi del cluster	DEFAULT_GATEWAY_IP
La netmask per la subnet a cui si trovano la workstation di amministrazione e il cluster nodes Esempio: 255.255.255.0	NETMASK
Se la rete è protetta da un server proxy, l'URL del server proxy. Per ulteriori informazioni, consulta proxy. Se necessario, compilalo manualmente nel file di configurazione della workstation amministrativa.	PROXY_URL
Intervalli CIDR per servizi e pod
Il cluster di amministrazione e 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 non sia necessario modificarli in evitare sovrapposizioni con altri elementi della tua 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 di Google Cloud
L'ID che hai scelto Progetto Cloud	PROJECT_ID
Il percorso del file della chiave JSON per l'account di servizio di accesso ai componenti configurato nella sezione precedente, sul computer che utilizzerai per creare la stazione di lavoro di amministrazione.	COMPONENT_ACCESS_SA_KEY_PATH
L'indirizzo email associato al tuo account Google Cloud. Ad esempio: [e-mail].	GOOGLE_ACCOUNT_EMAIL

3. Creazione di una workstation di amministrazione

Prima di poter creare cluster, devi creare una workstation di amministrazione e connetterti 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. Utilizza lo strumento a riga di comando gkeadm per creare la workstation di amministrazione.

Scarica gkeadm

Scarica gkeadm nella tua directory attuale:

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

È necessaria la versione gkeadm (che è anche la versione di Google Distributed Cloud) per creare i file di configurazione dei cluster utente e di amministrazione. Per controllare la versione di gkeadm, esegui quanto segue:

./gkeadm version

L'esempio di output seguente mostra la versione.

gkeadm 1.30.0 (1.30.0-gke.1930)

Sebbene tu possa scaricare un'altra versione di gkeadm, questa guida presuppone che tu stia installando la versione 1.30.0-gke.1930 e la utilizzi in tutti i file di configurazione e i comandi.

Crea il file delle credenziali

Crea e salva un file denominato credential.yaml nella directory corrente con il seguente contenuto:

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 di questo comando:

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

L'output fornisce informazioni dettagliate sulla creazione dell'amministratore workstation e fornisce un comando che puoi usare per ottenere una connessione SSH alla workstation di amministrazione. Ad esempio:

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

Nell'output precedente, l'indirizzo IP è un esempio. L'indirizzo IP del tuo e la workstation di amministrazione. Prendi nota dell'indirizzo IP della tua workstation amministrativo. Ti servirà nel passaggio successivo.

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 dalla tua 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 della tua macchina locale in cui hai eseguito gkeadm create admin-workstation. Questo file contiene i dettagli della workstation di amministrazione, incluso il comando SSH.

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

Copia la chiave di registrazione degli audit sulla workstation di amministrazione

Nella sezione precedente hai creato un file della chiave JSON per il tuo account di servizio per la registrazione degli audit.

Copia il file della chiave JSON nella home directory della 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:~

Visualizzare i file sulla workstation di amministrazione

Ancora una volta, accedi alla workstation di amministrazione tramite SSH.

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

ls -1

L'output dovrebbe includere:

• admin-cluster.yaml, un file di configurazione modello per creare il cluster di amministrazione.
• user-cluster.yaml, un file di configurazione modello per creare il 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 della chiave JSON per l'account di servizio di registrazione degli audit.
• File di chiavi JSON per due account di servizio che gkeadm ha creato per te: un account di servizio di registrazione e un account di servizio di monitoraggio e registrazione, nonché il file della chiave per l'account di servizio di accesso ai componenti che hai 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, dovrai specificare alcuni di questi nomi file nei file di configurazione. Utilizza i nomi file come valori per i segnaposto nella seguente tabella:

Nome del file della chiave del service account Connect-register Esempio: connect-register-sa-2203040617.json	CONNECT_REGISTER_SA_KEY
Nome file della chiave dell'account di servizio di monitoraggio dei log Esempio: log-mon-sa-2203040617.json	LOG_MON_SA_KEY
Nome file della chiave dell'account di servizio dell'audit logging Esempio: audit-logging-key.json	AUDIT_LOG_SA_KEY
Nome file della chiave dell'account di servizio di 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. Prima di iniziare questo passaggio, assicurati di avere una connessione SSH alla workstation di amministrazione, come descritto in precedenza. Tutti i comandi riportati di seguito vengono eseguiti sulla workstation di amministrazione.

Nota: se utilizzi i nomi DNS interni o la workstation non può accedere Per gli indirizzi DNS pubblici di Google (8.8.8.8 o 8.8.4.4), devi specificare nameserver in /etc/resolv.conf.

Crea il file di configurazione del cluster di amministrazione

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

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"

Convalida il file di configurazione del cluster di amministrazione

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

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

Importa le immagini del 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 VM, inclusa l'immagine per il cluster di amministrazione.

L'esecuzione di questo comando può 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 corrente. Ti servirà questo file kubeconfig in un secondo momento per interagire con il cluster di amministrazione.

Verificare 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:

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

Abilita autorizzazione RBAC

Per concedere al tuo account utente il ruolo clusterrole/cluster-admin di Kubernetes sul 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 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 tuo cluster 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 registrate automaticamente nell'API GKE On-Prem. Registrazione dell'amministratore dell'API GKE On-Prem consente di usare strumenti standard, console Google Cloud, Google Cloud CLI Terraform: per creare, eseguire l'upgrade aggiornare ed eliminare i cluster utente gestiti dal cluster di amministrazione. Registrazione il cluster ti consente anche di eseguire comandi gcloud per ottenere informazioni sul cluster.

5. Creazione di un cluster utente

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

gkectl

Prima di iniziare questa procedura, assicurati di avere una connessione SSH alla tua workstation di amministrazione, come descritto in precedenza. Tutti i seguenti comandi vengono eseguite sulla workstation di amministrazione.

Crea il file di blocco 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 di 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.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

Convalida la configurazione e crea il cluster

1. Verifica che il file di configurazione del cluster utente sia valido e 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.

Individuare il file kubeconfig del cluster utente

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

Verificare 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 cluster utente kubeconfig.

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 clusterrole/cluster-admin di Kubernetes sul 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 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 tuo cluster 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 registrato automaticamente nell'API GKE On-Prem. In questo modo puoi utilizzare o gcloud CLI per visualizzare i dettagli del cluster e gestire il relativo ciclo di vita. Ad esempio, puoi eseguire comandi gcloud per ottenere informazioni sul cluster di utenti.

Console

1. Nella console Google Cloud, vai alla sezione Crea un del cluster Google Distributed Cloud.

   Vai a Creare un cluster Google Distributed Cloud

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 a cui è registrato il cluster di amministrazione. Dopo che l'utente il cluster viene creato, viene registrato automaticamente nell'istanza nel parco risorse del progetto.

Le sezioni seguenti illustrano la configurazione del 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. Per Cluster di amministrazione, seleziona minimal-installation-admin-cluster.

3. Per il campo Località API Google Cloud, seleziona us-central1.

4. In Versione, seleziona 1.30.0-gke.1930.

5. Non è necessario aprire la sezione Authorization o vCenter configurazione.

6. Fai clic su Avanti.

Control plane

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, per Indirizzo IP 1, inserisci USER_CONTROL_PLANE_NODE_IP. Lascia vuoto Nome host 1.

4. Fai clic su Avanti.

Networking

In questa sezione specifichi gli indirizzi IP dei nodi, dei pod, e servizi. Un cluster utente deve avere un indirizzo IP per ogni nodo e indirizzo IP aggiuntivo per un nodo temporaneo necessario durante il cluster upgrade, aggiornamenti e riparazioni automatiche. Per ulteriori informazioni, consulta Quanti indirizzi IP sono necessari per un cluster di utenti?.

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

2. In Gateway, inserisci DEFAULT_GATEWAY_IP.

3. Per 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 del pod, inserisci 192.168.0.0/16.

2. In Server DNS 1, inserisci DNS_SERVER_IP.

3. In Server NTP 1, inserisci NTP_SERVER_IP.

4. Lascia vuoto DNS search domain (Dominio di ricerca DNS).

5. Fai clic su Avanti.

Bilanciatore del carico

1. In Tipo di bilanciatore del carico, seleziona In bundle con 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 Automatica.

5. Lascia deselezionata l'opzione Evita indirizzi IP che presentano bug.

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

7. Fai clic su Continua.

Funzionalità

1. Lascia invariate tutte le impostazioni predefinite.

2. Fai clic su Avanti.

Pool di nodi

1. Lascia invariate tutte le impostazioni predefinite.

2. Fai clic su Verifica e completa per creare il cluster utente. Ci vogliono 15 minuti o più per creare il cluster utente. La console mostra i messaggi di stato durante la verifica delle impostazioni e la creazione del cluster nel tuo data center.

   Se si verifica un errore durante la verifica delle impostazioni, nella console viene visualizzato un errore che dovrebbe essere abbastanza chiaro da consentire di risolvere il problema di configurazione. e riprova a creare il cluster.

   Per ulteriori informazioni sui possibili errori e su come correggerli, consulta Risolvi 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 con Terraform. Per ulteriori informazioni e altri esempi, consulta quanto segue:

• google_gkeonprem_vmware_cluster

• google_gkeonprem_vmware_node_pool

• terraform.tfvars.sample

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

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

2. Verifica la risorsa Terraform del cluster utente:

   Il seguente esempio di risorsa Terraform è compilato con i valori che inserito nella tabella di pianificazione nella 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.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. Copia la risorsa Terraform in main.tf e salva il file.

4. Inizializza e crea il piano Terraform:

   terraform init
   

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

5. Rivedi la configurazione e apporta le modifiche necessarie:

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

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 è il OPERATION_ID dell'operazione a lungo termine. Puoi scoprire lo stato dell'operazione con il seguente comando:

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

Per ulteriori informazioni, vedi operazioni di gcloud container vmware.

Per creare il cluster utente sono necessari almeno 15 minuti. Puoi visualizzare nel cluster nella console Pagina di riepilogo dei cluster di Google Kubernetes Engine.

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 Google Distributed Cloud. Come seguito facoltativo, puoi vedere l'installazione in azione implementando un'applicazione.