Scopri di più su Google Distributed Cloud creando cluster demo su Compute Engine Virtual macchine (VM). La creazione di un cluster di amministrazione e di un cluster utente con questa guida potrebbe da 40 minuti a 1 ora. I cluster demo creati in questa guida aiutano si valuta il processo per il provisioning e la gestione di Google Distributed Cloud ma non sono destinati all'uso in produzione.
Il documento ti guida nella procedura di esecuzione di uno script che:
- Esegue il provisioning di cinque VM di Compute Engine per l'installazione dei cluster demo
- Configura una rete VPC per fornire la connettività del cluster
Dopo che lo script esegue il provisioning delle risorse necessarie, utilizza una delle seguenti opzioni
per creare un cluster di amministrazione e un cluster utente di accompagnamento che può
carichi di lavoro host: bmctl
, console Google Cloud, Google Cloud CLI o Terraform.
Panoramica della procedura
Questa guida contiene i seguenti passaggi principali:
Prepara l'ambiente locale in modo che lo script abbia i requisiti necessari variabili di ambiente e aver raccolto le informazioni di base necessarie .
Crea le VM e la rete con lo script scaricato.
Crea il cluster di amministrazione con uno dei client supportati.
Crea il cluster utente con uno dei client supportati.
Esegui la pulizia per rimuovere i cluster e le VM che hai creato con questa guida.
1. Prepara l'ambiente locale
Poiché questa guida utilizza uno script che configura la rete per te, raccogliere molte informazioni o pianificare attività. Per impostare i seguenti passaggi il tuo ambiente locale e raccogli le informazioni di base necessarie nelle sezioni della guida:
- 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é è necessario 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:
You cannot perform this action because the Google Cloud CLI component manager is disabled for this installation. You can run the following command to achieve the same result for this installation:
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:
- 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
ADMIN_CLUSTER_NAME
: il nome che scegli per del cluster di amministrazione.ON_PREM_API_REGION
: la regione Google Cloud in cui l'API GKE On-Prem esegue e archivia i propri metadati. Specificaus-central1
o altro regione supportata.ZONE
: la zona Google Cloud in cui Vengono create le VM di Compute Engine. Puoi utilizzare la modalitàus-central1-a
o un altro Compute Engine zone.
- Esegui questi comandi per impostare il progetto e la zona predefiniti.
gcloud config set project $PROJECT_ID gcloud config set compute/zone $ZONE
Se ricevi un errore
PERMISSION_DENIED
, controlla l'ID progetto che hai inserito. Se l'ID progetto è corretto, eseguigcloud auth login
per accedere gcloud CLI con l'account che ha accesso al progetto. - Ottieni un elenco delle versioni supportate che puoi installare:
gcloud container bare-metal admin-clusters query-version-config \ --location=ON_PREM_API_REGION
- Seleziona una versione dall'output del comando precedente e impostala in un
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.
2. crea le VM e la rete
In questa sezione devi scaricare ed eseguire lo script install_admin_cluster.sh
.
Clona il repository
anthos-samples
e passa alla directory in cui si trova lo script si trova:git clone https://github.com/GoogleCloudPlatform/anthos-samples cd anthos-samples/anthos-bm-gcp-bash
Esegui lo script:
bash install_admin_cluster.sh
Al prompt, inserisci
2
per configurare solo l'infrastruttura Compute Engine e conferma la selezione quando ti viene richiesto.Lo script crea le VM di Compute Engine, crea una rete VXLAN e configura alla workstation di amministrazione e ai nodi del cluster. Questa infrastruttura richiede circa 5 minuti per la configurazione.
Per saperne di più sullo script, fai clic sul seguente link:
Informazioni sullo script
Puoi visualizzare lo script nel
anthos-bm-gcp-bash
nella cartella anthos-samples GitHub di ASL. Lo script automatizza i seguenti passaggi manuali:-
Crea un account di servizio denominato
baremetal-gcr
e concede all'account di servizio autorizzazioni aggiuntive per evitare di dover più account di servizio 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.
- 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.
- Verifica che SSH sia abilitato su tutte le VM e che la workstation di amministrazione dispone dell'accesso SSH a tutte le altre VM create per il cluster nodi.
-
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
nella subnet
10.200.0.0/24
. Il livello 2 la connettività è un requisito 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. -
Assicurati che
root@10.200.0.x
dalla workstation di amministrazione funziona svolgendo le seguenti attività:- Genera una nuova chiave SSH sulla workstation di amministrazione.
- Aggiunge la chiave pubblica a tutte le altre VM nel deployment.
Lo script restituisce ogni comando che esegue e lo stato. Al termine, lo script restituisce quanto segue:
✅ Successfully set up SSH access from admin workstation to cluster node VMs. ✅ GCE Infrastructure setup 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-cp | 10.200.0.3 | 🌟 Ready for use as control plane for the admin cluster | | abm-user-cluster-cp | 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 | |---------------------------------------------------------------------------------------------------------|
-
Crea un account di servizio denominato
3. Crea il cluster di amministrazione
bmctl
Per creare un cluster di amministrazione con bmctl
, accedi alla VM della workstation di amministrazione in
finestra del terminale ed esegui i comandi da lì:
Utilizza SSH per accedere alla VM della workstation di amministrazione,
abm-ws
, come root:gcloud compute ssh root@abm-ws --zone ZONE
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.
Genera un file di configurazione del cluster:
bmctl create config -c ADMIN_CLUSTER_NAME --project-id=PROJECT_ID
Verifica il file di configurazione del cluster di amministrazione:
Il seguente file di configurazione del cluster viene compilato con i valori che fornito in precedenza. Oltre ai valori inseriti, tieni presente le seguenti differenze rispetto al file di configurazione generato:
- I commenti sono stati rimossi da questo campione per migliorarne la leggibilità.
- Lo script crea un singolo account di servizio con tutte le autorizzazioni richieste
e scarica la chiave
bm-gcr.json
a cui viene fatto riferimento nel file di configurazione.
gcrKeyPath: /root/bm-gcr.json sshPrivateKeyPath: /root/.ssh/id_rsa gkeConnectAgentServiceAccountKeyPath: /root/bm-gcr.json gkeConnectRegisterServiceAccountKeyPath: /root/bm-gcr.json cloudOperationsServiceAccountKeyPath: /root/bm-gcr.json --- apiVersion: v1 kind: Namespace metadata: name: cluster-ADMIN_CLUSTER_NAME --- apiVersion: baremetal.cluster.gke.io/v1 kind: Cluster metadata: name: ADMIN_CLUSTER_NAME namespace: cluster-ADMIN_CLUSTER_NAME spec: type: admin profile: default anthosBareMetalVersion: BMCTL_VERSION gkeConnect: projectID: PROJECT_ID controlPlane: nodePoolSpec: nodes: - address: 10.200.0.3 clusterNetwork: pods: cidrBlocks: - 192.168.0.0/16 services: cidrBlocks: - 10.96.0.0/20 loadBalancer: mode: bundled ports: controlPlaneLBPort: 443 vips: controlPlaneVIP: 10.200.0.48 clusterOperations: projectID: PROJECT_ID location: us-central1 storage: lvpNodeMounts: path: /mnt/localpv-disk storageClassName: local-disks lvpShare: path: /mnt/localpv-share storageClassName: local-shared numPVUnderSharedPath: 5 nodeConfig: podDensity: maxPodsPerNode: 110
Sostituisci i contenuti del file di configurazione generato nella pagina di amministrazione con i contenuti dell'esempio precedente.
Apri il file generato,
bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME.yaml
e sostituisco i suoi contenuti con quelli dell'esempio verificato nel passaggio precedente.Crea il cluster di amministrazione:
bmctl create cluster -c ADMIN_CLUSTER_NAME
Il comando
bmctl
mostra l'output sullo schermo durante l'esecuzione preflight controlla e crea il cluster. Le informazioni dettagliate vengono scritte nei log inbaremetal/bmctl-workspace/abm-user-cluster-metallb/log
sulla workstation di amministrazione.La creazione del cluster può richiedere diversi minuti.
Nella console, vai alla pagina Cluster GKE.
Assicurati che il progetto in cui hai creato il cluster utente sia selezionato. Dovresti vedere il cluster di amministrazione nell'elenco.
Accedi al cluster di amministrazione:
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).
Verifica il cluster di amministrazione
Puoi trovare il file kubeconfig del cluster di amministrazione sulla workstation di amministrazione in
Directory bmctl-workspace
dell'account root. Per verificare il deployment,
completa i seguenti passaggi:
Utilizza SSH per accedere alla workstation di amministrazione come root:
gcloud compute ssh root@abm-ws --zone ZONE
Verifica che il cluster di amministrazione sia stato creato e sia in esecuzione:
kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes
L'output è simile al seguente:
NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m v1.27.4-gke.1600
Al termine dell'esplorazione, inserisci
exit
per disconnetterti dall'amministratore la workstation.
Console
Per creare un cluster di amministrazione nella console, devi eseguire bmctl
register bootstrap
dalla VM della workstation di amministrazione per creare un cluster di bootstrap.
Mentre il comando bmctl register bootstrap
è in esecuzione, esegui i passaggi
nella console per creare il cluster di amministrazione.
Inserisci le impostazioni di base dell'ambiente di bootstrap
Nella console Google Cloud, vai ai cluster GKE. .
Fai clic su Crea.
Nella finestra di dialogo Crea un cluster seleziona On-premise e fai clic su Configura per 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.Seleziona
BMCTL_VERSION
come per il cluster di amministrazione. Lo script ha scaricato questa versione dell'bmctl
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é si continua da lì per creare il cluster di amministrazione.
Crea il cluster di bootstrap
Quando utilizzi un client API GKE On-Prem, ad esempio la console, per creare un devi creare un cluster di bootstrap sulla workstation di amministrazione. Il cluster di bootstrap ospita i controller Kubernetes necessari per creare del cluster di amministrazione.
Dalla riga di comando, utilizza SSH per accedere alla VM della 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.
Passa alla directory
baremetal/
ed esegui questo comando per creare il cluster di bootstrap.Il nome del cluster di bootstrap viene derivato anteponendo
bootstrap-
al del cluster di amministrazione.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
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.
Networking
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
Il passaggio seguente dipende dalla disponibilità del cluster di bootstrap. Il comando
bmctl register bootstrap
nella finestra del terminale deve essere eseguito per pochi minuti prima che il cluster di bootstrap venga visualizzato come membro registrato. Se dopo alcuni minuti non è ancora disponibile, controlla il cluster di bootstrap e l'ID progetto che hai utilizzato. Se devi cambiare il bootstrap del cluster o dell'ID progetto, inserisciCtrl-C
nella finestra dell'altro terminale per uscire dabmctl register bootstrap
ed eseguire nuovamente il comando.Fai clic su Verifica e crea.
Nella console vengono visualizzati messaggi di stato durante la verifica delle impostazioni e crea il cluster.
Una volta creato il cluster di amministrazione, il cluster di bootstrap sull'interfaccia viene eliminata. L'output di
bmctl register bootstrap
nell'altra finestra del terminale è simile al seguente:... [2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK [2024-04-15 23:16:38+0000] Please run [2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes [2024-04-15 23:16:38+0000] to get cluster nodes status. [2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK [2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK [2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK [2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster [2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK [2024-04-15 23:24:30+0000] Flushing logs... OK [2024-04-15 23:24:30+0000] Unregistering bootstrap cluster. [2024-04-15 23:24:30+0000] Deleting membership... OK [2024-04-15 23:24:32+0000] Deleting bootstrap cluster.
Verifica il cluster di amministrazione
Puoi trovare il file kubeconfig del cluster di amministrazione sulla workstation di amministrazione in
Directory bmctl-workspace
dell'account root. Per verificare il deployment,
completa i seguenti passaggi:
Utilizza SSH per accedere alla workstation di amministrazione come root:
gcloud compute ssh root@abm-ws --zone ZONE
Verifica che il cluster di amministrazione sia stato creato e sia in esecuzione:
kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes
L'output è simile al seguente:
NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m v1.27.4-gke.1600
Al termine dell'esplorazione, inserisci
exit
per disconnetterti dall'amministratore la workstation.
Interfaccia a riga di comando gcloud
Le seguenti istruzioni richiedono due finestre del terminale. In una finestra del terminale,
esegui bmctl register bootstrap
per creare un cluster di bootstrap. Mentre
Il comando bmctl register bootstrap
è in esecuzione. Esegui gcloud container
bare-metal admin-clusters create
in un'altra finestra del terminale per creare l'amministratore
in un cluster Kubernetes.
Crea il cluster di bootstrap
Quando utilizzi un client API GKE On-Prem, ad esempio gcloud CLI, per creare un devi creare un cluster di bootstrap sulla workstation di amministrazione. Il cluster di bootstrap ospita i controller Kubernetes necessari per creare del cluster di amministrazione.
Dalla riga di comando, utilizza SSH per accedere alla VM della 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.
Passa alla directory
baremetal/
ed esegui questo comando per creare il cluster di bootstrap.Il nome del cluster di bootstrap viene derivato anteponendo
bootstrap-
al del cluster di amministrazione.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
In una nuova finestra del terminale, verifica che il cluster di bootstrap sia stato registrati come membri del parco risorse:
gcloud container fleet memberships list \ --project=PROJECT_ID
Il comando
gcloud container bare-metal admin-clusters create
nel il passaggio successivo dipende dalla disponibilità del cluster di bootstrap. La È necessario eseguire il comandobmctl register bootstrap
nella finestra dell'altra finestra del terminale per pochi minuti prima che il cluster di bootstrap venga visualizzato come membro registrato. Se dopo alcuni minuti, non è ancora presente nell'elenco; controlla il nome del cluster di bootstrap e l'ID progetto che hai utilizzato. Se devi modificare il cluster di bootstrap o l'ID progetto, inserisciCtrl-C
nella finestra dell'altro terminale per uscire submctl register bootstrap
ed esegui nuovamente il comando.Crea il cluster di amministrazione con il bilanciatore del carico in bundle:
Assicurati che i valori specificati corrispondano alle variabili di ambiente indicate specificato in precedenza per lo script.
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
In questo comando:
--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 VMabm-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
Al completamento di
gcloud container bare-metal admin-clusters create
correttamente, l'output è simile al seguente:Created Anthos on bare metal Admin Cluster [https://gkeonprem.googleapis.com/v1/projects/anonuser-anonproject/locations/us-central1/bareMetalAdminClusters/gce-admin-gcloud-001]. NAME LOCATION VERSION MEMBERSHIP STATE abm-cluster-1 us-central1 1.28.300-gke.131 abm-cluster-1 RUNNING
Una volta creato il cluster di amministrazione, il cluster di bootstrap sull'interfaccia viene eliminata. L'output di
bmctl register bootstrap
nell'altra finestra del terminale è simile al seguente:... [2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK [2024-04-15 23:16:38+0000] Please run [2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes [2024-04-15 23:16:38+0000] to get cluster nodes status. [2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK [2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK [2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK [2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster [2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK [2024-04-15 23:24:30+0000] Flushing logs... OK [2024-04-15 23:24:30+0000] Unregistering bootstrap cluster. [2024-04-15 23:24:30+0000] Deleting membership... OK [2024-04-15 23:24:32+0000] Deleting bootstrap cluster.
Verifica il cluster di amministrazione
Puoi trovare il file kubeconfig del cluster di amministrazione sulla workstation di amministrazione in
Directory bmctl-workspace
dell'account root. Per verificare il deployment,
completa i seguenti passaggi:
Utilizza SSH per accedere alla workstation di amministrazione come root:
gcloud compute ssh root@abm-ws --zone ZONE
Verifica che il cluster di amministrazione sia stato creato e sia in esecuzione:
kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes
L'output è simile al seguente:
NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m v1.27.4-gke.1600
Al termine dell'esplorazione, inserisci
exit
per disconnetterti dall'amministratore la workstation.
Terraform
Le seguenti istruzioni richiedono due finestre del terminale. In una finestra del terminale,
esegui bmctl register bootstrap
per creare un cluster di bootstrap. Mentre
il comando bmctl register bootstrap
è in esecuzione, esegui i comandi Terraform in
in un'altra finestra del terminale
per creare il cluster di amministrazione.
Modifica i file di esempio del cluster utente in modo che funzionino per un cluster di amministrazione
Il repository anthos-samples
non include un esempio specifico
per la creazione di un cluster di amministrazione Google Distributed Cloud. I passaggi seguenti mostrano
Come creare un cluster di amministrazione modificando un cluster utente esistente Terraform
campione.
Nella directory in cui hai clonato
anthos-samples
, esegui questo comando per copiare i file di esempio per l'esempio del cluster utente MetalLB in un nuova cartella per il cluster di amministrazione:cp -r anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb \ anthos-samples/anthos-onprem-terraform/abm_admin_cluster_basic
Passa alla directory
abm_admin_cluster_basic
:cd anthos-samples/anthos-onprem-terraform/abm_admin_cluster_basic
Modifica i file Terraform:
variables.tf
:Definisci una variabile per gli indirizzi IP dei nodi del piano di controllo (sebbene utilizzane solo uno per questa demo). Questa variabile dovrebbe essere simile a Voce
variable "control_plane_ips" { ... }
.Definisci una variabile per l'indirizzo VIP del piano di controllo. Questa variabile deve essere simile alla voce
variable "control_plane_vip" { ... }
.
terraform.tfvars
:Assegna valori delle variabili per le seguenti impostazioni del cluster di amministrazione:
Indirizzi IP dei nodi del piano di controllo:
10.200.0.3
Indirizzo VIP del piano di controllo:
10.200.0.48
main.tf
:Sostituisci la risorsa
google_gkeonprem_bare_metal_cluster
congoogle_gkeonprem_bare_metal_admin_cluster
risorsa.Elimina la risorsa
google_gkeonprem_bare_metal_node_pool
e le risorse correlate Sezionelifecycle
.Aggiorna la risorsa per utilizzare le variabili appena definite.
Ecco un esempio di come potrebbe apparire il file
main.tf
quando viene modificato in crea un cluster di amministrazione:/** * Copyright 2023 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #[START anthos_onprem_terraform_bare_metal_admin_cluster_basic_main] module "enable_google_apis_primary" { source = "terraform-google-modules/project-factory/google//modules/project_services" version = "~> 14.0" project_id = var.project_id activate_apis = [ "anthos.googleapis.com", "anthosaudit.googleapis.com", "anthosgke.googleapis.com", "cloudresourcemanager.googleapis.com", "compute.googleapis.com", "connectgateway.googleapis.com", "container.googleapis.com", "file.googleapis.com", "gkehub.googleapis.com", "iam.googleapis.com", "kubernetesmetadata.googleapis.com", "logging.googleapis.com", "monitoring.googleapis.com", "opsconfigmonitoring.googleapis.com", "serviceusage.googleapis.com", "stackdriver.googleapis.com" ] disable_services_on_destroy = false } # Enable GKE OnPrem API resource "google_project_service" "default" { project = var.project_id service = "gkeonprem.googleapis.com" disable_on_destroy = false } # Create an anthos baremetal admin cluster and enroll it with the gkeonprem API resource "google_gkeonprem_bare_metal_admin_cluster" "admin-cluster-basic" { name = var.admin_cluster_name description = "Anthos bare metal admin cluster" provider = google depends_on = [google_project_service.default] location = var.region bare_metal_version = var.bare_metal_version network_config { island_mode_cidr { service_address_cidr_blocks = ["0.96.0.0/20"] pod_address_cidr_blocks = ["192.168.0.0/16"] } } node_config { max_pods_per_node = 250 } control_plane { control_plane_node_pool_config { node_pool_config { operating_system = "LINUX" dynamic "node_configs" { for_each = var.admin_cp_ips content { node_ip = node_configs.value } } } } } load_balancer { port_config { control_plane_load_balancer_port = 443 } vip_config { control_plane_vip = var.admin_cp_vip } } storage { lvp_share_config { lvp_config { path = "/mnt/localpv-share" storage_class = "local-shared" } shared_path_pv_count = 5 } lvp_node_mounts_config { path = "/mnt/localpv-disk" storage_class = "local-disks" } } dynamic "security_config" { for_each = length(var.admin_user_emails) == 0 ? [] : [1] content { authorization { dynamic "admin_users" { for_each = var.admin_user_emails content { username = admin_users.value } } } } } lifecycle { ignore_changes = [ annotations["onprem.cluster.gke.io/user-cluster-resource-link"], annotations["alpha.baremetal.cluster.gke.io/cluster-metrics-webhook"], annotations["baremetal.cluster.gke.io/operation"], annotations["baremetal.cluster.gke.io/operation-id"], annotations["baremetal.cluster.gke.io/start-time"], annotations["baremetal.cluster.gke.io/upgrade-from-version"] ] } } #[END anthos_onprem_terraform_bare_metal_admin_cluster_basic_main]
Per saperne di più sulla risorsa Terraform per i cluster di amministrazione, consulta google_gkeonprem_bare_metal_admin_cluster nel registro Terraform.
Crea il cluster di bootstrap
Quando utilizzi un client API GKE On-Prem, ad esempio Terraform, per creare un devi creare un cluster di bootstrap sulla workstation di amministrazione. Il cluster di bootstrap ospita i controller Kubernetes necessari per creare del cluster di amministrazione.
Dalla riga di comando, utilizza SSH per accedere alla VM della 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.
Passa alla directory
baremetal/
ed esegui questo comando per creare il cluster di bootstrap.Il nome del cluster di bootstrap viene derivato anteponendo
bootstrap-
al del cluster di amministrazione.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
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 di amministrazione:
terraform apply
Per creare il cluster di amministrazione sono necessari almeno 15 minuti. Quando il cluster viene visualizzato un messaggio simile al seguente:
... google_gkeonprem_bare_metal_admin_cluster.admin-cluster-basic: Still creating... [20m10s elapsed] google_gkeonprem_bare_metal_admin_cluster.admin-cluster-basic: Creation complete after 20m11s [id=projects/anonuser-anonproject/locations/us-central1/bareMetalAdminClusters/gce-admin-terra002] Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
Una volta creato il cluster di amministrazione, il cluster di bootstrap sull'interfaccia viene eliminata. L'output di
bmctl register bootstrap
nell'altra finestra del terminale è simile al seguente:... [2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK [2024-04-15 23:16:38+0000] Please run [2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes [2024-04-15 23:16:38+0000] to get cluster nodes status. [2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK [2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK [2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK [2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster [2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK [2024-04-15 23:24:30+0000] Flushing logs... OK [2024-04-15 23:24:30+0000] Unregistering bootstrap cluster. [2024-04-15 23:24:30+0000] Deleting membership... OK [2024-04-15 23:24:32+0000] Deleting bootstrap cluster.
Nella console, vai alla pagina Cluster GKE.
Assicurati che il progetto in cui hai creato il cluster utente sia selezionato. Dovresti vedere il cluster di amministrazione nell'elenco.
Accedi al cluster di amministrazione:
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).
Verifica il cluster di amministrazione
Puoi trovare il file kubeconfig del cluster di amministrazione sulla workstation di amministrazione in
Directory bmctl-workspace
dell'account root. Per verificare il deployment,
completa i seguenti passaggi:
Utilizza SSH per accedere alla workstation di amministrazione come root:
gcloud compute ssh root@abm-ws --zone ZONE
Verifica che il cluster di amministrazione sia stato creato e sia in esecuzione:
kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes
L'output è simile al seguente:
NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m v1.27.4-gke.1600
Al termine dell'esplorazione, inserisci
exit
per disconnetterti dall'amministratore la workstation.
4. Crea il cluster utente
Puoi utilizzare la console Google Cloud, Google Cloud CLI o Terraform per creare
per il cluster utente. Per semplicità, utilizza abm-user-cluster-metallb
per l'utente
del cluster, in modo che corrisponda al nome hardcoded negli script Terraform.
bmctl
Utilizza SSH per accedere alla VM della workstation di amministrazione,
abm-ws
, come root:gcloud compute ssh root@abm-ws --zone ZONE
Genera un file di configurazione del cluster:
bmctl create config -c abm-user-cluster-metallb \ --project-id=PROJECT_ID
Nel file di configurazione del cluster utente seguente, imposta il tuo indirizzo email in la sezione
clusterSecurity
e verifica le altre impostazioni:Il seguente file di configurazione del cluster viene compilato con i valori che inserito in precedenza nella tabella di pianificazione. Oltre ai valori che hai inserito, tieni presente le seguenti differenze rispetto alla configurazione generata file:
- I commenti sono stati rimossi da questo campione per migliorarne la leggibilità.
- La sezione delle credenziali è stata rimossa normalmente per i cluster utente.
- Il tipo di cluster
spec.type
è stato impostato suuser
. - Il campo
spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts
è stato aggiunto per concedereclusterrole/cluster-admin
al tuo account. Tra altri aspetti, questo campo ti consente di accedere al cluster Console Google Cloud per visualizzare ulteriori dettagli sul cluster.
--- apiVersion: v1 kind: Namespace metadata: name: cluster-abm-user-cluster-metallb --- apiVersion: baremetal.cluster.gke.io/v1 kind: Cluster metadata: name: abm-user-cluster-metallb namespace: cluster-abm-user-cluster-metallb spec: type: user profile: default anthosBareMetalVersion: BMCTL_VERSION gkeConnect: projectID: PROJECT_ID controlPlane: nodePoolSpec: nodes: - address: 10.200.0.4 clusterNetwork: pods: cidrBlocks: - 192.168.0.0/16 services: cidrBlocks: - 10.96.0.0/20 loadBalancer: mode: bundled ports: controlPlaneLBPort: 443 vips: controlPlaneVIP: 10.200.0.50 ingressVIP: 10.200.0.51 addressPools: - name: pool1 addresses: - 10.200.0.51-10.200.0.70 clusterOperations: projectID: PROJECT_ID location: us-central1 clusterSecurity: authorization: clusterAdmin: gcpAccounts: - YOUR_EMAIL_ADDRESS storage: lvpNodeMounts: path: /mnt/localpv-disk storageClassName: local-disks lvpShare: path: /mnt/localpv-share storageClassName: local-shared numPVUnderSharedPath: 5 nodeConfig: podDensity: maxPodsPerNode: 250 --- apiVersion: baremetal.cluster.gke.io/v1 kind: NodePool metadata: name: node-pool-1 namespace: cluster-abm-user-cluster-metallb spec: clusterName: abm-user-cluster-metallb nodes: - address: 10.200.0.5
Sostituisci i contenuti del file di configurazione generato nella pagina di amministrazione con i contenuti dell'esempio precedente.
Apri il file generato,
bmctl-workspace/abm-user-cluster-metallb/abm-user-cluster-metallb.yaml
e sostituisco i suoi contenuti con quelli dell'esempio verificato nel passaggio precedente.Crea il cluster utente:
bmctl create cluster -c abm-user-cluster-metallb \ --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig
Il comando
bmctl
mostra l'output sullo schermo durante l'esecuzione preflight controlla e crea il cluster. Le informazioni dettagliate vengono scritte nei log inbaremetal/bmctl-workspace/abm-user-cluster-metallb/log
sulla workstation di amministrazione.La creazione del cluster può richiedere diversi minuti.
Nella console Google Cloud, vai ai cluster GKE. .
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.
Accedi al cluster utente:
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 per accedere al cluster di amministrazione.
Console
Segui questi passaggi per creare un cluster utente nella console:
Nella console, vai alla pagina 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
Anche lo script che hai eseguito per creare le VM e il cluster di amministrazione ha creato
VXLAN di livello 2 con indirizzi IP nella subnet 10.200.0.0/24
.
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 creato 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 utente deve avere almeno un pool di nodi per i nodi worker.
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.Accedi al cluster utente:
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 per accedere al cluster di amministrazione.
Interfaccia a riga di comando gcloud
Per creare il cluster utente:
Esegui questo comando per creare il cluster utente:
gcloud container bare-metal clusters create abm-user-cluster-metallb \ --project=PROJECT_ID \ --admin-cluster-membership=projects/PROJECT_ID/locations/ON_PREM_API_REGION/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
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
è ilOPERATION_ID
dell'operazione a lunga esecuzione.Per scoprire lo stato dell'operazione, apri un'altra finestra del terminale e per eseguire il comando.
gcloud container bare-metal operations describe OPERATION_ID \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION
Sostituisci
OPERATION_ID
con la stringa corrispondente dall'output del passaggio precedente.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/abm-user-cluster-metallb].
Per ulteriori informazioni sull'
gcloud container bare-metal clusters create
incluse le descrizioni di ogni flag, creano cluster bare-metal di container per la risorsa cluster nel riferimento di gcloud CLI.
Crea un pool di nodi
Dopo aver creato il cluster, puoi creare un pool di nodi per in un cluster Kubernetes.
Per creare un pool di nodi:
Esegui questo comando per creare un pool di nodi:
gcloud container bare-metal node-pools create NODE_POOL_NAME \ --cluster=abm-user-cluster-metallb \ --project=PROJECT_ID \ --location=ON_PREM_API_REGION \ --node-configs='node-ip=10.200.0.5'
Sostituisci
NODE_POOL_NAME
con un nome per il pool di nodi.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/abm-user-cluster-metallb/bareMetalNodePools/NODE_POOL_NAME].
Vai alla pagina Crea un cluster bare metal nella console:
Vai alla pagina Crea un cluster bare metal
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.
Accedi al cluster utente:
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 per accedere al cluster di amministrazione.
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
Verifica i valori nel seguente esempio:
Il seguente file di variabili Terraform,
terraform.tfvars.sample
, è precompilati con indirizzi IP e con i valori che hai inserito in precedenza di questa guida.Sostituisci
ADMIN_2_EMAIL_ADDRESS
con un indirizzo email associato al tuo account Google Cloud o rimuoverlo quando modifichi il file delle variabili.Per ulteriori informazioni sugli argomenti di questo esempio per il quale stai l'impostazione delle variabili, consulta Riferimento all'argomento nella documentazione di Terraform per i cluster utente Google Distributed Cloud.
Sostituisci i contenuti della tua copia del file delle variabili con i contenuti dall'esempio precedente.
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 .
Nella console Google Cloud, vai ai cluster GKE. .
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.
Accedi al cluster utente:
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 per accedere al cluster di amministrazione.
5. Esegui la pulizia
Segui queste istruzioni per rimuovere i cluster e le VM che hai creato questa guida.
Elimina il cluster utente
bmctl
Per eliminare il cluster utente con
bmctl
, esegui questo comando dal VM della workstation di amministrazione,abm-ws
:bmctl reset \ --cluster abm-user-cluster-metallb \ --admin-kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig
Console
Nella console, vai ai cluster GKE. .
Nell'elenco dei cluster, fai clic sul cluster utente.
Nel riquadro Dettagli, fai clic su Visualizza 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 Elimina.
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
Per eliminare il cluster, esegui questo comando:
gcloud container bare-metal clusters delete abm-user-cluster-metallb \ --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
Il comando terraform destroy
termina le risorse create al momento dell'esecuzione
ha eseguito terraform apply
per creare il cluster utente.
Esegui il comando seguente dalla directory in cui l'utente Terraform dei cluster di esempio, come
main.tf
: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:
exit
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 compute instances delete --quiet --zone ZONE
Esegui questo comando per eliminare l'account di servizio e, quando richiesto, inserisci
y
:gcloud iam service-accounts delete baremetal-gcr@PROJECT_ID.iam.gserviceaccount.com
Passaggi successivi
Per iniziare a creare cluster sul tuo hardware, consulta Pianificare una pianificazione di base sull'installazione hardware e Crea sul tuo hardware.
Per i requisiti di installazione dettagliati, consulta Prerequisiti di installazione. Panoramica.
Per saperne di più sull'installazione, vedi Panoramica della creazione del cluster.
Per istruzioni sul deployment nel tuo cluster, consulta Eseguire il deployment di un'applicazione.