Versión 1.6. Esta versión es compatible como se describe en la política de asistencia de la versión de Anthos, y ofrece los últimos parches y actualizaciones de vulnerabilidades de seguridad, exposiciones y problemas que afectan a los clústeres de Anthos en equipos físicos. Consulta las notas de la versión para obtener más detalles. Esta no es la versión más reciente.

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 de 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 recursos siguientes:

  • 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 para descargar bmctl:

    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 SSH esté listo 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 las VM

Usa la funcionalidad estándar de vxlan 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 estas 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 configuraciones 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:

Antes de ejecutar el siguiente bloque de código, asegúrate de haber creado un lugar de trabajo de Cloud Monitoring para tu proyecto.

Crear lugar de trabajo

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: standard
---
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 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 Cloud Console

Para observar tus cargas de trabajo en clústeres de Anthos alojados en equipos físicos en Cloud Console, 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 Cloud Console.

Limpia

Enumera todas las VM que tienen abm en su nombre:

gcloud compute instances list | grep 'abm'

Verifica que estás de acuerdo con 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