Crea un cluster ibrido Anthos on bare metal sulle VM di Compute Engine

Version 1.13 

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

Questa pagina mostra come configurare un cluster ibrido Anthos on bare metal in modalità ad alta disponibilità utilizzando macchine virtuali (VM) su Compute Engine.

Importante: questo deployment è solo a scopo di valutazione. Non eseguire Anthos clusters on bare metal sulle VM di Compute Engine in produzione. Per la produzione, segui i passaggi descritti nella nostra Guida rapida per installare Anthos clusters on bare metal sul tuo hardware.

Puoi provare Anthos clusters on bare metal rapidamente e senza dover preparare alcun hardware. Il completamento dei passaggi in questa pagina fornisce un ambiente di test di Anthos clusters on bare metal in esecuzione su Compute Engine.

Per provare Anthos clusters on bare metal sulle VM di Compute Engine, completa i seguenti passaggi:

1. Crea sei VM in Compute Engine
2. Crea una rete vxlan tra tutte le VM con connettività L2
3. Prerequisiti per l'installazione di Anthos clusters on bare metal

4. Esegui il deployment di un cluster Anthos on bare metal

5. Verifica il 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 negli script e nei comandi in questa pagina. Se hai selezionato un progetto esistente, assicurati di essere un proprietario o un editor del progetto.
7. Sulla workstation Linux, assicurati di aver installato la versione più recente di Google Cloud CLI, lo strumento a riga di comando per interagire con Google Cloud. Se hai già installato gcloud CLI, aggiorna i componenti eseguendo questo comando:

   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.

I passaggi di questa guida sono ricavati dallo script di installazione nel repository anthos-samples. La sezione Domande frequenti contiene ulteriori informazioni su come personalizzare questo script per utilizzarlo con alcune varianti popolari.

Crea sei VM in Compute Engine

Completa questi passaggi per creare le seguenti VM:

• Una VM per la workstation di amministrazione. Una 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, nonché strumenti di interfaccia a riga di comando per interagire con i cluster di cui è stato eseguito il provisioning dopo l'installazione. La workstation di amministrazione avrà accesso a tutti gli altri nodi del cluster tramite SSH.
• Tre VM per i tre nodi del piano di controllo necessari per eseguire il cluster di controllo Anthos clusters on bare metal.
• Due VM per i due nodi worker necessari per eseguire i carichi di lavoro sul cluster Anthos clusters on bare metal.

1. Configura le variabili di ambiente:

   export PROJECT_ID=PROJECT_ID
   export ZONE=ZONE
   export CLUSTER_NAME=CLUSTER_NAME
   export BMCTL_VERSION=1.13.10
   

   Per ZONE, puoi utilizzare us-central1-a o una qualsiasi delle altre zone di Compute Engine .

2. Esegui questi comandi per accedere con il tuo Account Google e impostare il progetto come predefinito:

   gcloud auth login
   gcloud config set project $PROJECT_ID
   gcloud config set compute/zone $ZONE
   

3. Crea l'account di servizio baremetal-gcr:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Visualizza su GitHub

   gcloud iam service-accounts create baremetal-gcr
   
   gcloud iam service-accounts keys create bm-gcr.json \
       --iam-account=baremetal-gcr@"${PROJECT_ID}".iam.gserviceaccount.com

4. Abilita le API e i servizi di Google Cloud:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Visualizza su GitHub

   gcloud services enable \
       anthos.googleapis.com \
       anthosaudit.googleapis.com \
       anthosgke.googleapis.com \
       cloudresourcemanager.googleapis.com \
       connectgateway.googleapis.com \
       container.googleapis.com \
       gkeconnect.googleapis.com \
       gkehub.googleapis.com \
       serviceusage.googleapis.com \
       stackdriver.googleapis.com \
       monitoring.googleapis.com \
       logging.googleapis.com \
       opsconfigmonitoring.googleapis.com

5. Concedi all'account di servizio baremetal-gcr autorizzazioni aggiuntive per evitare di aver bisogno di più account di servizio per API e servizi diversi:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Visualizza su GitHub

   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.connect" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.admin" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/logging.logWriter" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.dashboardEditor" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/stackdriver.resourceMetadata.writer" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/opsconfigmonitoring.resourceMetadata.writer" \
     --no-user-output-enabled

6. Crea le variabili e gli array necessari per tutti i comandi di questa pagina:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Visualizza su GitHub

   MACHINE_TYPE=n1-standard-8
   VM_PREFIX=abm
   VM_WS=$VM_PREFIX-ws
   VM_CP1=$VM_PREFIX-cp1
   VM_CP2=$VM_PREFIX-cp2
   VM_CP3=$VM_PREFIX-cp3
   VM_W1=$VM_PREFIX-w1
   VM_W2=$VM_PREFIX-w2
   declare -a VMs=("$VM_WS" "$VM_CP1" "$VM_CP2" "$VM_CP3" "$VM_W1" "$VM_W2")
   declare -a IPs=()

