Crea cluster di amministrazione e cluster utente Anthos on bare metal sulle VM di Compute Engine

Version 1.13 

• Ultimi
• Versione 1.16
• Versioni precedenti (non supportate)

Questa pagina mostra come creare un cluster utente Anthos on bare metal e un cluster di amministrazione sulle macchine virtuali (VM) di Compute Engine. Lo script fornito crea VM di Compute Engine per i nodi amministrativi e del cluster utente e una workstation di amministrazione.

La workstation di amministrazione ospita strumenti di interfaccia a riga di comando (CLI) e file di configurazione per eseguire il provisioning dei cluster durante l'installazione, oltre a strumenti di interfaccia a riga di comando per interagire con i cluster di cui è stato eseguito il provisioning dopo l'installazione. Lo script installa 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. È costituito dai nodi del piano di controllo e dai nodi worker. I cluster utente devono contenere uno o più nodi worker che eseguono carichi di lavoro utente. Un cluster di amministrazione è un cluster Kubernetes che gestisce uno o più cluster utente, contribuendo alla creazione, agli aggiornamenti e all'eliminazione dei cluster utente. Un cluster di amministrazione è costituito solo da nodi del piano di controllo. Per scoprire di più, consulta Deployment e cluster utente.

Lo script configura una rete overlay Virtual Extensible LAN (VXLAN) tra le VM e prepara le VM per la creazione del cluster. Facoltativamente, lo script crea un cluster di amministrazione o puoi scegliere di creare il cluster di amministrazione autonomamente per scoprire gli strumenti offerti da Anthos clusters on bare metal per la creazione dei cluster di amministrazione.

Con lo script fornito, puoi provare Anthos clusters on bare metal in modo rapido e senza dover preparare hardware. Il completamento dei passaggi in questa pagina fornisce un ambiente di test di Anthos clusters on bare metal funzionante in Compute Engine.

Importante: questo deployment è solo a scopo di valutazione. Non eseguire Anthos clusters on bare metal sulle VM di Compute Engine in produzione.

Che cos'è l'API Anthos On-Prem?

L'API Anthos On-Prem è un'API ospitata da Google Cloud che ti consente di gestire il ciclo di vita dei cluster on-premise utilizzando Terraform e le applicazioni Google Cloud standard. L'API Anthos On-Prem viene eseguita nell'infrastruttura di Google Cloud. Terraform, la console e gcloud CLI sono client dell'API e utilizzano l'API per creare cluster nel tuo data center.

Per gestire il ciclo di vita dei cluster, l'API Anthos On-Prem deve archiviare metadati sullo stato del cluster in Google Cloud, utilizzando la regione Google Cloud specificata durante la creazione del cluster. Questi metadati consentono all'API di gestire il ciclo di vita del cluster e non includono dati specifici del carico di lavoro.

Quando crei un cluster utilizzando un client API Anthos On-Prem, specifichi un progetto Google Cloud. Una volta creato, il cluster viene registrato automaticamente nel parco risorse del progetto specificato. 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

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Make sure that billing is enabled for your Google Cloud project.

6. Prendi nota dell'ID progetto, perché ti serve per impostare una variabile di ambiente utilizzata nello script e nei comandi in questa pagina. Se hai selezionato un progetto esistente, assicurati di essere un proprietario o un editor del progetto.
7. Puoi eseguire lo script su Cloud Shell o sulla tua macchina locale che esegue Linux o macOS. Se non utilizzi Cloud Shell:
   1. Assicurati di aver installato l'ultima versione di Google Cloud CLI, lo strumento a riga di comando per interagire con Google Cloud, inclusi i componenti beta gcloud CLI.
   2. Se non hai ancora i componenti beta, esegui il comando seguente per installarli:

      gcloud components install beta

   3. Aggiorna i componenti dell'interfaccia a riga di comando gcloud, se necessario:

      gcloud components update

      A seconda di come è stata installata l'interfaccia a riga di comando gcloud, potresti visualizzare il messaggio: "Non puoi eseguire questa azione perché il gestore di componenti Google Cloud CLI è disabilitato per questa installazione. Per ottenere lo stesso risultato per questa installazione, puoi eseguire il seguente comando: Segui le istruzioni per copiare e incollare il comando per aggiornare i componenti.

   4. Assicurati di avere installato kubectl. Se devi installare kubectl, esegui il comando seguente:

      gcloud components install kubectl

Crea l'infrastruttura VM e, facoltativamente, il cluster di amministrazione

Per configurare ed eseguire lo script, procedi nel seguente modo. Lo script che scarichi ed esegui proviene dal repository anthos-samples. Per saperne di più sullo script prima di eseguirlo, consulta la sezione successiva Informazioni sullo script.

1. 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 di Google Cloud in cui viene eseguita l'API Anthos On-Prem e archivia i relativi metadati. Specifica us-central1 o un'altra regione supportata.

   • ZONE: la zona Google Cloud in cui verranno create le VM di Compute Engine. Puoi utilizzare us-central1-a o qualsiasi altra zona di Compute Engine.

