Crea cluster amministrativi e utente demo di Google Distributed Cloud nelle VM di Compute Engine

Distributed Cloud software only per bare metal ti consente di valutare il deployment e le operazioni dei cluster creando cluster demo su macchine virtuali (VM) Compute Engine. In questo tutorial eseguirai uno script che esegue il provisioning di cinque VM Compute Engine e configura una rete VPC per fornire la connettività del cluster. Al termine dello script, utilizza bmctl, la consoleGoogle Cloud , Google Cloud CLI o Terraform per creare un cluster di amministrazione e un cluster utente associato che possa ospitare i workload.

Il completamento di questi passaggi può richiedere da 40 minuti a un'ora. Questo deployment è solo a scopo di valutazione. Non eseguire questi cluster demo in produzione. Per eseguire il deployment di Google Distributed Cloud in produzione, segui i passaggi descritti in Crea cluster di base.

Panoramica della procedura

In questo tutorial, completerai i seguenti passaggi:

  1. Prepara l'ambiente locale in modo che lo script abbia le variabili di ambiente richieste e tu abbia raccolto le informazioni di base necessarie per eseguire i comandi.

  2. Crea le VM e la rete con lo script scaricato.

  3. Crea il cluster di amministrazione con uno dei client supportati.

  4. Crea il cluster utente con uno dei client supportati.

  5. 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, non è necessario raccogliere molte informazioni o eseguire alcuna pianificazione. I seguenti passaggi configurano l'ambiente locale e raccolgono le informazioni di base necessarie nelle sezioni successive della guida:

  1. 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 senza costi per l'esecuzione, il test e il deployment dei workload.

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  5. Verify 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 di questa pagina. Se hai selezionato un progetto esistente, assicurati di essere un Project Owner o un editor.
  7. Puoi eseguire lo script su Cloud Shell o sulla tua macchina locale con Linux o macOS. Se utilizzi una macchina locale, assicurati che nel tuo ambiente siano installati gli strumenti richiesti:
    1. Assicurati di aver installato l'ultima versione di Google Cloud CLI, lo strumento a riga di comando per interagire con Google Cloud. Aggiorna i componenti di gcloud CLI, se necessario: 
      gcloud components update

      A seconda di come è stata installata gcloud CLI, potresti visualizzare 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 per aggiornare i componenti.

    2. Assicurati di aver installato kubectl: 
      kubectl
       Dovresti visualizzare le informazioni sull'utilizzo per kubectl. Se il comando non è disponibile, installa kubectl: 
      gcloud components install kubectl
  8. Assicurati che il tuo progetto abbia una rete VPC denominata "default".

    Se non hai una rete VPC "predefinita", lo script nella sezione seguente non riesce a eseguire il provisioning delle risorse necessarie. A meno che tu non scelga di eliminarla o limitarla, ogni nuovo progetto inizia con una rete VPC in modalità automatica denominata "default" che dovrebbe funzionare con lo script. Per saperne di più, consulta Reti VPC.

  9. Assicurati che i seguenti vincoli delle policy dell'organizzazione non siano applicati:
    • constraints/iam.disableServiceAccountKeyCreation
    • constraints/compute.vmCanIpForward
    • constraints/compute.requireShieldedVm
    • constraints/compute.vmExternalIpAccess

    Se questi vincoli vengono applicati, lo script nella sezione seguente non riesce a eseguire il provisioning delle risorse necessarie. Per un nuovo progetto, questi vincoli sono impostati su Non attivo (non applicato) per impostazione predefinita. Per saperne di più, consulta Vincoli delle policy dell'organizzazione.

  10. 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 il cluster di amministrazione.
    • ON_PREM_API_REGION: la regione Google Cloud in cui l'API GKE On-Prem viene eseguita e archivia i suoi metadati. Specifica us-central1 o un'altra regione supportata.
    • ZONE: la zona Google Cloud in cui vengono create le VM di Compute Engine. Puoi utilizzare us-central1-a o una qualsiasi delle altre zone di Compute Engine.
  11. 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, esegui gcloud auth login per accedere a gcloud CLI con l'account che ha accesso al progetto.

  12. Visualizza un elenco delle versioni supportate che puoi installare: 
    gcloud container bare-metal admin-clusters query-version-config \
    --location=ON_PREM_API_REGION
  13. Seleziona una versione dall'output del comando precedente e impostala in una variabile di ambiente: 
    export BMCTL_VERSION=BMCTL_VERSION

    Ti consigliamo di selezionare la versione compatibile più recente per ottenere le funzionalità e le correzioni più aggiornate di Google Distributed Cloud.

