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

Version 1.8 (unsupported)

• Más reciente
• Versión 1.16
• Versiones anteriores (no admitidas)

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.

Importante: Esta implementación es solo para fines de evaluación. No ejecutes clústeres de Anthos alojados en equipos físicos en las VM de Compute Engine en producción. Para implementar clústeres de Anthos en equipos físicos en producción, sigue los pasos de nuestra guía de inicio rápido.

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

Nota: Todos los comandos se ejecutan en una máquina que accede a gcloud con las credenciales de propietario o editor del 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 \
       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. 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
   

   Nota: Si pretendes implementar VM con el entorno de ejecución de VM de Anthos, para obtener un mejor rendimiento, habilita la virtualización de hardware agregando --enable-nested-virtualization al comando gcloud anterior.

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
   
   EOF
       i=$((i+1))
   done
   

   Nota: A partir de los clústeres de Anthos en equipos físicos 1.8.2, no es necesario que inhabilites AppArmor. Si usas versiones anteriores, agrega los siguientes comandos a la lista anterior:

       systemctl stop apparmor.service
       systemctl disable apparmor.service
   

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.8.9/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:

Nota: Copia todo el bloque de código en la consola. Si copias solo partes de él, no se realizará la creación del 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.8.9
  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 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
   

Nota: Reemplaza $clusterid por el nombre real de tu clúster. El comando usa cluster-1 porque es el valor establecido en el bloque de código anterior cuando creaste el clúster.

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

1. Conéctate a la máquina de administrador para restablecer las VM del clúster al estado que tenían antes de la instalación y cancelar el registro del clúster de tu proyecto de Google Cloud:

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

   Nota: Reemplaza cluster-1 por el nombre real de tu clúster. El comando usa cluster-1 porque es el valor que se estableció en el bloque de código anterior cuando creaste el clúster.

2. Enumera todas las VM que tienen abm en su nombre:

   gcloud compute instances list | grep 'abm'
   

3. 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 --format="value(name)" | grep 'abm'  | xargs gcloud \
       --quiet compute instances delete