2. Esegui questi comandi per impostare 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, esegui gcloud auth login per accedere all'interfaccia alla gcloud CLI'account che ha accesso al progetto.

3. Ecco un elenco delle versioni che puoi installare:

   gcloud beta container bare-metal admin-clusters query-version-config \
         --location=ON_PREM_API_REGION
   

4. Seleziona una versione dall'output del comando precedente e impostala in una variabile di ambiente:

   export BMCTL_VERSION=BMCTL_VERSION
   

5. Clona il repository anthos-samples e passa alla directory in cui si trova lo script:

   git clone https://github.com/GoogleCloudPlatform/anthos-samples
   cd anthos-samples/anthos-bm-gcp-bash
   

6. Esegui lo script:

   bash install_admin_cluster.sh
   

7. Quando richiesto, inserisci un numero per scegliere la modalità di installazione:

   • Inserisci 1 per configurare lo script dell'infrastruttura VM e installare il cluster di amministrazione.
   • Inserisci 2 per fare in modo che lo script configuri solo l'infrastruttura VM.

8. Quando richiesto, conferma la selezione.

Lo script restituisce ogni comando eseguito e lo stato. Al termine, lo script restituisce quanto segue, a seconda che tu abbia scelto o meno il 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 su Informazioni sullo script nella riga successiva.

Informazioni sullo script

Lo script automatizza i seguenti passaggi manuali:

1. Crea un account di servizio denominato baremetal-gcr e concede all'account di servizio autorizzazioni aggiuntive per evitare di aver bisogno di più account di servizio per API e servizi diversi.
2. 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

3. Crea le seguenti VM:
   • Una VM per la workstation di amministrazione. La workstation di amministrazione avrà 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.
   Lo script inoltre verifica che SSH sia abilitato su tutte le VM.
4. Crea una rete in overlay LAN estensibile virtuale (VXLAN) per la connettività di livello 2 tra le VM. La VXLAN non è permanente, quindi se riavvii un'istanza VM la rete viene eliminata. La rete è configurata in modo da trovarsi nella subnet 10.200.0.0/24. La connettività di livello 2 è un requisito per il bilanciatore del carico in bundle.
5. Installa i seguenti strumenti sulla workstation di amministrazione:
   • bmctl
   • kubectl
   • Docker

   Lo script scarica anche la chiave dell'account di servizio per l'account di servizio baremetal-gcr nella workstation di amministrazione.

6. Garantisce che root@10.200.0.x dalla workstation di amministrazione funzioni eseguendo le seguenti attività:
   1. Genera una nuova chiave SSH sulla workstation di amministrazione.
   2. Aggiunge la chiave pubblica a tutte le altre VM nel deployment.
7. Facoltativamente, lo script crea il cluster di amministrazione con il seguente file di configurazione:
   anthos-bm-gcp-bash/install_admin_cluster.sh

   Visualizza su GitHub

     gcloud compute ssh root@"$VM_WS" --zone "${ZONE}" <<EOF
   set -x
   export PROJECT_ID=\$(gcloud config get-value project)
   ADMIN_CLUSTER_NAME=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/cluster_id -H "Metadata-Flavor: Google")
   BMCTL_VERSION=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/bmctl_version -H "Metadata-Flavor: Google")
   export ADMIN_CLUSTER_NAME
   export BMCTL_VERSION
   bmctl create config -c \$ADMIN_CLUSTER_NAME
   cat > bmctl-workspace/\$ADMIN_CLUSTER_NAME/\$ADMIN_CLUSTER_NAME.yaml << EOB
   ---
   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
     anthosBareMetalVersion: \$BMCTL_VERSION
     gkeConnect:
       projectID: \$PROJECT_ID
     controlPlane:
       nodePoolSpec:
         clusterName: \$ADMIN_CLUSTER_NAME
         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:
       # might need to be this location
       location: us-central1
       projectID: \$PROJECT_ID
     storage:
       lvpNodeMounts:
         path: /mnt/localpv-disk
         storageClassName: node-disk
       lvpShare:
         numPVUnderSharedPath: 5
         path: /mnt/localpv-share
         storageClassName: local-shared
     nodeConfig:
       podDensity:
         maxPodsPerNode: 250
   EOB
   
   bmctl create cluster -c \$ADMIN_CLUSTER_NAME
   EOF

   Se hai scelto di creare il cluster di amministrazione per lo script, lo script utilizza SSH per accedere alla workstation di amministrazione come utente root. A questo punto, lo script esegue lo strumento a riga di comando bmctl per creare il cluster di amministrazione. Si tratta di uno degli strumenti che puoi utilizzare per creare cluster di amministrazione.

   Quando Anthos clusters on bare metal crea cluster, esegue il deployment di un cluster Kubernetes in Docker (tipo) sulla workstation di amministrazione. Questo cluster bootstrap ospita i controller Kubernetes necessari per creare i cluster e viene utilizzato per creare il cluster di amministrazione. Al momento della creazione, i controller pertinenti vengono spostati dal cluster di bootstrap al cluster di amministrazione. Infine, a meno che non venga specificato diversamente, il cluster di bootstrap viene rimosso al completamento della creazione del cluster. Il cluster bootstrap richiede Docker per eseguire il pull delle immagini dei container.