2. Crea le VM e la rete

In questa sezione scaricherai ed eseguirai lo script install_admin_cluster.sh.

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

  2. Esegui lo script:

    bash install_admin_cluster.sh

  3. Al prompt, inserisci 2 per configurare solo l'infrastruttura di Compute Engine e conferma la selezione quando richiesto.

    Lo script crea VM di Compute Engine, crea una rete VXLAN e configura la workstation di amministrazione e i nodi del cluster. La configurazione di questa infrastruttura richiede circa 5 minuti.

    Per scoprire di più sullo script, fai clic sul seguente link:

    Informazioni sullo script

    Puoi visualizzare lo script nella cartella anthos-bm-gcp-bash nel repository GitHub anthos-samples. Lo script esegue queste operazioni:

    1. Abilita le seguenti API Google Cloud : 
      anthos.googleapis.com
anthosaudit.googleapis.com
anthosgke.googleapis.com
cloudresourcemanager.googleapis.com
connectgateway.googleapis.com
container.googleapis.com
compute.googleapis.com
gkeconnect.googleapis.com
gkehub.googleapis.com
gkeonprem.googleapis.com
serviceusage.googleapis.com
stackdriver.googleapis.com
monitoring.googleapis.com
logging.googleapis.com
kubernetesmetadata.googleapis.com
iam.googleapis.com
opsconfigmonitoring.googleapis.com
    2. Anziché creare più service account per API e servizi diversi, lo script crea un unico account di servizio denominato baremetal-gcr e gli concede i seguenti ruoli IAM:
      • roles/gkehub.admin
      • roles/gkehub.connect
      • roles/logging.logWriter
      • roles/monitoring.dashboardEditor
      • roles/monitoring.metricWriter
      • roles/monitoring.viewer
      • roles/opsconfigmonitoring.resourceMetadata.writer
      • roles/serviceusage.serviceUsageViewer
      • roles/stackdriver.resourceMetadata.writer
    3. Crea le seguenti VM:
      • Una VM per la workstation di amministrazione
      • Una VM per il nodo del control plane del cluster di amministrazione
      • Due VM per i nodi worker del cluster utente
      • Una VM per il nodo del control plane del cluster utente
    4. Verifica che SSH sia abilitato su tutte le VM e che la workstation di amministrazione abbia accesso SSH a tutte le altre VM create per i nodi del cluster.
    5. Crea una rete overlay Virtual Extensible LAN (VXLAN) per la connettività di livello 2 tra le VM. La VXLAN non è persistente, quindi se riavvii un'istanza VM, la rete viene eliminata. La rete è configurata per trovarsi nella subnet 10.200.0.0/24. La connettività di livello 2 è un requisito per il bilanciatore del carico in bundle.
    6. Installa i seguenti strumenti sulla workstation di amministrazione:
      • bmctl
      • kubectl
      • Docker

      Lo script scarica anche la chiave del account di servizio per il account di servizio baremetal-gcr nella workstation di amministrazione.

    7. Assicura che root@10.200.0.x dalla workstation di amministrazione funzioni eseguendo le seguenti operazioni:
      1. Genera una nuova chiave SSH sulla workstation di amministrazione.
      2. Aggiunge la chiave pubblica a tutte le altre VM del deployment.

    Lo script genera ogni comando eseguito e lo stato. Al termine, lo script restituisce il seguente output:

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

