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

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.

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

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

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