Facoltativamente, crea il cluster di amministrazione

Anteprima

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Se lo script ha creato il cluster di amministrazione, vai alla sezione successiva Verificare il cluster di amministrazione. In caso contrario, 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 il comando bmctl register bootstrap sulla workstation di amministrazione. Questo comando esegue il deployment di un cluster Kubernetes in Docker (tipo) temporaneo sulla workstation di amministrazione. Questo cluster bootstrap ospita i controller Kubernetes necessari per creare il cluster di amministrazione. Quando crei il cluster di amministrazione, i controller sul cluster di bootstrap eseguono il provisioning dei nodi, eseguono i controlli preflight e registrano il cluster di amministrazione al parco risorse. Il cluster di bootstrap viene eliminato automaticamente dopo la creazione del cluster.

Console

1. Nella console Google Cloud, vai alla pagina Cluster Anthos.

   Vai a Cluster Anthos di Anthos

2. Assicurati di selezionare PROJECT_ID dall'elenco dei progetti.

3. Fai clic su Crea cluster.

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

5. Accanto a Bare metal, fai clic su Configure (Configura). La pagina Prerequisiti mostra i requisiti per la workstation di amministrazione e le macchine dei nodi del cluster.

   Assicurati che sia selezionato Crea un cluster di amministrazione.

6. Nella barra di navigazione a sinistra, fai clic su Installa ambiente bootstrap.

7. Inserisci ADMIN_CLUSTER_NAME come nome del cluster di amministrazione. Tieni presente che il nome del cluster bootstrap deriva da prima di bootstrap- al nome del cluster di amministrazione.

8. Seleziona VERSION come versione per il cluster di amministrazione. Lo script ha scaricato questa versione dello strumento a riga di comando bmctl nella workstation di amministrazione. La versione di Anthos clusters on bare metal che installi deve corrispondere alla versione bmctl.

9. Nel campo Posizione API di Google Cloud, seleziona ON_PREM_API_REGION dall'elenco. Questa impostazione specifica la regione in cui viene eseguita l'API Anthos On-Prem e la regione in cui vengono archiviati:

   • I metadati del cluster necessari all'API Anthos 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 della Console di amministrazione creato da Cloud Audit Logs

   Il nome, il progetto e la località del cluster identificano in modo univoco il cluster in Google Cloud.

Per creare il cluster di bootstrap, utilizza i passaggi della sezione successiva anziché i passaggi visualizzati nella console. Lascia la pagina della console visualizzata perché tornerai lì 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 e creare il cluster di bootstrap. Utilizzerai la prima finestra del terminale per eseguire il comando gcloud CLI per creare il cluster di amministrazione.

Crea il cluster bootstrap

Completa i seguenti passaggi sulla tua workstation di amministrazione.

1. SSH nella workstation di amministrazione come root:

   gcloud compute ssh root@abm-ws --zone ZONE
   

   Puoi ignorare tutti i messaggi sull'aggiornamento della VM e completare questo tutorial. Se prevedi di mantenere le VM come ambiente di test, potresti aggiornare il sistema operativo o eseguire l'upgrade alla release successiva, come descritto nella documentazione di Ubuntu.

2. Imposta le tue credenziali utente come credenziali predefinite dell'applicazione:

   gcloud auth application-default login
   

   Segui le istruzioni per selezionare il tuo Account Google per l'ADC.

3. 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 avrà creato correttamente il cluster di bootstrap, visualizzerai un 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..

Attenzione: lascia il comando in esecuzione durante la creazione del cluster di amministrazione. Se esci dal comando bmctl register bootstrap prima di creare il cluster di amministrazione, la creazione del cluster di amministrazione non riesce. Una volta creato il cluster, il comando elimina automaticamente il cluster bootstrap e ne esce.

Crea il cluster di amministrazione

Console

1. Nella pagina Installa ambiente bootstrap della sezione Ambiente di avvio dalla workstation di amministrazione, fai clic su Verifica connessione.

   Se l'operazione riesce, la console mostra Connessione stabilita.

   La connessione al cluster bootstrap deve essere stabilita prima di continuare. Se la connessione non è stabilita, controlla gli argomenti che hai specificato nel comando bmctl register bootstrap:

   • Assicurati che il valore di --name corrisponda al nome del bootstrap derivato visualizzato nella sezione Nozioni di base sull'ambiente bootstrap.

   • Assicurati che il valore di --project-id corrisponda all'ID del progetto selezionato nella console.

   Se devi modificare il nome del cluster bootstrap o l'ID progetto, inserisci Ctrl-C per uscire da bmctl register bootstrap ed eseguire nuovamente il comando.

