Questa pagina mostra come creare un cluster utente Google Distributed Cloud su macchine virtuali (VM) Compute Engine. La script fornito crea VM di Compute Engine per i nodi dei cluster di amministrazione e utente la workstation di amministrazione.
La workstation di amministrazione ospita strumenti di interfaccia a riga di comando (CLI) e di configurazione per eseguire il provisioning dei cluster durante l'installazione e strumenti dell'interfaccia a riga di comando per interazione con i cluster di cui è stato eseguito il provisioning dopo l'installazione. Lo script viene installato gli strumenti dell'interfaccia a riga di comando sulla VM della workstation di amministrazione.
Un cluster utente è un cluster Kubernetes che esegue i carichi di lavoro containerizzati. È composto dai nodi del piano di controllo e dai nodi worker. I cluster utente devono Contenere uno o più nodi worker che eseguono i carichi di lavoro utente. Un cluster di amministrazione è un cluster Kubernetes che gestisce uno o più cluster utente, contribuendo la creazione, gli aggiornamenti e l'eliminazione dei cluster utente. Un cluster di amministrazione è composto da solo i nodi del piano di controllo. Per saperne di più, vedi Deployment dei cluster di amministrazione e degli utenti.
Lo script configura una rete overlay Virtual Extensible LAN (VXLAN) tra le VM e le prepara per la creazione del cluster. Facoltativamente, lo script crea un cluster di amministrazione o puoi scegliere di crearlo personalmente per conoscere gli strumenti forniti da Google Distributed Cloud per creare cluster.
Con lo script fornito, puoi provare Google Distributed Cloud rapidamente e senza dover preparare alcun hardware. Completa i passaggi in questa pagina fornisce un ambiente di test Google Distributed Cloud funzionante che esegue su Compute Engine.
Che cos'è l'API GKE On-Prem?
L'API GKE On-Prem è un'API ospitata da Google Cloud che consente di gestire del ciclo di vita dei cluster on-premise utilizzando Terraform e le applicazioni Google Cloud. L'API GKE On-Prem viene eseguita dell'infrastruttura. Terraform, la console gcloud CLI sono client dell'API che la utilizzano per creare nel tuo data center.
Per gestire il ciclo di vita dei tuoi cluster, l'API GKE On-Prem deve archiviare i metadati sullo stato del cluster in Google Cloud, utilizzando Regione Google Cloud specificata durante la creazione del cluster. Questo metadati consentono all'API di gestire il ciclo di vita del cluster includono dati specifici dei carichi di lavoro.
Quando crei un cluster utilizzando un client API GKE On-Prem, specifichi progetto Google Cloud. Una volta creato, il cluster viene automaticamente sono registrati nello spazio dei nomi di progetto flotta. Questo progetto è denominato progetto host del parco risorse. Il progetto host del parco risorse non può essere modificato dopo la creazione del cluster.
Prima di iniziare
- Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
- Prendi nota dell'ID progetto perché ti serve per impostare un ambiente utilizzata nello script e nei comandi di questa pagina. Se selezionato un progetto esistente, assicurati di essere un proprietario del progetto o un editor.
-
Puoi eseguire lo script su Cloud Shell o
su un computer locale con Linux o macOS. Se non utilizzi
Cloud Shell:
- Assicurati di aver installato l'ultima versione
Google Cloud CLI, lo strumento a riga di comando per
a interagire con Google Cloud. Aggiorna i componenti della gcloud CLI,
se necessario:
gcloud components update
A seconda di come è stata installata la gcloud CLI, potresti vedere il seguente messaggio: "Non puoi eseguire questa azione perché Il gestore dei componenti della gcloud CLI è disabilitato per questa installazione. Per ottenere lo stesso risultato, puoi eseguire questo comando installazione:" Segui le istruzioni per copiare e incollare il comando da aggiornare tra i componenti.
- Assicurati di avere installato
kubectl
. Per installakubectl
, esegui questo comando:gcloud components install kubectl
- Assicurati di aver installato l'ultima versione
Google Cloud CLI, lo strumento a riga di comando per
a interagire con Google Cloud. Aggiorna i componenti della gcloud CLI,
se necessario:
Crea l'infrastruttura VM e, facoltativamente, il cluster di amministrazione
Segui questi passaggi per configurare ed eseguire lo script. La lo script scaricato ed eseguito proviene anthos-campioni repository Git. Per ulteriori informazioni sullo script prima di eseguirlo, consulta alla sezione successiva, Informazioni sullo script.
Configura le variabili di ambiente:
export PROJECT_ID=PROJECT_ID export ADMIN_CLUSTER_NAME=ADMIN_CLUSTER_NAME export ON_PREM_API_REGION=ON_PREM_API_REGION export ZONE=ZONE
ON_PREM_API_REGION
: la regione Google Cloud in che l'API GKE On-Prem esegue e archivia i relativi metadati. Specificaus-central1
o altro regione supportata.ZONE
: la zona Google Cloud in cui Verranno create le VM di Compute Engine. Puoi usareus-central1-a
o qualsiasi altro Zone Compute Engine.
Imposta il progetto e la zona predefiniti:
gcloud config set project $PROJECT_ID gcloud config set compute/zone $ZONE
Se viene visualizzato un errore
PERMISSION_DENIED
, controlla l'ID progetto inserito. Se l'ID progetto è corretto, eseguigcloud auth login
per accedere a gcloud CLI con l'account che ha accesso del progetto.Ottieni un elenco di versioni di Google Distributed Cloud che puoi installare:
gcloud container bare-metal admin-clusters query-version-config \ --location=ON_PREM_API_REGION
Alcune istruzioni in questo documento dipendono dall'API GKE On-Prem, che supporta un sottoinsieme di versioni Google Distributed Cloud disponibili.
Seleziona una versione dall'output del comando precedente e impostala in una variabile di ambiente:
export BMCTL_VERSION=BMCTL_VERSION
Ti consigliamo di selezionare la versione più compatibile per poter scaricare le funzionalità e le correzioni più recenti di Google Distributed Cloud.
Clona il repository
anthos-samples
e passa alla directory dove si trova lo script:git clone https://github.com/GoogleCloudPlatform/anthos-samples cd anthos-samples/anthos-bm-gcp-bash
Esegui lo script:
bash install_admin_cluster.sh
Quando richiesto, inserisci un numero per scegliere la modalità di installazione:
- Inserisci 1 per fare in modo che lo script configuri l'infrastruttura VM e lo installi il cluster di amministrazione.
- Inserisci 2 per fare in modo che lo script configuri solo l'infrastruttura VM.
Quando richiesto, conferma la selezione.
Lo script restituisce ogni comando che esegue e lo stato. Al termine, lo script restituisce quanto segue, a seconda che tu abbia scelto di installare o meno cluster di amministrazione:
Cluster di amministrazione creato
✅ Installation complete. Please check the logs for any errors!!! ✅ If you do not see any errors in the output log, then you now have the following setup: |---------------------------------------------------------------------------------------------------------| | VM Name | L2 Network IP (VxLAN) | INFO | |---------------------------------------------------------------------------------------------------------| | abm-admin-cluster-cp1 | 10.200.0.3 | Has control plane of admin cluster running inside | | abm-user-cluster-cp1 | 10.200.0.4 | 🌟 Ready for use as control plane for the user cluster | | abm-user-cluster-w1 | 10.200.0.5 | 🌟 Ready for use as worker for the user cluster | | abm-user-cluster-w2 | 10.200.0.6 | 🌟 Ready for use as worker for the user cluster | |---------------------------------------------------------------------------------------------------------|
Configura solo le VM
|---------------------------------------------------------------------------------------------------------| | VM Name | L2 Network IP (VxLAN) | INFO | |---------------------------------------------------------------------------------------------------------| | abm-admin-cluster-cp1 | 10.200.0.3 | 🌟 Ready for use as control plane for the admin cluster | | abm-user-cluster-cp1 | 10.200.0.4 | 🌟 Ready for use as control plane for the user cluster | | abm-user-cluster-w1 | 10.200.0.5 | 🌟 Ready for use as worker for the user cluster | | abm-user-cluster-w2 | 10.200.0.6 | 🌟 Ready for use as worker for the user cluster | |---------------------------------------------------------------------------------------------------------|
Informazioni sullo script
Per scoprire di più su
install_admin_cluster.sh
, fai clic
Informazioni sullo script nella
alla riga successiva.
Informazioni sullo script
Lo script automatizza i seguenti passaggi manuali:
-
Crea un account di servizio denominato
baremetal-gcr
e concede autorizzazioni aggiuntive dell'account di servizio per evitare di aver bisogno di più servizi per API e servizi diversi. -
Abilita le seguenti API Google Cloud:
anthos.googleapis.com anthosaudit.googleapis.com anthosgke.googleapis.com cloudresourcemanager.googleapis.com connectgateway.googleapis.com container.googleapis.com gkeconnect.googleapis.com gkehub.googleapis.com gkeonprem.googleapis.com iam.googleapis.com logging.googleapis.com monitoring.googleapis.com opsconfigmonitoring.googleapis.com serviceusage.googleapis.com stackdriver.googleapis.com storage.googleapis.com
-
Crea le seguenti VM:
- Una VM per la workstation di amministrazione. La workstation di amministrazione avrà e l'accesso a tutti gli altri nodi del cluster tramite SSH.
- Una VM per il nodo del piano di controllo del cluster di amministrazione.
- Due VM per i nodi worker del cluster utente.
- Una VM per il nodo del piano di controllo del cluster utente.
- Crea una rete overlay Virtual Extensible LAN (VXLAN) per il livello 2 e la connettività tra le VM. La VXLAN non è persistente, quindi se e riavviare un'istanza VM. La rete viene eliminata. La rete è configurata in modo da essere attiva 10.200.0.0/24. La connettività di livello 2 è un requisito per bilanciatore del carico in bundle.
-
Installa i seguenti strumenti sulla workstation di amministrazione:
bmctl
kubectl
- Docker
Lo script scarica anche la chiave dell'account di servizio per
baremetal-gcr
account di servizio alla workstation di amministrazione. -
Garantisce che
root@10.200.0.x
della workstation di amministrazione funzioni svolgendo le seguenti attività:- Genera una nuova chiave SSH sulla workstation di amministrazione.
- Aggiunge la chiave pubblica a tutte le altre VM nel deployment.
-
Facoltativamente, lo script crea il cluster di amministrazione con quanto segue
di configurazione del deployment:
Se hai scelto che lo script crei il cluster di amministrazione, lo script utilizza Accedi tramite SSH alla workstation di amministrazione come utente root. Quindi, lo script esegue lo strumento a riga di comando
bmctl
per creare il cluster di amministrazione. Questo è uno degli strumenti che puoi usare per creare cluster di amministrazione.Quando Google Distributed Cloud crea i cluster, esegue il deployment di un Cluster Docker (kind) sulla workstation di amministrazione. Questo bootstrap che ospita i controller Kubernetes necessari per creare i cluster utilizzata per creare il cluster di amministrazione. Al momento della creazione, i titolari pertinenti vengono dal cluster di bootstrap al cluster di amministrazione. Infine, a meno che se non lo specifichi, il cluster di bootstrap viene rimosso al momento della creazione del cluster viene completata correttamente. Il cluster di bootstrap richiede il pull di Docker immagini container.
Facoltativamente, crea il cluster di amministrazione
Se lo script ha creato il cluster di amministrazione, vai alla sezione successiva Verifica il cluster di amministrazione. Altrimenti, segui i passaggi in questa sezione per creare un cluster di bootstrap e il cluster di amministrazione.
Prima di creare il cluster di amministrazione, devi eseguire
bmctl register bootstrap
sulla workstation di amministrazione. Questo comando
esegue il deployment di un cluster Kubernetes temporaneo in Docker (kind) sul
la workstation. Questo cluster di bootstrap ospita i controller Kubernetes necessari
per creare il cluster di amministrazione. Quando crei il cluster di amministrazione, i controller
il cluster di bootstrap eseguirà il provisioning dei nodi, eseguirà i controlli preflight e registra
il cluster di amministrazione al parco risorse. Il cluster di bootstrap viene eliminato automaticamente
dopo la creazione del cluster.
Console
Nella console, vai a Crea un cluster bare metal. .
Assicurati di selezionare
PROJECT_ID
dall'elenco dei progetti.Nella barra di navigazione a sinistra, fai clic su Installa ambiente di bootstrap.
Inserisci
ADMIN_CLUSTER_NAME
come il nome del cluster di amministrazione. Nota che il nome del cluster di bootstrap viene derivato anteponendo bootstrap- al nome del cluster di amministrazione.Seleziona
VERSION
come versione per del cluster di amministrazione. Lo script ha scaricato questa versione dibmctl
a strumento a riga di comando alla workstation di amministrazione. Il Google Distributed Cloud installata deve corrispondere alla versionebmctl
.Nel campo Posizione API Google Cloud, seleziona ON_PREM_API_REGION da dall'elenco di lettura. Questa impostazione specifica la regione in cui viene eseguita l'API GKE On-Prem la regione in cui sono archiviati i seguenti elementi:
- I metadati del cluster necessari all'API GKE On-Prem per gestire il ciclo di vita del cluster
- I dati di Cloud Logging e Cloud Monitoring dei componenti di sistema
- Il log di controllo Admin creato da Cloud Audit Logs
Il nome del cluster, il progetto e la località identificano in modo univoco in un cluster Google Cloud.
Utilizza i passaggi della sezione successiva anziché quelli mostrati nella per creare il cluster di bootstrap. Esci dalla visualizzata perché tornerai alla pagina per creare il cluster di amministrazione.
Interfaccia a riga di comando gcloud
Apri una nuova finestra del terminale. Utilizzerai la seconda finestra del terminale per connetterti alla workstation di amministrazione per creare il cluster di bootstrap. Utilizzerai il prima finestra del terminale per eseguire il comando gcloud CLI per creare del cluster di amministrazione.
Crea il cluster di bootstrap
Esegui i seguenti passaggi sulla workstation di amministrazione.
Utilizza SSH per accedere alla workstation di amministrazione come root:
gcloud compute ssh root@abm-ws --zone ZONE
Puoi ignorare gli eventuali messaggi relativi all'aggiornamento della VM e completare durante il tutorial. Se prevedi di mantenere le VM come ambiente di test, aggiornare il sistema operativo o eseguire l'upgrade alla release successiva come descritto Documentazione di Ubuntu.
Imposta le tue credenziali utente come Credenziali predefinite dell'applicazione (ADC):
gcloud auth application-default login
Segui le istruzioni per selezionare il tuo Account Google per ADC.
Crea il cluster di bootstrap.
bmctl register bootstrap \ --ssh-key=/root/.ssh/id_rsa \ --name=bootstrap-ADMIN_CLUSTER_NAME \ --project-id=PROJECT_ID
Dopo che bmctl
ha creato correttamente il cluster di bootstrap, vedrai l'output
simile al seguente:
[2023-03-22 17:35:24+0000] Waiting for the temporary cluster to be registered... OK [2023-03-22 17:35:37+0000] Please go to https://console.cloud.google.com/home/dashboard?project=example-project-12345 to create the cluster [2023-03-22 17:35:37+0000] Waiting for preflight checks and cluster to run..
Crea il cluster di amministrazione
Console
Nella pagina Installa ambiente di bootstrap della sezione Bootstrap dell'ambiente della workstation di amministrazione, fai clic su Verifica connessione.
Se l'operazione riesce, la console mostra
Connessione stabilita.Devi stabilire la connessione al cluster di bootstrap prima di continua. Se la connessione non viene stabilita, controlla gli argomenti che specificato per il comando
bmctl register bootstrap
:Assicurati che il valore di
--name
corrisponda a Nome del bootstrap derivato visualizzato in Sezione Nozioni di base sull'ambiente di bootstrap.Assicurati che il valore di
--project-id
corrisponda all'ID del progetto che hai selezionato nella console.
Se devi modificare il nome del cluster di bootstrap o l'ID progetto, inserisci
Ctrl-C
per uscire dabmctl register bootstrap
e esegui nuovamente il comando.Fai clic su Networking nella barra di navigazione a sinistra.
Nella sezione Piano di controllo, inserisci quanto segue nel campo Controllo campo plane node IP 1:
10.200.0.3
Questo è l'indirizzo IP della VM abm-admin-cluster-cp nella VXLAN creata dallo script.
Nella sezione Bilanciatore del carico, assicurati che sia selezionato In bundle.
Nella sezione IP virtuali (VIP), inserisci quanto segue nel campo Campo VIP piano di controllo:
10.200.0.48
Fai clic su Verifica e crea.
Nella console vengono visualizzati messaggi di stato durante la verifica delle impostazioni e crea il cluster.
Interfaccia a riga di comando gcloud
Assicurati che le variabili di ambiente definite in precedenza abbiano lo valori corretti. Anche se il comando di esempio utilizza i segnaposto, devono corrispondere alle variabili di ambiente utilizzate dallo script.
echo $PROJECT_ID echo $ADMIN_CLUSTER_NAME echo $ON_PREM_API_REGION echo $BMCTL_VERSION
Verifica che il cluster di bootstrap sia stato registrato come membro del programma parco risorse:
gcloud container fleet memberships list \ --project=PROJECT_ID
Se il cluster di bootstrap non è in elenco, controlla il nome del cluster e all'ID progetto che hai specificato in
bmctl register bootstrap
. Per modifica il nome del cluster di bootstrap o l'ID progetto, inserisciCtrl-C
per uscire submctl register bootstrap
ed esegui nuovamente il comando.Crea il cluster di amministrazione con il bilanciatore del carico in bundle:
gcloud container bare-metal admin-clusters create ADMIN_CLUSTER_NAME \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION \ --version=BMCTL_VERSION \ --max-pods-per-node=110 \ --control-plane-vip=10.200.0.48 \ --control-plane-load-balancer-port=443 \ --control-plane-node-configs node-ip=10.200.0.3 \ --island-mode-service-address-cidr-blocks=10.96.0.0/20 \ --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \ --lvp-share-path=/mnt/localpv-share \ --lvp-share-storage-class=local-shared \ --lvp-node-mounts-config-path=/mnt/localpv-disk \ --lvp-node-mounts-config-storage-class=local-disks
Nel comando precedente:
--control-plane-vip
: il valore è impostato su10.200.0.48
. questo è l'IP virtuale (VIP) sul bilanciatore del carico del server API Kubernetes del cluster.--control-plane-node-configs
: il valorenode-ip
è impostato su10.200.0.3
. Questo è l'indirizzo IP della VM abm-admin-cluster-cp nella VXLAN creato dallo script.
Per un elenco completo delle segnalazioni e delle relative descrizioni, consulta la Riferimento dell'interfaccia a riga di comando gcloud.
L'output del comando è simile al seguente:
Waiting for operation [projects/example-project-12345/locations/us-west1/operations/operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179] to complete.
Nell'output di esempio, la stringa
operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179
è ilOPERATION_ID
dell'operazione a lunga esecuzione. Puoi scoprire lo stato dell'operazione eseguendo questo in un'altra finestra del terminale:gcloud container bare-metal operations describe OPERATION_ID \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION
I dettagli sul processo di creazione del cluster vengono restituiti all'amministratore
la workstation. Prima di creare il cluster, bmctl
esegue una serie di preflight
per verificare la configurazione. Se i controlli preflight vengono superati, vedrai
ad esempio:
[2023-03-22 23:12:47+0000] Waiting for cluster kubeconfig to become ready OK [2023-03-22 23:15:47+0000] Writing kubeconfig file [2023-03-22 23:15:47+0000] kubeconfig of cluster being created is present at bmctl-workspace/abm-cluster-1/abm-cluster-1-kubeconfig [2023-03-22 23:15:47+0000] Please restrict access to this file as it contains authentication credentials of your cluster. [2023-03-22 23:15:47+0000] Waiting for cluster to become ready OK [2023-03-22 23:20:17+0000] Please run [2023-03-22 23:20:17+0000] kubectl --kubeconfig bmctl-workspace/abm-cluster-1/abm-cluster-1-kubeconfig get nodes [2023-03-22 23:20:17+0000] to get cluster nodes status. [2023-03-22 23:20:17+0000] Waiting for node pools to become ready OK [2023-03-22 23:20:37+0000] Waiting for metrics to become ready in GCP OK [2023-03-22 23:25:38+0000] Waiting for cluster API provider to install in the created admin cluster OK [2023-03-22 23:25:48+0000] Moving admin cluster resources to the created admin cluster [2023-03-22 23:25:51+0000] Waiting for node update jobs to finish OK [2023-03-22 23:27:41+0000] Flushing logs... OK [2023-03-22 23:27:41+0000] Deleting membership... OK [2023-03-22 23:27:42+0000] Deleting bootstrap cluster.
Verifica il cluster di amministrazione
Puoi trovare il file kubeconfig
del cluster di amministrazione sulla workstation di amministrazione in
nella directory bmctl-workspace
dell'account root. Per verificare il deployment,
completa i seguenti passaggi.
Se lo script ha creato il cluster di amministrazione, utilizza SSH per accedere all'amministratore workstation come root:
gcloud compute ssh root@abm-ws --zone ZONE
Puoi ignorare gli eventuali messaggi relativi all'aggiornamento della VM e completare durante il tutorial. Se prevedi di mantenere le VM come ambiente di test, aggiornare il sistema operativo o eseguire l'upgrade alla release successiva come descritto Documentazione di Ubuntu.
Imposta la variabile di ambiente
KUBECONFIG
con il percorso della risorsa del cluster di configurazione del deployment per eseguire i comandikubectl
sul cluster.export clusterid=ADMIN_CLUSTER_NAME export KUBECONFIG=$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig kubectl get nodes
L'output è simile al seguente:
NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane,master 91m v1.24.2-gke.1900
Imposta il contesto attuale in una variabile di ambiente:
export CONTEXT="$(kubectl config current-context)"
Esegui questo comando
gcloud
. Questo comando esegue le seguenti operazioni:- Concede al tuo account utente l'
clusterrole/cluster-admin
di Kubernetes nel cluster. - Configura il cluster in modo da poter eseguire i comandi
kubectl
sul tuo computer locale senza doverti connettere alla workstation di amministrazione tramite SSH. - Ti consente di accedere al cluster nella console utilizzando Identità Google.
Sostituisci
YOUR_EMAIL_ADDRESS
con l'indirizzo email associato è associato al tuo account Google Cloud. Ad esempio:--users=alex@example.com
.gcloud container fleet memberships generate-gateway-rbac \ --membership=ADMIN_CLUSTER_NAME \ --role=clusterrole/cluster-admin \ --users=YOUR_EMAIL_ADDRESS \ --project=PROJECT_ID \ --kubeconfig=$KUBECONFIG \ --context=$CONTEXT\ --apply
L'output di questo comando è simile al seguente, che è troncato per migliorare 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: /root/bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig, context: ADMIN_CLUSTER_NAME-admin@ADMIN_CLUSTER_NAME Writing RBAC policy for user: YOUR_EMAIL_ADDRESS to cluster. Successfully applied the RBAC policy to cluster.
- Concede al tuo account utente l'
Al termine dell'esplorazione, inserisci exit per uscire dall'amministratore. la workstation.
Esegui questo comando sul tuo computer locale per ottenere il file kubeconfig che può accedere al cluster tramite Connetti gateway:
gcloud container fleet memberships get-credentials ADMIN_CLUSTER_NAME
L'output è simile al seguente:
Starting to build Gateway kubeconfig... Current project_id: PROJECT_ID A new kubeconfig entry "connectgateway_PROJECT_ID_global_ADMIN_CLUSTER_NAME" has been generated and set as the current context.
Ora puoi eseguire i comandi
kubectl
tramite il gateway di connessione:kubectl get nodes
L'output è simile al seguente:
NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane,master 94m v1.24.2-gke.1900
In Google Distributed Cloud 1.16 e versioni successive, il cluster viene registrato automaticamente nell'API GKE On-Prem. Ciò ti consente di utilizzare gcloud CLI per eseguire l'upgrade e aggiornare il cluster di amministrazione.
Crea il cluster utente
Quando lo script ha creato il VXLAN L2 per le VM, ha assegnato il seguente IP nella rete 10.200.0.0/24. Questi indirizzi IP vengono utilizzati quando configurando le impostazioni di rete e del pool di nodi per il cluster utente.
Nome VM | IP di rete | Descrizione del nodo |
---|---|---|
abm-admin-cluster-cp1 | 10,200,0,3 | Nodo del piano di controllo per il cluster di amministrazione |
abm-user-cluster-cp1 | 10.200.0,4 | Nodo del piano di controllo per il cluster utente |
abm-user-cluster-w1 | 10,200,0,5 | Nodo worker per il cluster utente |
abm-user-cluster-w2 | 10.200.0,6 | Un altro nodo worker per il cluster utente |
Puoi utilizzare la console Google Cloud, Google Cloud CLI o Terraform per creare per il cluster utente.
Console
Segui questi passaggi per creare un cluster utente nella console:
Nella console, vai a Crea un cluster bare metal. .
Assicurati che il progetto Google Cloud in cui hai creato l'amministratore cluster selezionato.
Fai clic su Crea cluster.
Nella finestra di dialogo, fai clic su On-premise.
Accanto a Bare metal, fai clic su Configura. La pagina Prerequisiti vengono visualizzati i video.
In Scegli il tipo di cluster, seleziona Crea un cluster utente per un cluster di amministrazione esistente
Fai clic su Avanti.
Impostazioni di base del cluster
Inserisci un nome per il cluster utente o utilizza quello predefinito.
Assicurati che il cluster di amministrazione appena creato sia selezionato. Puoi utilizzare i valori predefiniti per le altre impostazioni in questa pagina.
Fai clic su Networking nella barra di navigazione a sinistra.
Networking
Nella sezione Piano di controllo, inserisci quanto segue nel campo Piano di controllo. campo Node IP 1:
10.200.0.4
Questo è l'indirizzo IP della VM abm-user-cluster-cp1 nella VXLAN creata dallo script.
Nella sezione Bilanciatore del carico, utilizza il bilanciatore del carico predefinito, In bundle con MetalLB.
Nella sezione Nuovo pool di indirizzi, inserisci il seguente indirizzo IP nel campo Intervallo di indirizzi IP 1:
10.200.0.51-10.200.0.70
Fai clic su Fine.
Nella sezione IP virtuali, inserisci il seguente indirizzo IP nella Campo VIP piano di controllo:
10.200.0.50
Inserisci il seguente indirizzo IP per il VIP Ingress:
10.200.0.51
Utilizza gli indirizzi IP predefiniti nella sezione CIDR di servizi e pod.
Fai clic su pool predefinito nella barra di navigazione a sinistra.
Crea un pool di nodi
Il cluster deve avere almeno un pool di nodi per i nodi worker. R il pool di nodi è un modello per i gruppi di nodi worker creati in questo in un cluster Kubernetes.
Inserisci il seguente indirizzo IP nel campo Indirizzo dei nodi 1:
10.200.0.5
Questo è l'indirizzo IP della VM abm-user-cluster-w1 nella VXLAN creata dallo script.
Crea il cluster
Fai clic su Verifica e crea per creare il cluster utente.
Per creare il cluster utente sono necessari almeno 15 minuti. La Nella console sono visualizzati messaggi di stato durante la verifica delle impostazioni. e crea il cluster.
Se si verifica un problema con la configurazione, la console visualizza un messaggio di errore che dovrebbe essere abbastanza chiaro da consentirti di correggere di configurazione e riprova a creare il cluster.
Per visualizzare ulteriori informazioni sul processo di creazione, fai clic su Mostra dettagli per visualizzare un riquadro laterale. Clic
per chiudere i dettagli dal riquadro.Alla creazione del cluster viene visualizzato Stato del cluster: in esecuzione.
Dopo aver creato il cluster, fai clic su
Cluster rimasti torna alla pagina Cluster.
Interfaccia a riga di comando gcloud
Utilizza il comando seguente per creare un cluster utente:
gcloud container bare-metal clusters create
Dopo aver creato il cluster, devi creare almeno un pool di nodi utilizzando il seguente comando:
gcloud container bare-metal node-pools create
Per creare il cluster utente:
Assicurati che le variabili di ambiente definite in precedenza abbiano lo valori corretti. Anche se il comando di esempio utilizza i segnaposto, devono corrispondere alle variabili di ambiente utilizzate dallo script.
echo $PROJECT_ID echo $ADMIN_CLUSTER_NAME echo $ON_PREM_API_REGION echo $BMCTL_VERSION
Esegui questo comando per creare il cluster utente. Sostituisci le seguenti:
USER_CLUSTER_NAME
: il nome del cluster.Assicurati che
--admin-users
sia impostato sull'indirizzo email associato a il tuo Account Google per amministrare il cluster.
Gli altri valori del flag sono stati compilati automaticamente. Scorri se necessario per verificare che il flag
--admin-cluster-membership
abbia il valore corretto per il nome del cluster di amministrazione, che è l'ultimo segmento nel nome completo dell'appartenenza.gcloud container bare-metal clusters create USER_CLUSTER_NAME \ --project=PROJECT_ID \ --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \ --location=ON_PREM_API_REGION \ --version=BMCTL_VERSION \ --admin-users=YOUR_EMAIL_ADDRESS \ --metal-lb-address-pools='pool=lb-pool-1,manual-assign=True,addresses=10.200.0.51-10.200.0.70' \ --control-plane-node-configs='node-ip=10.200.0.4' \ --control-plane-vip=10.200.0.50 \ --control-plane-load-balancer-port=443 \ --ingress-vip=10.200.0.51 \ --island-mode-service-address-cidr-blocks=10.96.0.0/20 \ --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \ --lvp-share-path=/mnt/localpv-share \ --lvp-share-storage-class=local-shared \ --lvp-node-mounts-config-path=/mnt/localpv-disk \ --lvp-node-mounts-config-storage-class=local-disks
Nell'elenco che segue vengono descritti i flag:
--project
: l'ID del progetto in cui verrà inserito il cluster utente registrato. Questo progetto è indicato come progetto host del parco risorse.--admin-cluster-membership
: il nome completo del cluster di amministrazione che identifica il cluster di amministrazione nel parco risorse.--location
: la regione Google Cloud in cui l'API GKE On-Prem ne esegue e archivia i metadati.--version
: la versione Google Distributed Cloud.--admin-users
: includi il tuo indirizzo email da concedere a Kubernetes di controllo dell'accesso basato sui ruoli (RBAC, Role-Based Access Control) accesso amministrativo al cluster.--metal-lb-address-pools
: la configurazione del pool di indirizzi per bilanciatore del carico MetalLB in bundle. L'intervallo di indirizzi IP deve essere compreso nel10.200.0.0/24
rete creata dallo script. L'intervallo di indirizzi deve non contengano gli indirizzi IP assegnati alle VM né al piano di controllo VIP. Tieni presente, tuttavia, che il VIP in entrata deve essere compreso in questo intervallo di indirizzi.--control-plane-node-configs
: la configurazione del nodo del piano di controllo per per il cluster utente. Il valore dinode-ip
è10.200.0.4
, ovvero l'IP che lo script ha assegnato alla VMabm-user-cluster-cp1
.--control-plane-vip
: l'IP virtuale per il piano di controllo. Il valore10.200.0.50
si trova nella rete10.200.0.0/24
in cui lo script ma non si sovrappone all'intervallo di indirizzi IP utilizzato per la Pool di indirizzi del bilanciatore del carico MetalLB.--control-plane-load-balancer-port
: la porta gestita dal bilanciatore del carico attivare il piano di controllo. Sebbene sia possibile configurare un altro valore, la porta443
è la porta standard utilizzata per le connessioni HTTPS.--ingress-vip
: l'IP virtuale per il servizio in entrata. Questo indirizzo IP deve essere compreso nell'intervallo di indirizzi IP utilizzato per l'indirizzo del bilanciatore del carico MetalLB piscine.--island-mode-service-address-cidr-blocks
: un intervallo di indirizzi IP, in Formato CIDR, da utilizzare per i servizi nel cluster utente. L'esempio ha utilizzato10.96.0.0/20
, che è il valore predefinito fornito Google Cloud. L'intervallo CIDR deve essere compreso tra /24 e /12, dove /12 fornisce il maggior numero di indirizzi IP. Ti consigliamo di utilizzare una nello spazio di indirizzi IP per le connessioni internet private, come definito RFC 1918.--island-mode-pod-address-cidr-blocks
: un intervallo di indirizzi IP, in Formato CIDR, da utilizzare per i pod nel cluster utente. L'esempio ha utilizzato192.168.0.0/16
, che è il valore predefinito fornito Google Cloud. L'intervallo CIDR deve essere compreso tra /18 e /8, dove /8 fornisce il maggior numero di indirizzi IP. Ti consigliamo di utilizzare un intervallo nello spazio di indirizzi IP per le connessioni internet private, come definito RFC 1918.--lvp-share-path
: questo è il percorso della macchina host in cui le sottodirectory possono possono essere create. Viene creato un PersistentVolume (PV) locale per ogni sottodirectory.--lvp-share-storage-class
: oggetto StorageClass da utilizzare per creare come volumi permanenti. L'oggetto StorageClass viene creato durante la creazione del cluster.--lvp-node-mounts-config-path
: questo è il percorso della macchina host in cui è montato il rilevamento dei dischi. Viene creato un PersistentVolume (PV) locale per ogni .--lvp-node-mounts-config-storage
: la classe di archiviazione in cui vengono creati i volumi permanenti durante la creazione del cluster.
Dopo aver eseguito il comando, viene visualizzato un output simile al seguente:
Waiting for operation [projects/PROJECT_ID/locations/ON_PREM_API_REGION/operations/operation-1678304606537-5f668bde5c57e-341effde-b612ff8a] to complete...
Nell'output di esempio, la stringa operation-1678304606537-5f668bde5c57e-341effde-b612ff8a
è il OPERATION_ID
dell'operazione a lunga esecuzione.
Per scoprire lo stato dell'operazione, copia
OPERATION_ID
dal tuo output nel seguente
. Apri un'altra finestra del terminale ed esegui il comando.
gcloud container bare-metal operations describe OPERATION_ID \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION
Per creare il cluster sono necessari almeno 15 minuti. Quando il cluster puoi eseguire il comando precedente ogni tanto per visualizzare lo stato attuale.
Una volta creato il cluster, viene visualizzato un output simile al seguente:
Created Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/ON_PREM_API_REGION/bareMetalClusters/USER_CLUSTER_NAME].
Crea un pool di nodi
Dopo aver creato il cluster, esegui questo comando
per creare un pool di nodi. Sostituisci NODE_POOL_NAME
con un nome per il pool di nodi e assicurati che il segnaposto per
il flag --cluster
è ancora impostato sul nome del cluster utente.
gcloud container bare-metal node-pools create NODE_POOL_NAME \ --cluster=USER_CLUSTER_NAME \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION \ --node-configs='node-ip=10.200.0.5'
-node-configs
: il valore assegnato anode-ip
è l'indirizzo IP di la VM abm-user-cluster-w1 nella VXLAN creata dallo script.
Dopo aver eseguito il comando, viene visualizzato un output simile al seguente:
Waiting for operation [projects/PROJECT_ID/locations/ON_PREM_API_REGION/operations/operation-1678308682052-5f669b0d132cb-6ebd1c2c-816287a7] to complete...
Per creare il pool di nodi sono necessari circa 5 minuti o meno. Quando il pool di nodi , verrà visualizzato un output simile al seguente:
Created node pool in Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/ON_PREM_API_REGION/bareMetalClusters/USER_CLUSTER_NAME/bareMetalNodePools/NODE_POOL_NAME].
Altri comandi del cluster utente
Oltre a creare i cluster, esistono altri gcloud CLI che puoi eseguire, ad esempio:
- Per elencare i cluster utente:
gcloud container bare-metal clusters list \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION
- Per descrivere un cluster utente:
gcloud container bare-metal clusters describe USER_CLUSTER_NAME \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION
Per ulteriori informazioni, vedi gcloud container bare-metal clusters.
Altri comandi del pool di nodi
Oltre a creare pool di nodi, sono disponibili altre interfacce di gcloud CLI che puoi eseguire, ad esempio:
- Per elencare i pool di nodi:
gcloud container bare-metal node-pools list \ --cluster=USER_CLUSTER_NAME \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION
- Per descrivere un pool di nodi:
gcloud container bare-metal node-pools describe NODE_POOL_NAME \ --cluster=USER_CLUSTER_NAME \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION
Per ulteriori informazioni, vedi gcloud container bare-metal node-pools.
Terraform
Puoi utilizzare il seguente esempio di configurazione di base per creare un cluster utente
con il bilanciatore del carico MetalLB in bundle. Per ulteriori informazioni, consulta
documentazione di riferimento di google_gkeonprem_bare_metal_cluster
.
Nella directory in cui hai clonato
anthos-samples
, passa alla directory dove si trova l'esempio Terraform:cd anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb
L'esempio fornisce un file di variabili di esempio da passare a
main.tf
.Crea una copia del file
terraform.tfvars.sample
:cp terraform.tfvars.sample terraform.tfvars
Modifica i valori dei parametri in
terraform.tfvars
e salva il file.Le variabili sono descritte nel seguente elenco:
project_id
: l'ID del progetto in cui verrà inserito il cluster utente registrato. Questo progetto è indicato come progetto host del parco risorse.region
: la regione Google Cloud che hai impostato all'inizio del tutorial. Eseguiecho $ON_PREM_API_REGION
per ottenere il valore.admin_cluster_name
: il nome del cluster di amministrazione che hai impostato l'inizio di questo tutorial. Esegui echo$ADMIN_CLUSTER_NAME
per ottenere il valore.bare_metal_version
: la versione di Google Distributed Cloud per il tuo utente in un cluster Kubernetes. Per utilizzare la stessa versione che utilizzavi per il cluster di amministrazione, eseguiecho $BMCTL_VERSION
per ottenere il valore. Se preferisci, specifica una versione che non sia più di una versione secondaria inferiore rispetto della versione del cluster di amministrazione. La versione del cluster utente non può essere superiore a della versione del cluster di amministrazione.cluster_name
: puoi utilizzare il nome nel file TVARS per il parametro cluster utente o specifica un nome a tua scelta. Il nome non può essere dopo la creazione del cluster.admin_user_emails
: un elenco di indirizzi email degli utenti a cui assegnare a cui sono stati concessi privilegi amministrativi. Assicurati di aggiungere per amministrare il cluster.Alla creazione del cluster, l'API GKE On-Prem applica lo standard Kubernetes i criteri di controllo dell'accesso basato sui ruoli (RBAC) al cluster per concedere agli utenti amministratore il ruolo Kubernetes
clusterrole/cluster-admin
, fornisce l'accesso completo a tutte le risorse del cluster in tutti gli spazi dei nomi. Ciò consente inoltre agli utenti di accedere alla console utilizzando il proprio Identità Google.
Utilizza i valori predefiniti definiti in
terraform.tvars
per i valori rimanenti come la codifica one-hot delle variabili categoriche. Lo script ha utilizzato questi valori durante la creazione delle VM e dell'amministratore in un cluster Kubernetes.control_plane_ips
: un elenco di uno o più indirizzi IPv4 per il parametro dai nodi del piano di controllo. Utilizza il valore predefinito, ovvero l'indirizzo IP lo script assegnato alla VMabm-user-cluster-cp1
.worker_node_ips
: un elenco di uno o più indirizzi IPv4 per il worker di macchine nodo. Utilizza i valori predefiniti, ovvero gli indirizzi IP che lo script ha assegnato alle VMabm-user-cluster-w1
eabm-user-cluster-w2
.control_plane_vip
: l'IP virtuale (VIP) per il piano di controllo. Utilizza le funzionalità di il valore predefinito,10.200.0.50
, che si trova nel campo10.200.0.0/24
creata dallo script. Tieni presente che questo indirizzo IP non si sovrappongono all'intervallo di indirizzi IP utilizzato per il bilanciatore del carico MetalLB pool di indirizzi.ingress_vip
: l'indirizzo IP virtuale da configurare sul bilanciatore del carico per il proxy in entrata. Utilizza il valore predefinito,10.200.0.51
, in la rete10.200.0.0/24
creata dallo script. Tieni presente che questo IP L'indirizzo IP è compreso nell'intervallo di indirizzi IP utilizzato per il bilanciatore del carico MetalLB pool di indirizzi.lb_address_pools
: un elenco di mappe che definiscono i pool di indirizzi per Bilanciatore del carico MetalLB. Utilizza il valore predefinito.
Salva le modifiche in
terraform.tfvars
.Inizializza e crea il piano Terraform:
terraform init
Terraform installa le librerie necessarie, ad esempio il provider Google Cloud.
Rivedi la configurazione e apporta le modifiche necessarie:
terraform plan
Applica il piano Terraform per creare il cluster utente:
terraform apply
Per creare il cluster utente sono necessari almeno 15 minuti. Puoi visualizzare nel cluster nella console Google Cloud Cluster GKE .
Connettiti al cluster utente
Quando crei un cluster utente utilizzando la console o
gcloud CLI, il cluster è configurato con lo stesso
i criteri di controllo dell'accesso basato sui ruoli (RBAC) che hai configurato per l'amministratore
cluster quando hai eseguito gcloud container fleet memberships generate-gateway-rbac
.
Questi criteri RBAC ti consentono di connetterti al cluster utilizzando i tuoi Google Cloud
Identity, ovvero l'indirizzo email associato al tuo Google Cloud
. Questi criteri RBAC ti consentono di accedere alla console
senza alcuna configurazione aggiuntiva.
Connettiti al cluster nella console
Se hai utilizzato gcloud CLI o Terraform per creare il cluster utente, vai alla pagina Cluster GKE nella console:
Assicurati che il progetto in cui hai creato il cluster utente sia selezionato. Nell'elenco dovresti vedere sia il cluster di amministrazione sia il cluster utente.
Nota che il cluster utente ha Bare metal: User nella Colonna Tipo. Questo indica che il cluster è gestito l'API GKE On-Prem.
Se hai utilizzato lo script per creare il cluster di amministrazione, avrà Esterno nel Colonna Tipo. Questo indica che il cluster non è gestito l'API GKE On-Prem. Puoi configurare il cluster di amministrazione in modo che sia gestito dall'API GKE On-Prem dopo la creazione del cluster.
Per accedere a un cluster:
Fai clic sul link sul nome del cluster e nel riquadro laterale fai clic su Accedi.
Seleziona Usa la tua identità Google per accedere.
Fai clic su Login (Accedi).
Ripeti gli stessi passaggi anche per accedere al cluster di amministrazione.
Connettiti al cluster dalla riga di comando
L'API GKE On-Prem configura i criteri RBAC per te in qualità di utente
creatore del cluster. Questi criteri ti consentono di eseguire comandi kubectl
sui tuoi server
utilizzando il gateway di connessione kubeconfig
.
Dal computer locale:
Ottieni la voce
kubeconfig
che può accedere al cluster tramite connetti il gateway.gcloud container fleet memberships get-credentials USER_CLUSTER_NAME
L'output è simile al seguente:
Starting to build Gateway kubeconfig... Current project_id: PROJECT_ID A new kubeconfig entry "connectgateway_PROJECT_ID_global_USER_CLUSTER_NAME" has been generated and set as the current context.
Ora puoi eseguire i comandi
kubectl
tramite il gateway di connessione:kubectl get nodes
L'output è simile al seguente:
NAME STATUS ROLES AGE VERSION abm-user-cluster-cp Ready control-plane,master 14m v1.24.2-gke.1900 abm-user-cluster-w1 Ready worker 8m28s v1.24.2-gke.1900
Aggiungi un altro pool di nodi al cluster utente
Console
Nella console, vai ai cluster GKE. .
Nell'elenco dei cluster, fai clic sul nome del cluster e quindi su Altri dettagli nel riquadro Dettagli.
Fai clic sulla scheda Nodi.
Fai clic su
Aggiungi pool di nodi.Inserisci un nome per il pool di nodi.
Nel campo Indirizzo dei nodi 1, inserisci il seguente indirizzo IP:
10.200.0.6
Questo è l'indirizzo IP della VM abm-user-cluster-w2 che lo script è stato creato.
Fai clic su Crea
Se necessario, fai di nuovo clic sulla scheda Nodi.
Il nuovo pool di nodi mostra lo stato Riconciliazione.
Fai clic su
nella nell'angolo in alto a destra per visualizzare lo stato della creazione del pool di nodi. Potresti aggiornare la pagina per vedere lo stato aggiornato nell'elenco dei pool di nodi.
Interfaccia a riga di comando gcloud
Esegui questo comando per creare un altro pool di nodi. Sostituisci
NODE_POOL_NAME_2
con un nome per il pool di nodi e
assicurati che il segnaposto per il flag --cluster
sia ancora impostato per l'utente
il nome del cluster.
gcloud container bare-metal node-pools create NODE_POOL_NAME_2 \ --cluster=USER_CLUSTER_NAME \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION \ --node-configs='node-ip=10.200.0.6'
-node-configs
: il valore assegnato anode-ip
è l'indirizzo IP del VM abm-user-cluster-w2 nella VXLAN creata dallo script.
Terraform
Se hai creato il cluster utilizzando Terraform, è stato creato con
due nodi, quindi non sono disponibili altre VM nella VXLAN
aggiungere un altro nodo. Per informazioni sull'aggiunta di pool di nodi, consulta
vedi il
documentazione di riferimento di google_gkeonprem_bare_metal_cluster
.
Puoi anche verificare il nuovo nodo utilizzando kubectl
. Devi prima eseguire
Comando gcloud container fleet memberships get-credentials
come mostrato
per recuperare la configurazione del cluster:
kubectl get nodes
L'output è simile al seguente:
NAME STATUS ROLES AGE VERSION
abm-user-cluster-cp Ready control-plane,master 24m v1.24.2-gke.1900
abm-user-cluster-w1 Ready worker 18m v1.24.2-gke.1900
abm-user-cluster-w2 Ready worker 52s v1.24.2-gke.1900
Esegui la pulizia
Le seguenti sezioni includono istruzioni per la rimozione di cluster e VM che hai creato con questa guida.
Elimina il cluster utente
Console
Nella console, vai ai cluster GKE. .
Nell'elenco dei cluster, fai clic sul cluster utente.
Nel riquadro Dettagli, fai clic su Altri dettagli.
Nella parte superiore della finestra, fai clic su
Elimina.Quando ti viene richiesta una conferma, inserisci il nome del cluster e fai clic su Conferma.
Fai clic su
nella nell'angolo in alto a destra per visualizzare lo stato dell'eliminazione. Potresti dover aggiorna la pagina per aggiornare l'elenco di cluster.
Interfaccia a riga di comando gcloud
Esegui questo comando per eliminare il cluster:
gcloud container bare-metal clusters delete USER_CLUSTER_NAME \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION \ --force
Il flag --force
consente di eliminare un cluster che ha pool di nodi.
Senza il flag --force
, devi
elimina i pool di nodi
per poi eliminare il cluster.
Per informazioni su altri flag, vedi gcloud container bare-metal clusters delete.
Terraform
Esegui questo comando:
terraform destroy
Attendi che il cluster utente venga eliminato prima di eliminare il cluster di amministrazione e VM.
Elimina il cluster di amministrazione e le VM
Annulla la registrazione del cluster di amministrazione dall'API GKE On-Prem:
gcloud container bare-metal admin-clusters unenroll ADMIN_CLUSTER_NAME \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION
Connettiti alla workstation di amministrazione:
gcloud compute ssh root@abm-ws --zone ZONE
Elimina il cluster di amministrazione:
bmctl reset -c ADMIN_CLUSTER_NAME
bmctl
annulla la registrazione del cluster dal parco risorse ed elimina il cluster in un cluster Kubernetes. Attendi che il cluster venga eliminato prima di eliminare le VM.Esci dalla workstation di amministrazione.
Elenca tutte le VM il cui nome contiene
abm
:gcloud compute instances list | grep 'abm'
Verifica di poter eliminare tutte le VM che contengono
abm
nel .Dopo la verifica, puoi eliminare
abm
VM eseguendo questo comando :gcloud compute instances list --format="value(name)" | \ grep 'abm' | \ xargs gcloud --quiet compute instances delete --zone ZONE
Elimina l'account di servizio:
gcloud iam service-accounts delete baremetal-gcr@PROJECT_ID.iam.gserviceaccount.com
Al prompt di conferma, inserisci y.
Passaggi successivi