3. Crea il cluster di amministrazione

bmctl

Per creare un cluster di amministrazione con bmctl, accedi alla VM della workstation di amministrazione in una finestra del terminale ed esegui i comandi da lì:

  1. Utilizza SSH per accedere alla VM della workstation di amministrazione, abm-ws, come root:

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

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

  3. Genera un file di configurazione del cluster:

    bmctl create config -c ADMIN_CLUSTER_NAME --project-id=PROJECT_ID

  4. Verifica il file di configurazione del cluster di amministrazione:

    Il seguente file di configurazione del cluster è compilato con i valori che hai 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 esempio per migliorare 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: ON_PREM_API_REGION
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 110

  5. Sostituisci i contenuti del file di configurazione generato sulla tua workstation di amministrazione con i contenuti dell'esempio precedente.

    Apri il file generato, bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME.yaml e sostituisci i contenuti con quelli dell'esempio che hai verificato nel passaggio precedente.

  6. Crea il cluster di amministrazione:

    bmctl create cluster -c ADMIN_CLUSTER_NAME

    Il comando bmctl mostra l'output sullo schermo mentre esegue i controlli preflight e crea il cluster. Le informazioni dettagliate vengono scritte nei log nella cartella baremetal/bmctl-workspace/abm-user-cluster-metallb/log sulla workstation di amministrazione.

    La creazione del cluster può richiedere diversi minuti.

  7. Nella console, vai alla pagina Cluster GKE.

    Vai ai cluster GKE

    Assicurati che sia selezionato il progetto in cui hai creato il cluster utente. Dovresti vedere il cluster di amministrazione nell'elenco.

  8. Accedi al cluster di amministrazione:

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

    2. Seleziona Accedi con la tua identità Google.

    3. Fai clic su Login (Accedi).

Verifica il cluster di amministrazione

Puoi trovare il file kubeconfig del cluster di amministrazione sulla workstation di amministrazione nella directory bmctl-workspace dell'account root. Per verificare il deployment, completa i seguenti passaggi:

  1. Utilizza SSH per accedere alla workstation di amministrazione come root:

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

  2. 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      1.31.300-gke.81

  3. Al termine dell'esplorazione, inserisci exit per disconnetterti dalla workstation di amministrazione.

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

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

    Vai ai cluster GKE

  2. Fai clic su Crea.

  3. Nella finestra di dialogo Crea un cluster, seleziona On-premise e fai clic su Configura per bare metal.

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

  5. Nella barra di navigazione a sinistra, fai clic su Installa l'ambiente di bootstrap.

  6. Inserisci ADMIN_CLUSTER_NAME come nome del cluster di amministrazione.

  7. Seleziona BMCTL_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 Google Distributed Cloud che installi deve corrispondere alla versione di bmctl.

  8. Nel campo Località API Google Cloud, seleziona ON_PREM_API_REGION dall'elenco. Questa impostazione specifica la regione in cui viene eseguita l'API GKE On-Prem e la regione in cui vengono 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
    • L'audit log amministrativo 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, segui i passaggi descritti nella sezione successiva anziché quelli visualizzati nella console. Lascia visualizzata la pagina della console, perché continuerai a utilizzarla per creare il cluster di amministrazione.

Crea il cluster di bootstrap

Quando utilizzi un client API GKE On-Prem, come la console, per creare un cluster di amministrazione, devi creare un cluster di bootstrap sulla workstation di amministrazione. Il cluster di bootstrap ospita i controller Kubernetes necessari per creare il cluster di amministrazione.

  1. 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 i messaggi relativi all'aggiornamento della VM e completare questo tutorial. Se prevedi di mantenere le VM come ambiente di test, ti consigliamo di aggiornare il sistema operativo o di eseguire l'upgrade alla release successiva, come descritto nella documentazione di Ubuntu.

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

  3. 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 nome 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, viene visualizzato 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..