2. Fai clic su Networking nella barra di navigazione a sinistra.

3. Nella sezione Piano di controllo, inserisci quanto segue nel campo Nodo piano di controllo IP 1:

   10.200.0.3
   

   Questo è l'indirizzo IP della VM abm-admin-cluster-cp nella VXLAN creata dallo script.

4. Nella sezione Bilanciatore del carico, assicurati che sia selezionato In bundle.

5. Nella sezione IP virtuali (VIP), inserisci quanto segue nel campo VIP del piano di controllo:

   10.200.0.48
   

6. Fai clic su Verifica e crea.

   Nella console vengono visualizzati messaggi di stato durante la verifica delle impostazioni e la creazione del cluster.

Interfaccia a riga di comando gcloud

1. Assicurati che le variabili di ambiente che hai definito in precedenza abbiano i 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
   

2. Verifica che il cluster bootstrap sia stato registrato come membro del parco risorse:

   gcloud container fleet memberships list \
     --project=PROJECT_ID
   

   Se il cluster bootstrap non è in elenco, controlla il nome e l'ID del progetto bootstrap specificati in bmctl register bootstrap. Se devi modificare il nome del cluster bootstrap o l'ID progetto, inserisci Ctrl-C per uscire da bmctl register bootstrap ed eseguire nuovamente il comando.

3. Crea il cluster di amministrazione con il bilanciatore del carico in bundle:

   gcloud beta 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: è impostato su 10.200.0.48. Questo è l'IP virtuale (VIP) sul bilanciatore del carico del server API Kubernetes del cluster.

   • --control-plane-node-configs: il valore di node-ip è impostato su 10.200.0.3. Questo è l'indirizzo IP della VM abm-admin-cluster-cp nella VXLAN creata dallo script.

   Per un elenco completo dei flag e delle relative descrizioni, consulta il riferimento per l'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 è il valore OPERATION_ID dell'operazione a lunga esecuzione. Puoi conoscere lo stato dell'operazione eseguendo questo comando in un'altra finestra del terminale:

   gcloud beta 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 sulla tua workstation di amministrazione. Prima di creare il cluster, bmctl esegue una serie di controlli 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 tuo cluster di amministrazione nella workstation di amministrazione della directory bmctl-workspace dell'account root. Per verificare il deployment, completa i seguenti passaggi.

1. Se lo script ha creato il cluster di amministrazione, utilizza SSH per connetterti alla workstation di amministrazione come root:

   gcloud compute ssh root@abm-ws --zone ZONE
   

   Puoi ignorare tutti i messaggi sull'aggiornamento della VM e completare questo tutorial. Se prevedi di mantenere le VM come ambiente di test, potresti aggiornare il sistema operativo o eseguire l'upgrade alla release successiva, come descritto nella documentazione di Ubuntu.

2. Imposta la variabile di ambiente KUBECONFIG con il percorso del file di configurazione del cluster per eseguire i comandi kubectl 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
   

3. Imposta il contesto corrente in una variabile di ambiente:

   export CONTEXT="$(kubectl config current-context)"
   

4. Esegui questo comando gcloud. Il comando seguente:

   • Concede al tuo account utente il ruolo clusterrole/cluster-admin Kubernetes sul cluster.
   • Configura il cluster in modo da poter eseguire i comandi kubectl sul computer locale senza dover accedere alla workstation di amministrazione tramite SSH.
   • Ti consente di accedere al cluster nella console utilizzando la tua identità Google.

   Sostituisci YOUR_EMAIL_ADDRESS con l'indirizzo email associato al tuo account Google Cloud. Ad esempio: --users=[e-mail].

   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, troncato per la leggibilità:

   Validating input arguments.
   Specified Cluster Role is: clusterrole/cluster-admin
   Generated RBAC policy is:
   --------------------------------------------
   ...
   
   Applying the generate RBAC policy to cluster with kubeconfig: /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.
   

5. Quando hai finito di esplorare, inserisci exit per uscire dalla workstation di amministrazione.

6. Esegui questo comando sul computer locale per recuperare la voce kubeconfig che può accedere al cluster tramite il gateway di connessione:

   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.
   

7. Ora puoi eseguire 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
   

8. Se lo script ha creato il cluster di amministrazione, esegui il comando seguente per registrare il cluster nell'API Anthos On-Prem:

   gcloud beta container bare-metal admin-clusters enroll ADMIN_CLUSTER_NAME  \
       --project=PROJECT_ID \
       --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
       --location=ON_PREM_API_REGION
   

   Se hai creato il cluster, viene registrato automaticamente nell'API Anthos On-Prem.

Crea il cluster utente

