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

Questa pagina mostra come provare Anthos clusters on bare metal in modalità ad alta disponibilità utilizzando macchine virtuali (VM) in esecuzione su Compute Engine.

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

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 clusters on bare metal
  5. Verifica il cluster

Prima di iniziare

Il deployment richiede le seguenti risorse:

  • Sei VM per il deployment di Anthos clusters on bare metal
  • Una workstation a cui è stato eseguito l'accesso a gcloud con le autorizzazioni Proprietario per il progetto.

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 di amministrazione utilizzata per il deployment di Anthos clusters on bare metal nelle altre macchine.
  • 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.12.9

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

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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

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

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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 
    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 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 sulla macchina di amministrazione, sono necessari i seguenti strumenti:

  • bmctl
  • kubectl
  • Docker

  1. Esegui questo comando per installare gli strumenti necessari:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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 nella macchina di amministrazione.
    2. Aggiungi la chiave pubblica a tutte le altre VM nel deployment.
    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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 clusters 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 
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 nella macchina di amministrazione nella directory bmctl-workspace. Per verificare il tuo deployment, completa i seguenti passaggi.

  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_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 Anthos clusters 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 Accedere 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 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