Prova di Cluster Anthos su Bare Metal sulle VM di Compute Engine

Version 1.9 (unsupported)

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

Questa pagina mostra come provare i cluster Anthos su Bare Metal in modalità ad alta disponibilità (HA) utilizzando macchine virtuali (VM) in esecuzione su Compute Engine.

Importante: questo deployment è solo a scopo di valutazione. Non eseguire cluster Anthos su Bare Metal sulle VM di Compute Engine in produzione. Per eseguire il deployment dei cluster Anthos su Bare Metal in produzione, segui i passaggi indicati nella nostra guida rapida.

Puoi provare i cluster Anthos su Bare Metal rapidamente e senza dover preparare alcun hardware. Il completamento dei passaggi in questa pagina fornisce l'ambiente di test funzionante in esecuzione su Compute Engine per i tuoi cluster Anthos su ambiente Bare Metal.

Per provare i cluster Anthos su Bare Metal sulle VM di Compute Engine, completa i passaggi seguenti:

1. Crea sei VM in Compute Engine
2. Crea una rete vxlan tra tutte le VM con connettività L2
3. Prerequisiti per l'installazione dei cluster Anthos su Bare Metal
4. Esegui il deployment di un cluster Anthos su cluster Bare Metal
5. Verifica il tuo cluster

Prima di iniziare

Il deployment richiede le seguenti risorse:

• Sei VM per eseguire il deployment di cluster Anthos su Bare Metal
• Una workstation a cui è stato eseguito l'accesso a gcloud con autorizzazioni di proprietario o editor per il progetto

Nota: tutti i comandi vengono eseguiti su una macchina su cui è stato eseguito l'accesso in gcloud con le credenziali del proprietario o dell'editor del progetto.

Crea sei VM in Compute Engine

Completa questi passaggi per creare le seguenti VM:

• Una VM di amministrazione utilizzata per eseguire il deployment di cluster Anthos su Bare Metal sulle altre macchine.
• Tre VM per i tre nodi del piano di controllo necessari per eseguire i cluster Anthos sul piano di controllo Bare Metal.
• Due VM per i due nodi worker necessari per eseguire i carichi di lavoro sui cluster Anthos su cluster Bare Metal.

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

   export PROJECT_ID=$(gcloud config get-value project)
   export ZONE=us-central1-a
   
   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
   

2. Concedi all'account di servizio baremetal-gcr ulteriori autorizzazioni per evitare la necessità di più account di servizio per API e servizi diversi:

   gcloud services enable \
       anthos.googleapis.com \
       anthosaudit.googleapis.com \
       anthosgke.googleapis.com \
       cloudresourcemanager.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
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.connect"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.admin"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/logging.logWriter"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.dashboardEditor"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/stackdriver.resourceMetadata.writer"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/opsconfigmonitoring.resourceMetadata.writer"
   

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

   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=()
   

4. Utilizza il loop seguente per creare sei VM:

   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" \
                 --scopes cloud-platform \
                 --machine-type $MACHINE_TYPE
       IP=$(gcloud compute instances describe $vm --zone ${ZONE} \
            --format='get(networkInterfaces[0].networkIP)')
       IPs+=("$IP")
   done
   

   Nota: se intendi eseguire il deployment delle VM utilizzando il runtime VM VM, per migliorare le prestazioni abilita la virtualizzazione hardware aggiungendo --enable-nested-virtualization al comando gcloud precedente.

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

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

Crea una rete vxlan con connettività L2 tra le VM

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

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

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

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

   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)
           echo "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
   

   Nota: a partire dai cluster Anthos su Bare Metal 1.8.2, non devi disattivare AppArmor. Se utilizzi release precedenti, aggiungi i seguenti comandi all'elenco precedente:

       systemctl stop apparmor.service
       systemctl disable apparmor.service
   

Ora hai la connettività L2 all'interno della rete 10.200.0.0/24. Le VM hanno i seguenti indirizzi IP:

• VM amministratore: 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 i cluster Anthos su Bare Metal

I seguenti strumenti sono necessari sulla macchina di amministrazione prima di installare i cluster Anthos su Bare Metal:

• bmctl
• kubectl
• Docker

1. Esegui il comando seguente per installare gli strumenti necessari:

   gcloud compute ssh root@$VM_WS --zone ${ZONE} << EOF
   set -x
   
   export PROJECT_ID=\$(gcloud config get-value project)
   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/1.9.8/linux-amd64/bmctl .
   chmod a+x bmctl
   mv bmctl /usr/local/sbin/
   
   cd ~
   echo "Installing docker"
   curl -fsSL https://get.docker.com -o get-docker.sh
   sh get-docker.sh
   EOF
   

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

   1. Generare una nuova chiave SSH nella macchina di amministrazione.
   2. Aggiungi la chiave pubblica a tutte le altre VM nel deployment.

   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 Anthos su cluster 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 preliminari.
3. Eseguire il deployment del cluster.

Nota: copia l'intero blocco di codice nella console. Se ne copi solo parti, la creazione del cluster non avrà esito positivo.

gcloud compute ssh root@$VM_WS --zone ${ZONE} << EOF
set -x
export PROJECT_ID=$(gcloud config get-value project)
export clusterid=cluster-1
bmctl create config -c \$clusterid
cat > bmctl-workspace/\$clusterid/\$clusterid.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-\$clusterid
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: \$clusterid
  namespace: cluster-\$clusterid
spec:
  type: hybrid
  anthosBareMetalVersion: 1.9.8
  gkeConnect:
    projectID: \$PROJECT_ID
  controlPlane:
    nodePoolSpec:
      clusterName: \$clusterid
      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
    containerRuntime: containerd
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-\$clusterid
spec:
  clusterName: \$clusterid
  nodes:
  - address: 10.200.0.6
  - address: 10.200.0.7
EOB

bmctl create cluster -c \$clusterid
EOF

Verifica il cluster

Puoi trovare il file kubeconfig del cluster nella macchina di amministrazione nella directory bmctl-workspace. Per verificare il deployment, completa i passaggi seguenti.

1. Accedi tramite SSH alla workstation di amministrazione:

   gcloud compute ssh root@$VM_WS --zone ${ZONE}
   

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

Nota: sostituisci $clusterid con il nome effettivo del tuo cluster. Il comando utilizza cluster-1 perché è il valore impostato nel blocco di codice precedente quando hai creato il cluster.

Accedi al cluster da Google Cloud Console

Per osservare i carichi di lavoro su cluster Anthos su Bare Metal in Google Cloud Console, devi accedere alla macchina di amministrazione in cui è archiviato il file kubeconfig del cluster.

Per saperne di più, vai a Accedere a un cluster da Google Cloud Console.

Esegui la pulizia

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

   gcloud compute ssh root@$VM_WS --zone ${ZONE} << EOF
   set -x
   export clusterid=cluster-1
   bmctl reset -c \$clusterid
   EOF
   

   Nota: sostituisci cluster-1 con il nome effettivo del cluster. Il comando utilizza cluster-1 perché questo è il valore impostato nel blocco di codice precedente quando hai creato il cluster.

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

   gcloud compute instances list | grep 'abm'
   

3. Verifica che non ci siano problemi nel eliminare tutte le VM che contengono abm nel nome.

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

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