Anteprima

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Quando lo script ha creato l'L2 VXLAN per le VM, ha assegnato i seguenti indirizzi IP nella rete 10.200.0.0/24. Questi indirizzi IP vengono utilizzati per configurare le impostazioni del pool di nodi e di rete 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-utente-cluster-cp1	10.200.0.4	Nodo del piano di controllo per il cluster utente
cluster-utente-abm-w1	10.200.0.5	Nodo worker per il cluster utente
cluster-utente-abm-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 il cluster utente.

Console

Per creare un cluster utente nella console:

1. Nella console, vai alla pagina Cluster Anthos.

   Vai a Cluster Anthos di Anthos

2. Assicurati che il progetto Google Cloud in cui hai creato il cluster di amministrazione sia selezionato. Nell'elenco dovresti vedere il cluster di amministrazione.

3. Fai clic su Crea cluster.

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

5. Accanto a Bare metal, fai clic su Configure (Configura).

6. Fai clic su Nozioni di base sul cluster nella barra di navigazione a sinistra.

Impostazioni di base del cluster

1. Inserisci un nome per il cluster utente o utilizza il valore predefinito.

2. Assicurati che sia selezionato il cluster di amministrazione appena creato. Puoi utilizzare le impostazioni predefinite per le altre impostazioni di questa pagina.

3. Fai clic su Networking nella barra di navigazione a sinistra.

Networking

1. Nella sezione Piano di controllo, inserisci quanto segue nel campo Nodo piano di controllo IP 1:

   10.200.0.4
   

   Questo è l'indirizzo IP della VM abm-user-cluster-cp1 nella VXLAN creata dallo script.

2. Nella sezione Bilanciatore del carico, utilizza il bilanciatore del carico predefinito, Abbinato a MetalLB.

3. Nella sezione Nuovo pool di indirizzi, inserisci il seguente intervallo di indirizzi IP nel campo Intervallo di indirizzi IP 1:

   10.200.0.51-10.200.0.70
   

4. Fai clic su Fine.

5. Nella sezione IP virtuali, inserisci il seguente indirizzo IP nel campo VIP piano di controllo:

   10.200.0.50
   

6. Inserisci il seguente indirizzo IP per il VIP in entrata:

   10.200.0.51
   

7. Utilizza gli indirizzi IP predefiniti nella sezione Service e Pod CIDR.

8. 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. Un pool di nodi è un modello per i gruppi di nodi worker creati in questo cluster.

Inserisci il seguente indirizzo IP nel campo Indirizzo nodi 1:

10.200.0.5

Questo è l'indirizzo IP della VM abm-user-cluster-w1 nella VXLAN creata dallo script.

Crea il cluster

1. Fai clic su Verifica e crea per creare il cluster utente.

   La creazione del cluster utente richiede almeno 15 minuti. Nella console vengono visualizzati i messaggi di stato durante la verifica delle impostazioni e la creazione del cluster.

   Se si verifica un problema con la configurazione, la console visualizza un messaggio di errore che deve essere abbastanza chiaro da consentirti di risolvere il problema 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. Fai clic su per chiudere il riquadro dei dettagli.

   Alla creazione del cluster viene visualizzato Stato cluster: in esecuzione.

   

2. Dopo aver creato il cluster, fai clic su Cluster per tornare alla pagina Cluster.

Interfaccia a riga di comando gcloud

Per creare un cluster utente, utilizza il comando seguente:

gcloud beta container bare-metal clusters create

Dopo aver creato il cluster, devi creare almeno un pool di nodi utilizzando il comando seguente:

gcloud beta container bare-metal node-pools create

Per creare il cluster utente:

1. Assicurati che le variabili di ambiente che hai definito in precedenza abbiano i 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
   

2. Esegui il comando seguente per creare il cluster utente. Sostituisci quanto segue:

   • USER_CLUSTER_NAME: il nome del cluster.

   • Assicurati che --admin-users sia impostato sull'indirizzo email associato al tuo Account Google in modo da poter 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 di appartenenza completamente specificato.

   gcloud beta 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à registrato il cluster utente. Questo progetto è denominato 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 di Google Cloud in cui l'API Anthos On-Prem esegue e archivia i propri metadati.

• --version: la versione di Anthos clusters on bare metal.

• --admin-users: includi il tuo indirizzo email per ottenere i criteri di controllo dell'accesso basati sui ruoli (RBAC) di Kubernetes che ti danno accesso completo amministrativo al cluster.

• --metal-lb-address-pools: la configurazione del pool di indirizzi per il bilanciatore del carico MetalLB in bundle. L'intervallo di indirizzi IP deve essere compreso nella rete 10.200.0.0/24 creata dallo script. L'intervallo di indirizzi non deve contenere gli indirizzi IP assegnati alle VM né il VIP del piano di controllo. Tieni però presente che il VIP Ingress deve essere compreso in questo intervallo di indirizzi.

• --control-plane-node-configs: la configurazione del nodo del piano di controllo per il cluster utente. Il valore per node-ip è 10.200.0.4, ovvero l'indirizzo IP assegnato dallo script alla VM abm-user-cluster-cp1.