Crea il cluster di amministrazione

  1. Nella pagina Installa l'ambiente di bootstrap, nella sezione Esegui il bootstrap dell'ambiente dalla workstation di amministrazione, fai clic su Controlla connessione.

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

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

    • Assicurati che il valore di --name corrisponda al Nome bootstrap derivato visualizzato nella sezione Impostazioni di base dell'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 da bmctl register bootstrap ed esegui nuovamente il comando.

Networking

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

  2. Nella sezione Control plane, inserisci quanto segue nel campo IP del nodo del control plane 1:

    10.200.0.3

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

  3. Nella sezione Bilanciatore del carico, assicurati che sia selezionata l'opzione In bundle.

  4. Nella sezione IP virtuali (VIP), inserisci quanto segue nel campo VIP del control plane:

    10.200.0.48

    Il passaggio successivo dipende dalla disponibilità del cluster di bootstrap. Il comando bmctl register bootstrap nella finestra del terminale deve essere eseguito per alcuni minuti prima che il cluster di bootstrap venga visualizzato come membro registrato. Se dopo qualche minuto non è ancora disponibile, controlla il nome del cluster di bootstrap e l'ID progetto che hai utilizzato. Se devi modificare il nome del cluster di bootstrap o l'ID progetto, inserisci Ctrl-C nell'altra finestra del terminale per uscire da bmctl register bootstrap ed esegui nuovamente il comando.

  5. Fai clic su Verifica e crea.

    La console visualizza i messaggi di stato mentre verifica le impostazioni e crea il cluster.

    Quando viene creato il cluster di amministrazione, il cluster di bootstrap sulla workstation di amministrazione viene eliminato. L'output del comando 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 nella directory bmctl-workspace dell'account root. Per verificare il deployment, completa i seguenti passaggi:

  1. Utilizza SSH per accedere alla workstation di amministrazione come root:

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

  2. 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      1.31.300-gke.81

  3. Al termine dell'esplorazione, inserisci exit per disconnetterti dalla workstation di amministrazione.

gcloud CLI

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 il cluster di amministrazione.

Crea il cluster di bootstrap

Quando utilizzi un client API GKE On-Prem, come gcloud CLI, per creare un cluster di amministrazione, devi creare un cluster di bootstrap sulla workstation di amministrazione. Il cluster di bootstrap ospita i controller Kubernetes necessari per creare il cluster di amministrazione.

  1. 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 i messaggi relativi all'aggiornamento della VM e completare questo tutorial. Se prevedi di mantenere le VM come ambiente di test, ti consigliamo di aggiornare il sistema operativo o di eseguire l'upgrade alla release successiva, come descritto nella documentazione di Ubuntu.

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

  3. 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 nome 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, viene visualizzato 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..