7. Utilizza il loop seguente per creare sei VM:

   Nota: se intendi eseguire il deployment delle VM utilizzando il runtime VM di Anthos, per migliorare le prestazioni abilita la virtualizzazione hardware aggiungendo --enable-nested-virtualization al comando gcloud seguente.
   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Visualizza su GitHub

   for vm in "${VMs[@]}"
   do
       gcloud compute instances create "$vm" \
         --image-family=ubuntu-2004-lts --image-project=ubuntu-os-cloud \
         --zone="${ZONE}" \
         --boot-disk-size 200G \
         --boot-disk-type pd-ssd \
         --can-ip-forward \
         --network default \
         --tags http-server,https-server \
         --min-cpu-platform "Intel Haswell" \
         --enable-nested-virtualization \
         --scopes cloud-platform \
         --machine-type "$MACHINE_TYPE" \
         --metadata "cluster_id=${CLUSTER_NAME},bmctl_version=${BMCTL_VERSION}"
       IP=$(gcloud compute instances describe "$vm" --zone "${ZONE}" \
            --format='get(networkInterfaces[0].networkIP)')
       IPs+=("$IP")
   done

   Questo comando crea istanze VM con i nomi seguenti:

   • abm-ws: la VM per la workstation di amministrazione.
   • abm-cp1, abm-cp2, abm-cp3: le VM per i nodi del piano di controllo.
   • abm-w1, abm-w2: le VM per i nodi che eseguono carichi di lavoro.

8. Utilizza il seguente loop per verificare che SSH sia pronto su tutte le VM:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Visualizza su GitHub

   for vm in "${VMs[@]}"
   do
       while ! gcloud compute ssh root@"$vm" --zone "${ZONE}" --command "printf 'SSH to $vm succeeded\n'"
       do
           printf "Trying to SSH into %s failed. Sleeping for 5 seconds. zzzZZzzZZ" "$vm"
           sleep  5
       done
   done

Crea una rete vxlan con connettività L2 tra le VM

Utilizza la funzionalità vxlan standard di Linux per creare una rete che collega tutte le VM con connettività L2.

Il comando seguente contiene due loop che eseguono le seguenti azioni:

1. SSH in ogni VM.
2. Aggiorna e installa i pacchetti richiesti.

3. Esegui i comandi richiesti per configurare la rete con vxlan.

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Visualizza su GitHub

   i=2 # We start from 10.200.0.2/24
   for vm in "${VMs[@]}"
   do
       gcloud compute ssh root@"$vm" --zone "${ZONE}" << EOF
           apt-get -qq update > /dev/null
           apt-get -qq install -y jq > /dev/null
           set -x
           ip link add vxlan0 type vxlan id 42 dev ens4 dstport 0
           current_ip=\$(ip --json a show dev ens4 | jq '.[0].addr_info[0].local' -r)
           printf "VM IP address is: \$current_ip"
           for ip in ${IPs[@]}; do
               if [ "\$ip" != "\$current_ip" ]; then
                   bridge fdb append to 00:00:00:00:00:00 dst \$ip dev vxlan0
               fi
           done
           ip addr add 10.200.0.$i/24 dev vxlan0
           ip link set up dev vxlan0
   
   EOF
       i=$((i+1))
   done

Ora hai una connettività L2 nella rete 10.200.0.0/24. Le VM hanno i seguenti indirizzi IP:

• VM workstation di amministrazione: 10.200.0.2
• VM che eseguono i nodi del piano di controllo:
  • 10.200.0.3
  • 10.200.0.4
  • 10.200.0.5
• VM che eseguono i nodi worker:
  • 10.200.0.6
  • 10.200.0.7

Installa i prerequisiti per Anthos clusters on bare metal

Prima di installare Anthos clusters on bare metal, devi installare i seguenti strumenti sulla workstation di amministrazione:

• bmctl
• kubectl
• Docker

Per installare gli strumenti e prepararti per l'installazione di Anthos clusters on bare metal:

1. Esegui questi comandi per scaricare la chiave dell'account di servizio nella workstation di amministrazione e installare gli strumenti richiesti:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Visualizza su GitHub

   gcloud compute ssh root@$VM_WS --zone "${ZONE}" << EOF
   set -x
   
   export PROJECT_ID=\$(gcloud config get-value project)
   BMCTL_VERSION=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/bmctl_version -H "Metadata-Flavor: Google")
   export BMCTL_VERSION
   
   gcloud iam service-accounts keys create bm-gcr.json \
     --iam-account=baremetal-gcr@\${PROJECT_ID}.iam.gserviceaccount.com
   
   curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl"
   
   chmod +x kubectl
   mv kubectl /usr/local/sbin/
   mkdir baremetal && cd baremetal
   gsutil cp gs://anthos-baremetal-release/bmctl/$BMCTL_VERSION/linux-amd64/bmctl .
   chmod a+x bmctl
   mv bmctl /usr/local/sbin/
   
   cd ~
   printf "Installing docker"
   curl -fsSL https://get.docker.com -o get-docker.sh
   sh get-docker.sh
   EOF

