Prueba clústeres de Anthos alojados en equipos físicos en VM de Compute Engine

En esta página, se muestra cómo probar clústeres de Anthos alojados en equipos físicos en el modo de alta disponibilidad (HA) con máquinas virtuales (VM) que se ejecutan en Compute Engine.

Puedes probar clústeres de Anthos alojados en equipos físicos con rapidez y sin tener que preparar ningún hardware. Completar los pasos de esta página te proporciona un entorno de prueba que se ejecuta en Compute Engine para tu entorno de clústeres de Anthos alojados en equipos físicos.

Para probar clústeres de Anthos alojados en equipos físicos en VM de Compute Engine, completa los siguientes pasos:

  1. Crea seis VM en Compute Engine
  2. Crea una red vxlan entre todas las VM con conectividad L2
  3. Requisitos previos de instalación de clústeres de Anthos alojados en equipos físicos
  4. Implementa un clúster de clústeres de Anthos alojados en equipos físicos
  5. Verifica tu clúster

Antes de comenzar

La implementación requiere los siguientes recursos:

  • Seis VM para implementar clústeres de Anthos alojados en equipos físicos
  • Una estación de trabajo registrada en gcloud con permisos de propietario o editor para tu proyecto

Crea seis VM en Compute Engine

Completa estos pasos para crear las siguientes VM:

  • Una VM de administrador que se usa para implementar clústeres de Anthos alojados en equipos físicos en otras máquinas.
  • Tres VM para los tres nodos del plano de control necesarios a fin de ejecutar el plano de control de clústeres de Anthos alojados en equipos físicos.
  • Se necesitan dos VM para los dos nodos trabajadores a fin de ejecutar cargas de trabajo en el clúster de clústeres de Anthos alojados en equipos físicos.

  1. Crea la cuenta de servicio 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. Otorga permisos adicionales a la cuenta de servicio baremetal-gcr a fin de evitar la necesidad de tener varias cuentas de servicio para diferentes API y servicios:

    gcloud services enable \
    anthos.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

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"

  3. Cree las variables y los arrays necesarios para todos los comandos de esta página:

    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. Usa el siguiente bucle para crear seis 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. Usa el siguiente bucle para verificar que la conexión SSH esté lista en todas las 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 red vxlan con conectividad L2 entre VM

Usa la funcionalidad vxlan estándar de Linux para crear una red que conecte todas las VM con conectividad L2.

El siguiente comando contiene dos bucles que realizan las siguientes acciones:

  1. Establecer una conexión SSH a cada VM
  2. Actualiza e instala los paquetes necesarios

  3. Ejecuta los comandos necesarios para configurar la red 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
        systemctl stop apparmor.service #Anthos clusters on bare metal does not support apparmor
        systemctl disable apparmor.service
EOF
    i=$((i+1))
done

Ahora tienes conectividad L2 dentro de la red 10.200.0.0/24. Las VM tienen las siguientes direcciones IP:

  • Admin VM: 10.200.0.2
  • VM que ejecutan los nodos del plano de control:
    • 10.200.0.3
    • 10.200.0.4
    • 10.200.0.5
  • VM que ejecutan los nodos trabajadores:
    • 10.200.0.6
    • 10.200.0.7

Requisitos previos de instalación de clústeres de Anthos alojados en equipos físicos

Se necesitan las siguientes herramientas en la máquina de administrador antes de instalar clústeres de Anthos alojados en equipos físicos:

  • bmctl
  • kubectl
  • Docker

  1. Ejecuta el siguiente comando para instalar las herramientas necesarias:

    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.6.2/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. Ejecuta los siguientes comandos para asegurarte de que root@10.200.0.x funcione. Los comandos realizan las siguientes tareas:

    1. Generar una clave SSH nueva en la máquina de administrador.
    2. Agregar la clave pública a todas las otras VM de la implementación.
    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

Implementa un clúster de clústeres de Anthos alojados en equipos físicos

El siguiente bloque de código contiene todos los comandos y las opciones de configuración necesarios para completar las siguientes tareas:

  1. Crear el archivo de configuración para el clúster híbrido necesario.
  2. Ejecutar las comprobaciones previas.
  3. Implemente el clúster:
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.6.2
  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
---
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 tu clúster

Puedes encontrar el archivo kubeconfig de tu clúster en la máquina de administrador en el directorio bmctl-workspace. Para verificar tu implementación, completa los siguientes pasos.

  1. Establece una conexión SSH a la estación de trabajo de administrador:

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

  2. Configura la variable de entorno KUBECONFIG con la ruta al archivo de configuración del clúster a fin de ejecutar comandos de kubectl en el clúster.

    export clusterid=cluster-1
export KUBECONFIG=$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig
kubectl get nodes

Accede a tu clúster desde la consola de Google Cloud

Para observar tus cargas de trabajo en clústeres de Anthos alojados en equipos físicos en la consola de Google Cloud, debes acceder a la máquina de administración en la que está almacenado el archivo kubeconfig del clúster.

Para obtener más información, ve a accede a un clúster desde la consola de Google Cloud.

Realiza una limpieza

Enumera todas las VM que tienen abm en su nombre:

gcloud compute instances list | grep 'abm'

Verifica que sea seguro borrar todas las VM que contienen abm en el nombre. Después de verificar, puedes borrar las VM de abm mediante la ejecución del siguiente comando:

gcloud compute instances list | grep 'abm' | awk '{ print $1 }' | \
  xargs gcloud --quiet compute instances delete