Crea il cluster di amministrazione

  1. In una nuova finestra del terminale, verifica che il cluster di bootstrap sia stato registrato come membro del parco risorse:

    gcloud container fleet memberships list \
    --project=PROJECT_ID

    Il comando gcloud container bare-metal admin-clusters create nel passaggio successivo dipende dalla disponibilità del cluster di bootstrap. Il comando bmctl register bootstrap nell'altra finestra del terminale deve essere eseguito per alcuni 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 nome del cluster di bootstrap o l'ID progetto, inserisci Ctrl-C nell'altra finestra del terminale per uscire da bmctl register bootstrap ed esegui nuovamente il comando.

  2. Crea il cluster di amministrazione con il bilanciatore del carico integrato:

    Assicurati che i valori specificati corrispondano alle variabili di ambiente che hai 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: è 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: 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 di gcloud CLI.

    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 OPERATION_ID dell'operazione a lunga esecuzione. Puoi scoprire lo stato dell'operazione eseguendo questo comando in un'altra finestra del terminale:

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

    Quando il comando gcloud container bare-metal admin-clusters create viene completato 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.31.300-gke.81 abm-cluster-1  RUNNING

    Quando viene creato il cluster di amministrazione, il cluster di bootstrap sulla workstation di amministrazione viene eliminato. L'output del comando 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 nella directory bmctl-workspace dell'account root. Per verificare il deployment, completa i seguenti passaggi:

  1. Utilizza SSH per accedere alla workstation di amministrazione come root:

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

  2. 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      1.31.300-gke.81

  3. Al termine dell'esplorazione, inserisci exit per disconnetterti dalla workstation di amministrazione.

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 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 esempio di Terraform di un cluster utente esistente.

  1. Nella directory in cui hai clonato anthos-samples, esegui questo comando per copiare i file di esempio per il cluster utente MetalLB in una 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

  2. Passa alla directory abm_admin_cluster_basic:

    cd anthos-samples/anthos-onprem-terraform/abm_admin_cluster_basic

  3. Modifica i file Terraform:

    • variables.tf:

      • Definisci una variabile per gli indirizzi IP dei nodi del control plane (anche se per questa demo ne utilizziamo solo uno). Questa variabile deve essere simile alla voce variable "control_plane_ips" { ... }.

      • Definisci una variabile per l'indirizzo VIP del control plane. Questa variabile dovrebbe essere simile alla voce variable "control_plane_vip" { ... }.

    • terraform.tfvars:

      • Assegna i valori delle variabili per le seguenti impostazioni del cluster di amministrazione:

        • Indirizzi IP dei nodi del control plane: 10.200.0.3

        • Indirizzo VIP del control plane: 10.200.0.48

    • main.tf:

      • Sostituisci la risorsa google_gkeonprem_bare_metal_cluster con la risorsa google_gkeonprem_bare_metal_admin_cluster.

      • Elimina la risorsa google_gkeonprem_bare_metal_node_pool e la sezione lifecycle correlata.

      • Aggiorna la risorsa in modo che utilizzi le variabili appena definite.

    Ecco un esempio di come potrebbe apparire il file main.tf quando viene modificato per creare 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 a 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              = "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 = ["10.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, come Terraform, per creare un cluster di amministrazione, devi creare un cluster di bootstrap sulla workstation di amministrazione. Il cluster di bootstrap ospita i controller Kubernetes necessari per creare il cluster di amministrazione.

  1. 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 i messaggi relativi all'aggiornamento della VM e completare questo tutorial. Se prevedi di mantenere le VM come ambiente di test, ti consigliamo di aggiornare il sistema operativo o di eseguire l'upgrade alla release successiva, come descritto nella documentazione di Ubuntu.

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

  3. 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 nome 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, viene visualizzato 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..

Crea il cluster di amministrazione

  1. Inizializza e crea il piano Terraform:

    terraform init

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

  2. Esamina la configurazione e apporta le modifiche necessarie:

    terraform plan

  3. Applica il piano Terraform per creare il cluster di amministrazione:

    terraform apply

    La creazione del cluster di amministrazione richiede almeno 15 minuti. Al termine della creazione del 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.

    Quando viene creato il cluster di amministrazione, il cluster di bootstrap sulla workstation di amministrazione viene eliminato. L'output del comando 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.

  4. Nella console, vai alla pagina Cluster GKE.

    Vai ai cluster GKE

    Assicurati che sia selezionato il progetto in cui hai creato il cluster utente. Dovresti vedere il cluster di amministrazione nell'elenco.

  5. Accedi al cluster di amministrazione:

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

    2. Seleziona Accedi con la tua identità Google.

    3. Fai clic su Login (Accedi).

Verifica il cluster di amministrazione

Puoi trovare il file kubeconfig del cluster di amministrazione sulla workstation di amministrazione nella directory bmctl-workspace dell'account root. Per verificare il deployment, completa i seguenti passaggi:

  1. Utilizza SSH per accedere alla workstation di amministrazione come root:

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

  2. 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      1.31.300-gke.81

  3. Al termine dell'esplorazione, inserisci exit per disconnetterti dalla workstation di amministrazione.

4. Crea il cluster utente

Puoi utilizzare la console Google Cloud , Google Cloud CLI o Terraform per creare il cluster utente. Per semplicità, utilizza abm-user-cluster-metallb come nome del cluster utente, in modo che corrisponda al nome hardcoded negli script Terraform.

