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

Version 1.11 (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 le macchine virtuali (VM) in esecuzione su Compute Engine.

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

Puoi provare Cluster Anthos on bare metal in modo rapido e senza dover preparare hardware. Il completamento dei passaggi in questa pagina fornisce un ambiente di test di lavoro 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 seguenti passaggi:

1. Crea sei VM in Compute Engine
2. Crea una rete vxlan tra tutte le VM con connettività L2
3. Installa i prerequisiti per Cluster Anthos on bare metal
4. Esegui il deployment di un cluster Anthos su Bare Metal
5. Verifica il cluster

Prima di iniziare

Il deployment richiede le seguenti risorse:

• Sei VM per eseguire il deployment di cluster Anthos su Bare Metal
• Una workstation collegata a gcloud con le autorizzazioni di proprietario per il progetto.

I passaggi di questa guida sono tratti dallo script di installazione nel repository anthos-samples. La sezione Domande frequenti contiene ulteriori informazioni su come personalizzare questo script in modo che funzioni con alcune varianti più comuni.

Nota: tutti i comandi vengono eseguiti su una macchina a cui hai 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 amministrativa 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 necessarie per eseguire carichi di lavoro sul cluster Anthos su Bare Metal.

1. Imposta le variabili di ambiente:

   export PROJECT_ID=PROJECT_ID
   export ZONE=ZONE
   

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

   gcloud auth login
   gcloud config set project $PROJECT_ID
   

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 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 richiedere 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 presenti in 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. Usa 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 dell'hardware aggiungendo --enable-nested-virtualization al comando gcloud precedente.
   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" \
         --scopes cloud-platform \
         --machine-type "$MACHINE_TYPE"
       IP=$(gcloud compute instances describe "$vm" --zone "${ZONE}" \
            --format='get(networkInterfaces[0].networkIP)')
       IPs+=("$IP")
   done

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

Usa la funzionalità standard vxlan di Linux per creare una rete che connette 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 necessari

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 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 Cluster Anthos on bare metal

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

• bmctl
• kubectl
• Docker

1. Esegui questo comando per installare gli strumenti necessari:

   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)
   
   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.13.1/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 questi comandi per assicurarti che root@10.200.0.x funzioni. I comandi eseguono queste attività:

   1. Genera una nuova chiave SSH nella macchina 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 Anthos su 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.

Nota: aggiorna la variabile CLUSTER_NAME nel blocco di codice che segue e copia l'intero blocco di codice nella console. Se copi solo parti, la creazione del cluster non riuscirà.

gcloud compute ssh root@$VM_WS --zone ${ZONE} << EOF
set -x
export PROJECT_ID=$(gcloud config get-value project)
export clusterid=CLUSTER_NAME
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.11.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
---
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 tuo cluster nella macchina di amministrazione nella directory bmctl-workspace. Per verificare il tuo deployment, completa i seguenti passaggi.

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

Accedi al tuo cluster dalla console Google Cloud

Per osservare i carichi di lavoro su Cluster Anthos on bare metal nella console Google Cloud, devi accedere alla macchina di amministrazione in cui è archiviato il file kubeconfig del cluster.

Per saperne di più, vai a Accesso a un cluster dalla console Google Cloud.

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 tuo progetto Google Cloud:

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

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

   gcloud compute instances list | grep 'abm'
   

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

   Dopo aver eseguito la verifica, puoi eliminare abm VM eseguendo questo comando:

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