• --control-plane-vip: l'IP virtuale per il piano di controllo. Il valore 10.200.0.50 appartiene alla rete 10.200.0.0/24 creata dallo script, ma non si sovrappone all'intervallo di indirizzi IP utilizzato per i pool di indirizzi del bilanciatore del carico MetalLB.

• --control-plane-load-balancer-port: la porta su cui il bilanciatore del carico gestisce il piano di controllo. Anche se puoi configurare un altro valore, la porta 443 è 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 i pool di indirizzi del bilanciatore del carico MetalLB.

• --island-mode-service-address-cidr-blocks: un intervallo di indirizzi IP, in formato CIDR, da utilizzare per i servizi nel cluster utente. Il comando di esempio ha utilizzato 10.96.0.0/20, valore predefinito fornito dalla console. L'intervallo CIDR deve essere compreso tra /24 e /12, dove /12 fornisce il maggior numero di indirizzi IP. Ti consigliamo di utilizzare un intervallo nello spazio di indirizzi IP per le reti Internet private, come definito nel documento RFC 1918.

• --island-mode-pod-address-cidr-blocks: un intervallo di indirizzi IP, in formato CIDR, da utilizzare per i pod nel cluster utente. Il comando di esempio ha utilizzato 192.168.0.0/16, valore predefinito fornito dalla console. L'intervallo CIDR deve essere compreso tra /18 e /8, dove /8 fornisce il maggior numero di indirizzi IP. Consigliamo di utilizzare un intervallo nello spazio di indirizzi IP per Internet privati, come definito in RFC 1918.

• --lvp-share-path: questo è il percorso della macchina host in cui possono essere create le sottodirectory. Per ogni sottodirectory viene creato un oggetto PersistentVolume (PV) locale.

• --lvp-share-storage-class: questo è l'oggetto StorageClass da utilizzare per creare volumi permanenti. Il valore StorageClass viene creato durante la creazione del cluster.

• --lvp-node-mounts-config-path: questo è il percorso della macchina host in cui possono essere rilevati i dischi montati. Per ogni montaggio viene creato un oggetto PersistentVolume (PV) locale.

• --lvp-node-mounts-config-storage: la classe di archiviazione con cui vengono creati i volumi permanenti durante la creazione del cluster.

Dopo aver eseguito il comando, viene visualizzato l'output come il 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 valore OPERATION_ID dell'operazione a lunga esecuzione.

Per conoscere lo stato dell'operazione, copia OPERATION_ID dall'output nel comando seguente. Apri un'altra finestra del terminale ed esegui il comando.

gcloud beta container bare-metal operations describe OPERATION_ID \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

La creazione del cluster richiede circa 15 minuti. Durante la creazione del cluster, puoi eseguire di frequente il comando precedente per ottenere lo stato attuale.

Alla creazione del cluster, visualizzi 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 il comando seguente 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 sia ancora impostato sul nome del cluster utente.

gcloud beta 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 a node-ip è l'indirizzo IP della VM abm-user-cluster-w1 nella VXLAN creata dallo script.

Dopo aver eseguito il comando, viene visualizzato l'output come il seguente:

Waiting for operation [projects/PROJECT_ID/locations/ON_PREM_API_REGION/operations/operation-1678308682052-5f669b0d132cb-6ebd1c2c-816287a7] to complete...

La creazione del pool di nodi richiede circa 5 minuti. Quando viene creato il pool di nodi, visualizzi 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, puoi eseguire altri comandi gcloud CLI, ad esempio:

• Per elencare i cluster utente:

gcloud beta container bare-metal clusters list \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

• Per descrivere un cluster utente:

gcloud beta container bare-metal clusters describe USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Per ulteriori informazioni, consulta Cluster beta gcloud beta container.

Altri comandi del pool di nodi

Oltre a creare pool di nodi, esistono altri comandi gcloud CLI che puoi eseguire, ad esempio:

• Per elencare i pool di nodi:

gcloud beta 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 beta container bare-metal node-pools describe NODE_POOL_NAME \
    --cluster=USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Per ulteriori informazioni, consulta pool di nodi bare-metal del container beta gcloud.

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 la documentazione di riferimento per google_gkeonprem_bare_metal_cluster.

1. Nella directory in cui hai clonato anthos-samples, passa alla directory in cui si trova l'esempio di Terraform:

   cd anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb
   

   Nell'esempio è fornito un file di variabili di esempio da trasmettere a main.tf.