bmctl

  1. Utilizza SSH per accedere alla VM della workstation di amministrazione, abm-ws, come root:

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

  2. Genera un file di configurazione del cluster:

    bmctl create config -c abm-user-cluster-metallb \
    --project-id=PROJECT_ID

  3. Nel seguente file di configurazione del cluster utente, imposta il tuo indirizzo email nella sezione clusterSecurity e verifica le altre impostazioni:

    Il seguente file di configurazione del cluster è compilato con i valori che hai inserito nella tabella di pianificazione in precedenza. Oltre ai valori che hai inserito, tieni presente le seguenti differenze rispetto al file di configurazione generato:

    • I commenti sono stati rimossi da questo esempio per migliorare la leggibilità.
    • La sezione delle credenziali è stata rimossa, come di consueto per i cluster utente.
    • Il tipo di cluster, spec.type, è stato impostato su user.
    • Il campo spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts è stato aggiunto per concedere il ruolo clusterrole/cluster-admin al tuo account. Tra le altre cose, questo campo ti consente di accedere al tuo cluster nella consoleGoogle Cloud per visualizzare ulteriori dettagli del 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: ON_PREM_API_REGION
  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

  4. Sostituisci i contenuti del file di configurazione generato sulla tua workstation di amministrazione con i contenuti dell'esempio precedente.

    Apri il file generato, bmctl-workspace/abm-user-cluster-metallb/abm-user-cluster-metallb.yaml, e sostituisci i contenuti con quelli dell'esempio che hai verificato nel passaggio precedente.

  5. 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 mentre esegue i controlli preflight e crea il cluster. Le informazioni dettagliate vengono scritte nei log nella cartella baremetal/bmctl-workspace/abm-user-cluster-metallb/log sulla workstation di amministrazione.

    La creazione del cluster può richiedere diversi minuti.

  6. Nella console Google Cloud , vai alla pagina Cluster GKE.

    Vai ai cluster GKE

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

  7. Accedi al cluster utente:

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

    2. Seleziona Accedi con la tua identità Google.

    3. Fai clic su Login (Accedi).

    Ripeti gli stessi passaggi per accedere al cluster di amministrazione.

Console

Per creare un cluster utente nella console, completa i seguenti passaggi:

  1. Nella console, vai alla pagina Crea un cluster Bare Metal.

    Vai a Crea un cluster bare metal

  2. Assicurati che sia selezionato il progetto Google Cloud in cui hai creato 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 Configura. Viene visualizzata la pagina Prerequisiti.

  6. In Scegli il tipo di cluster, seleziona Crea un cluster utente per un cluster di amministrazione esistente

  7. Fai clic su Avanti.

Impostazioni di base del cluster

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

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

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

Networking

Lo script che hai eseguito per creare le VM e il cluster di amministrazione ha anche creato una VXLAN di livello 2 con indirizzi IP nella subnet 10.200.0.0/24.

  1. Nella sezione Control plane, inserisci quanto segue nel campo IP 1 del nodo del control plane:

    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, In bundle con 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 del control plane:

    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 CIDR di servizi e pod.

  8. Fai clic su pool predefinito nella barra di navigazione a sinistra.

Crea un node pool

Il cluster utente deve avere almeno un pool di nodi per i nodi worker.

  1. Inserisci il seguente indirizzo IP nel campo Indirizzo nodo 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. La console visualizza i messaggi di stato mentre verifica le impostazioni e crea il cluster.

    Se si verifica un problema con la configurazione, la console visualizza un messaggio di errore che dovrebbe essere sufficientemente chiaro da consentirti di risolvere il problema di configurazione e riprovare 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.

    Una volta creato il cluster, viene visualizzato Stato del cluster: in esecuzione.

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

  3. Accedi al cluster utente:

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

    2. Seleziona Accedi con la tua identità Google.

    3. Fai clic su Login (Accedi).

    Ripeti gli stessi passaggi per accedere al cluster di amministrazione.