2. Esegui i comandi seguenti per assicurarti che root@10.200.0.x funzioni. I comandi eseguono queste attività:

   1. Genera una nuova chiave SSH sulla workstation di amministrazione.
   2. Aggiungi la chiave pubblica a tutte le altre VM nel deployment.
   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Visualizza su GitHub

   gcloud compute ssh root@$VM_WS --zone "${ZONE}" << EOF
   set -x
   ssh-keygen -t rsa -N "" -f /root/.ssh/id_rsa
   sed 's/ssh-rsa/root:ssh-rsa/' ~/.ssh/id_rsa.pub > ssh-metadata
   for vm in ${VMs[@]}
   do
       gcloud compute instances add-metadata \$vm --zone ${ZONE} --metadata-from-file ssh-keys=ssh-metadata
   done
   EOF

Esegui il deployment di un cluster ibrido Anthos on bare metal

Il blocco di codice seguente contiene tutti i comandi e le configurazioni necessari per completare le attività seguenti:

1. Crea il file di configurazione per il cluster ibrido necessario.
2. Esegui i controlli preflight.
3. Eseguire il deployment del cluster.

anthos-bm-gcp-bash/install_hybrid_cluster.sh

Visualizza su GitHub

gcloud compute ssh root@$VM_WS --zone "${ZONE}" <<EOF
set -x
export PROJECT_ID=$(gcloud config get-value project)
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 CLUSTER_NAME
export BMCTL_VERSION
bmctl create config -c \$CLUSTER_NAME
cat > bmctl-workspace/\$CLUSTER_NAME/\$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-\$CLUSTER_NAME
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: \$CLUSTER_NAME
  namespace: cluster-\$CLUSTER_NAME
spec:
  type: hybrid
  anthosBareMetalVersion: \$BMCTL_VERSION
  gkeConnect:
    projectID: \$PROJECT_ID
  controlPlane:
    nodePoolSpec:
      clusterName: \$CLUSTER_NAME
      nodes:
      - address: 10.200.0.3
      - address: 10.200.0.4
      - address: 10.200.0.5
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 172.26.232.0/24
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: 10.200.0.49
      ingressVIP: 10.200.0.50
    addressPools:
    - name: pool1
      addresses:
      - 10.200.0.50-10.200.0.70
  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
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-\$CLUSTER_NAME
spec:
  clusterName: \$CLUSTER_NAME
  nodes:
  - address: 10.200.0.6
  - address: 10.200.0.7
EOB

bmctl create cluster -c \$CLUSTER_NAME
EOF

Verifica il cluster

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

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 voler 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=CLUSTER_NAME
   export KUBECONFIG=$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig
   kubectl get nodes
   

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

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

4. Esegui questo comando gcloud. Il seguente comando:

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

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

   gcloud container fleet memberships generate-gateway-rbac  \
       --membership=CLUSTER_NAME \
       --role=clusterrole/cluster-admin \
       --users=GOOGLE_ACCOUNT_EMAIL \
       --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/CLUSTER_NAME/CLUSTER_NAME-kubeconfig, context: CLUSTER_NAME-admin@CLUSTER_NAME
   Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
   Successfully applied the RBAC policy to cluster.
   

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

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

   gcloud container fleet memberships get-credentials 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_CLUSTER_NAME" has been generated and set as the current context.
   

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

   kubectl get nodes
   kubectl get namespaces
   

Accedi al tuo cluster dalla console Google Cloud

Per osservare i tuoi carichi di lavoro su Anthos clusters on bare metal nella console Google Cloud, devi accedere al cluster. Prima di accedere alla console per la prima volta, devi configurare un metodo di autenticazione. Il metodo di autenticazione più semplice da configurare è l'identità Google. Questo metodo di autenticazione ti consente di accedere utilizzando l'indirizzo email associato al tuo account Google Cloud.

Il comando gcloud container fleet memberships generate-gateway-rbac che hai eseguito nella sezione precedente configura il cluster in modo da poter accedere con la tua identità Google.

1. Nella console Google Cloud:

   • Nella pagina Cluster GKE, fai clic su Azioni accanto al cluster registrato, quindi su Accedi.

     Vai ai cluster GKE

   oppure:

   • Nella pagina Cluster di Anthos, seleziona il cluster a cui vuoi accedere nell'elenco dei cluster, quindi fai clic su Accedi nel riquadro delle informazioni visualizzato.

     Vai ai cluster Anthos

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

3. Fai clic su Accedi.

Esegui la pulizia

1. Connettiti alla workstation di amministrazione per reimpostare lo stato delle VM del cluster prima dell'installazione e annullare la registrazione del cluster dal progetto Google Cloud:

   gcloud compute ssh root@abm-ws --zone ${ZONE} << EOF
   set -x
   export clusterid=CLUSTER_NAME
   bmctl reset -c \$clusterid
   EOF
   

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

   gcloud compute instances list | grep 'abm'
   

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

   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