2. Crea una copia del file terraform.tfvars.sample:

   cp terraform.tfvars.sample terraform.tfvars
   

   anthos-onprem-terraform/abm_user_cluster_metallb/terraform.tfvars.sample

   Visualizza su GitHub

   
   project_id          = "PROJECT_ID"
   region              = "ON_PREM_API_REGION"
   admin_cluster_name  = "ADMIN_CLUSTER_NAME"
   bare_metal_version  = "VERSION"
   admin_user_emails   = ["YOUR_EMAIL_ADDRESS", "ADMIN_2_EMAIL_ADDRESS"]
   cluster_name        = "abm-user-cluster-metallb"
   control_plane_ips   = ["10.200.0.4"]
   worker_node_ips     = ["10.200.0.5", "10.200.0.6"]
   control_plane_vip   = "10.200.0.50"
   ingress_vip         = "10.200.0.51"
   lb_address_pools    = [
       { name = "lbpool_1", addresses = ["10.200.0.51-10.200.0.70"] }
   ]
   

3. Modifica i valori dei parametri in terraform.tfvars e salva il file.

   Nell'elenco che segue vengono descritte le variabili:

   • project_id: l'ID del progetto in cui verrà registrato il cluster utente. Questo progetto è denominato progetto host del parco risorse.

   • region: la regione di Google Cloud che hai impostato all'inizio del tutorial. Esegui echo $ON_PREM_API_REGION per ottenere il valore.

   • admin_cluster_name: il nome del cluster di amministrazione impostato all'inizio di questo tutorial. Esegui echo $ADMIN_CLUSTER_NAME per ottenere il valore.

   • bare_metal_version: la versione di Anthos clusters on bare metal per il tuo cluster utente. Per utilizzare la stessa versione utilizzata per il cluster di amministrazione, esegui echo $BMCTL_VERSION per ottenere il valore. Se preferisci, puoi specificare una versione non superiore a una versione secondaria inferiore a quella del cluster di amministrazione. La versione del cluster utente non può essere successiva a quella del cluster di amministrazione.

   • cluster_name: puoi utilizzare il nome nel file TVARS per il cluster utente oppure specificare un nome a tua scelta. Il nome non può essere modificato dopo la creazione del cluster.

   • admin_user_emails: un elenco di indirizzi email degli utenti a cui concedere i privilegi amministrativi sul cluster. Assicurati di aggiungere il tuo indirizzo email in modo da poter amministrare il cluster.

     Quando viene creato il cluster, l'API Anthos On-Prem applica i criteri di controllo dell'accesso basati sui ruoli (RBAC) di Kubernetes al cluster per concedere agli utenti amministratori il ruolo clusterrole/cluster-admin di Kubernetes, che fornisce l'accesso completo a ogni risorsa nel cluster in tutti gli spazi dei nomi. In questo modo gli utenti possono anche accedere alla console utilizzando la propria identità Google.

   Utilizza i valori predefiniti definiti in terraform.tvars per le variabili rimanenti. Lo script ha utilizzato questi valori al momento della creazione delle VM e del cluster di amministrazione.

   • control_plane_ips: un elenco di uno o più indirizzi IPv4 per i nodi del piano di controllo. Utilizza il valore predefinito, ovvero l'indirizzo IP assegnato allo script abm-user-cluster-cp1 alla VM.

   • worker_node_ips: un elenco di uno o più indirizzi IPv4 per le macchine con nodi worker. Utilizza i valori predefiniti, ovvero gli indirizzi IP assegnati allo script assegnato alle VM abm-user-cluster-w1 e abm-user-cluster-w2.

   • control_plane_vip: l'IP virtuale (VIP) per il piano di controllo. Utilizza il valore predefinito, 10.200.0.50, nella rete 10.200.0.0/24 creata dallo script. Tieni presente che questo indirizzo IP non si sovrappone all'intervallo di indirizzi IP utilizzato per i pool di indirizzi del bilanciatore del carico MetalLB.

   • 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, che si trova nella rete 10.200.0.0/24 creata dallo script. Tieni presente che questo indirizzo IP rientra nell'intervallo di indirizzi IP utilizzato per i pool di indirizzi del bilanciatore del carico MetalLB.

   • lb_address_pools: un elenco di mappe che definiscono i pool di indirizzi per il bilanciatore del carico MetalLB. Utilizza il valore predefinito.

4. Salva le modifiche in terraform.tfvars.

5. Inizializza e crea il piano Terraform:

   terraform init
   

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

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

   terraform plan
   

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

   terraform apply
   

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

Connettiti al cluster utente

Quando crei un cluster utente utilizzando la console o gcloud CLI, il cluster è configurato con gli stessi criteri di controllo dell'accesso dell'accesso basati sui ruoli (RBAC) di Kubernetes che hai configurato per il cluster di amministrazione quando hai eseguito gcloud container fleet memberships generate-gateway-rbac. Questi criteri RBAC consentono di connetterti al cluster utilizzando la tua identità Google Cloud, che è l'indirizzo email associato al tuo account Google Cloud. Questi criteri RBAC consentono di accedere alla console senza ulteriori configurazioni.

Connettiti al cluster nella console

Se hai utilizzato gcloud CLI per creare il cluster utente, vai alla pagina Cluster Anthos nella console:

Vai a Cluster Anthos di Anthos

Assicurati che il progetto in cui hai creato il cluster utente sia selezionato. Nell'elenco dovrebbero essere visualizzati sia il cluster di amministrazione sia il cluster utente.