gcloud CLI

Per creare il cluster utente:

  1. 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 è il OPERATION_ID dell'operazione a lunga esecuzione.

  2. Per scoprire lo stato dell'operazione, apri un'altra finestra del terminale ed esegui il comando.

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

    Sostituisci OPERATION_ID con la stringa corrispondente dell'output del passaggio precedente.

    La creazione del cluster richiede circa 15 minuti o più. Durante la creazione del cluster, puoi eseguire il comando precedente di tanto in tanto per ottenere lo stato attuale.

    Quando il cluster viene creato, 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 sul comando gcloud container bare-metal clusters create, incluse le descrizioni di ogni flag, consulta la pagina container bare-metal clusters create per la risorsa clusters nel riferimento di gcloud CLI.

Crea un node pool

Dopo aver creato il cluster, puoi creare un pool di nodi per il cluster.

Per creare un pool di nodi:

  1. 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, dovresti visualizzare un output simile al 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 o meno. Quando il pool di nodi viene creato, viene 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].

  2. Vai alla pagina Cluster Kubernetes nella console:

    Vai alla pagina Crea un cluster bare metal

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

  3. Accedi al cluster utente:

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

    2. Seleziona Accedi con la tua identità Google.

    3. 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 un bilanciatore del carico MetalLB integrato. Per saperne di più, consulta la documentazione di riferimento di 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

    L'esempio fornisce un file di variabili di esempio da passare a main.tf.

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

    cp terraform.tfvars.sample terraform.tfvars

  3. Verifica i valori nell'esempio seguente.

    Il seguente file di variabili Terraform, terraform.tfvars.sample, è precompilato con gli indirizzi IP e i valori inseriti nelle sezioni precedenti di questa guida.

    
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"] }
]

    Sostituisci ADMIN_2_EMAIL_ADDRESS con un indirizzo email associato al tuo account Google Cloud o rimuovilo quando modifichi il file delle variabili.

    Per saperne di più sugli argomenti di questo esempio per cui stai impostando le variabili, consulta Riferimento agli argomenti nella documentazione di Terraform per i cluster utente Bare Metal.

  4. Sostituisci i contenuti della tua copia del file delle variabili con i contenuti dell'esempio precedente.

  5. Inizializza e crea il piano Terraform:

    terraform init

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

  6. Esamina la configurazione e apporta le modifiche necessarie:

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

  8. Nella console Google Cloud , vai alla pagina Cluster GKE.

    Vai ai cluster GKE

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

  9. Accedi al cluster utente:

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

    2. Seleziona Accedi con la tua identità Google.

    3. 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 con questa guida.

Elimina il cluster utente

bmctl

  • Per eliminare il cluster utente con bmctl, esegui questo comando dalla 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

  1. Nella console, vai alla pagina Cluster GKE.

    Vai ai cluster GKE

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

  3. Nel riquadro Dettagli, fai clic su Visualizza 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 Elimina.

  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.

gcloud CLI

  • Elimina il cluster:

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

Per informazioni sugli altri flag, consulta gcloud container bare-metal clusters delete.

Terraform

Il comando terraform destroy termina le risorse create quando hai eseguito terraform apply per creare il cluster utente.

  • Esegui questo comando dalla directory in cui si trovano i file di esempio del cluster utente Terraform, come main.tf:

    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 GKE On-Prem:

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

    exit

  5. Elenca tutte le VM con abm nel nome:

    gcloud compute instances list | grep 'abm'

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

    Dopo la verifica, puoi eliminare le VM abm eseguendo il seguente comando:

    gcloud compute instances list --format="value(name)" | \
    grep 'abm' | \
    xargs gcloud compute instances delete --quiet --zone ZONE

  7. Esegui questo comando per eliminare il account di servizio e, quando richiesto, inserisci y:

    gcloud iam service-accounts delete baremetal-gcr@PROJECT_ID.iam.gserviceaccount.com

    Passaggi successivi