Nota che il cluster utente ha Anthos (Bare metal: Utente) nella colonna Tipo. Indica che il cluster è gestito dall'API Anthos On-Prem.

Il cluster di amministrazione ha il valore Esterno nella colonna Tipo. Indica che il cluster non è gestito dall'API Anthos On-Prem.

Sebbene il cluster di amministrazione sia stato creato dallo script utilizzando bmctl, puoi configurare il cluster di amministrazione affinché venga gestito dall'API Anthos On-Prem.

Per accedere a un cluster:

1. Fai clic sul link nel nome del cluster e fai clic su Accedi nel riquadro laterale.

2. Seleziona Usa la tua identità Google per accedere.

3. Fai clic su Accedi.

Ripeti gli stessi passaggi per accedere al cluster di amministrazione.

Connettiti al cluster dalla riga di comando

L'API Anthos On-Prem configura i criteri RBAC per te in quanto creatore di cluster utente. Questi criteri consentono di eseguire i comandi kubectl sul desktop locale utilizzando il kubeconfig del gateway Connect.

Dal computer locale:

1. Recupera la voce kubeconfig che può accedere al cluster tramite il gateway Connect.

   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.
   

2. Ora puoi eseguire comandi kubectl tramite il gateway Connect:

   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

1. Nella console Google Cloud, vai alla pagina Cluster Anthos.

   Vai a Cluster Anthos di Anthos

2. Nell'elenco dei cluster, fai clic sul nome del cluster e poi su Altri dettagli nel riquadro Dettagli.

3. Fai clic sulla scheda Nodi.

4. Fai clic su Aggiungi pool di nodi.

5. Inserisci un nome per il pool di nodi.

6. Nel campo Indirizzo nodi 1, inserisci il seguente indirizzo IP:

   10.200.0.6
   

   Questo è l'indirizzo IP della VM abm-user-cluster-w2 creata dallo script.

7. Fai clic su Crea.

8. Se necessario, fai di nuovo clic sulla scheda Nodi.

9. Il nuovo pool di nodi mostra lo stato Riconciliazione in corso.

10. Fai clic su nell'angolo in alto a destra per visualizzare lo stato della creazione del pool di nodi. Potresti dover aggiornare la pagina per visualizzare lo stato aggiornato nell'elenco dei pool di nodi.

Interfaccia a riga di comando gcloud

Esegui il comando seguente 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 sul nome del cluster utente.

gcloud beta 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 a node-ip è l'indirizzo IP della 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 VM aggiuntive nella VXLAN per aggiungerne un altro. Per informazioni sull'aggiunta di pool di nodi, consulta la documentazione di riferimento di google_gkeonprem_bare_metal_cluster.

Puoi anche verificare il nuovo nodo utilizzando kubectl. Devi prima eseguire il comando gcloud container fleet memberships get-credentials come mostrato in precedenza 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

Elimina il cluster utente

Console

1. Nella console, vai alla pagina Cluster Anthos.

   Vai a Cluster Anthos di Anthos

2. Nell'elenco dei cluster, fai clic sul cluster utente.

3. Nel riquadro Dettagli, fai clic su Altri dettagli.

4. Nella parte superiore della finestra, fai clic su Elimina.

5. Quando ti viene chiesto di confermare, inserisci il nome del cluster e fai clic su Conferma.

6. Fai clic su nell'angolo in alto a destra per visualizzare lo stato dell'eliminazione. Potresti dover aggiornare la pagina per aggiornare l'elenco dei cluster.

Interfaccia a riga di comando gcloud

Esegui questo comando per eliminare il cluster:

gcloud beta 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 con pool di nodi. Senza il flag --force, devi prima eliminare i pool di nodi e quindi eliminare il cluster.

Per informazioni sugli altri flag, consulta gcloud beta 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 le VM.

Elimina il cluster di amministrazione e le VM

1. Annulla la registrazione del cluster di amministrazione dall'API Anthos On-Prem:

   gcloud beta container bare-metal admin-clusters unenroll ADMIN_CLUSTER_NAME \
       --project=PROJECT_ID \
       --location=ON_PREM_API_REGION
   

2. Connettiti alla workstation di amministrazione:

   gcloud compute ssh root@abm-ws --zone ZONE
   

3. Elimina il cluster di amministrazione:

   bmctl reset -c ADMIN_CLUSTER_NAME
   

   bmctl annulla la registrazione del cluster dal parco risorse, quindi elimina il cluster. Attendi che il cluster venga eliminato prima di eliminare le VM.

4. Esci dalla workstation di amministrazione.

5. Elenca tutte le VM che hanno abm nel loro nome:

   gcloud compute instances list | grep 'abm'
   

6. Verifica di voler eliminare tutte le VM che contengono abm.

   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
   

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

• Crea un Service e una risorsa Ingress
• Pianificare l'installazione
• Crea cluster di base