Crea un clúster híbrido en las VMs de Compute Engine

En esta página, se muestra cómo configurar un clúster híbrido en modo de alta disponibilidad (HA) con máquinas virtuales (VMs) que se ejecutan en Compute Engine.

Importante: Esta implementación es solo para fines de evaluación. No ejecutes Google Distributed Cloud solo con software en las VMs de Compute Engine en producción. Para la producción, sigue los pasos de nuestra guía de inicio rápido para instalar Google Distributed Cloud solo con software en tu hardware.

Puedes probar el software de Google Distributed Cloud 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 probar Google Distributed Cloud solo con software en VMs de Compute Engine, completa los siguientes pasos:

1. Crea seis VM en Compute Engine
2. Crea una red vxlan entre todas las VMs con conectividad L2
3. Requisitos previos de instalación de Google Distributed Cloud
4. Implementa un clúster híbrido
5. Verifica tu clúster

Antes de comenzar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

1. Toma nota del ID del proyecto, ya que lo necesitarás para establecer una variable de entorno que se usa en las secuencias de comandos y los comandos de esta página. Si seleccionaste un proyecto existente, asegúrate de ser propietario o editor del proyecto.
2. En tu estación de trabajo de Linux, asegúrate de haber instalado la versión más reciente de Google Cloud CLI, la herramienta de línea de comandos para interactuar con Google Cloud. Si ya tienes instalada gcloud CLI, ejecuta el siguiente comando para actualizar sus componentes:

   gcloud components update

   Según cómo se haya instalado gcloud CLI, es posible que veas el siguiente mensaje:

   "You cannot perform this action because the Google Cloud CLI component manager is disabled for this installation. You can run the following command to achieve the same result for this installation:"

   Sigue las instrucciones para copiar y pegar el comando para actualizar los componentes.

Los pasos que se indican en esta guía se toman de la secuencia de comandos de instalación en el repositorio anthos-samples. La sección de Preguntas frecuentes contiene más información sobre cómo personalizar esta secuencia de comandos para trabajar con algunas variaciones populares.

Crea seis VM en Compute Engine

Completa estos pasos para crear las siguientes VM:

• Una VM para la estación de trabajo de administrador Una estación de trabajo de administrador aloja las herramientas de la interfaz de línea de comandos (CLI) y archivos de configuración para aprovisionar clústeres durante la instalación, así como las herramientas de la CLI con el fin de interactuar con los clústeres aprovisionados después de la instalación. La estación de trabajo de administrador tendrá acceso a todos los demás nodos del clúster a través de SSH.
• Tres VMs para los tres nodos del plano de control necesarios para ejecutar el plano de control de Google Distributed Cloud.
• Se necesitan dos VMs para los dos nodos trabajadores a fin de ejecutar cargas de trabajo en el clúster de Google Distributed Cloud.

1. Configura variables de entorno:

   export PROJECT_ID=PROJECT_ID
   export ZONE=ZONE
   export CLUSTER_NAME=CLUSTER_NAME
   export BMCTL_VERSION=1.33.100-gke.89
   

   Para ZONE, puedes usar us-central1-a o cualquiera de las otras zonas de Compute Engine .

2. Ejecuta los siguientes comandos para acceder con tu Cuenta de Google y configura tu proyecto como el predeterminado:

   gcloud auth login
   gcloud config set project $PROJECT_ID
   gcloud config set compute/zone $ZONE
   

3. Crea la cuenta de servicio y la clave baremetal-gcr:

   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

   Nota: Las claves de cuenta de servicio son un riesgo de seguridad si no se administran de forma adecuada. Eres responsable de la seguridad de la clave privada y de otras operaciones que se describen en Prácticas recomendadas para administrar claves de cuentas de servicio. Si no se te permite crear una clave de cuenta de servicio, es posible que la creación de claves de cuentas de servicio esté inhabilitada para tu organización. Para obtener más información, consulta Administra los recursos de la organización con seguridad de forma predeterminada.

   Si adquiriste la clave de la cuenta de servicio de una fuente externa, debes validarla antes de usarla. Para obtener más información, consulta Requisitos de seguridad para las credenciales de fuentes externas.

4. Habilita Google Cloud APIs y servicios:

   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 \
       compute.googleapis.com \
       gkeonprem.googleapis.com \
       iam.googleapis.com \
       kubernetesmetadata.googleapis.com

5. 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 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
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
       --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
       --role="roles/kubernetesmetadata.publisher" \
       --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.viewer" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/serviceusage.serviceUsageViewer" \
     --no-user-output-enabled

6. 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=()

7. Usa el siguiente bucle para crear seis VM:

   for vm in "${VMs[@]}"
   do
       gcloud compute instances create "$vm" \
         --image-family=ubuntu-2204-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

   Este comando crea instancias de VM con los siguientes nombres:

   • abm-ws: Es la VM de la estación de trabajo de administrador.
   • abm-cp1, abm-cp2, abm-cp3: Son las VMs para los nodos del plano de control.
   • abm-w1, abm-w2: Son las VMs para los nodos que ejecutan cargas de trabajo.

8. 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 "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 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. Usa SSH para acceder 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)
           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

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

• Estación de trabajo de VM del administrador 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

Instala los requisitos previos para Google Distributed Cloud

Debes instalar las siguientes herramientas en la estación de trabajo de administrador antes de instalar Google Distributed Cloud:

• bmctl
• kubectl
• Docker

Para instalar las herramientas y prepararte para la instalación de Google Distributed Cloud, haz lo siguiente:

1. Ejecuta los siguientes comandos para descargar la clave de la cuenta de servicio en la estación de trabajo de administrador y, luego, instala las herramientas necesarias:

   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. 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 estación de trabajo 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 híbrido

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)
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 tu clúster

Puedes encontrar el archivo kubeconfig de tu clúster en la estación de trabajo de administrador en el directorio bmctl-workspace de la cuenta raíz. Para verificar tu implementación, completa los siguientes pasos.

1. Usa SSH para acceder a la estación de trabajo de administrador como raíz:

   gcloud compute ssh root@abm-ws --zone ${ZONE}
   

   Puedes ignorar los mensajes sobre la actualización de la VM y completar este instructivo. Si planeas mantener las VMs como entorno de pruebas, te recomendamos que actualices el SO o que cambies a la siguiente versión, como se describe en la documentación de Ubuntu.

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_NAME
   export KUBECONFIG=$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig
   kubectl get nodes
   

3. Establece el contexto actual en una variable de entorno:

   export CONTEXT="$(kubectl config current-context)"
   

4. Ejecuta el siguiente comando de gcloud CLI. Este comando realiza las siguientes acciones:

   • Otorga a tu cuenta de usuario el rol clusterrole/cluster-admin de Kubernetes en el clúster.
   • Configura el clúster para que puedas ejecutar comandos kubectl en tu computadora local sin tener que establecer una conexión SSH a la estación de trabajo de administrador.

   Reemplaza GOOGLE_ACCOUNT_EMAIL por la dirección de correo electrónico asociada a tu cuenta de Google Cloud . Por ejemplo: --users=[e-mail].

   gcloud container fleet memberships generate-gateway-rbac  \
       --membership=CLUSTER_NAME \
       --role=clusterrole/cluster-admin \
       --users=GOOGLE_ACCOUNT_EMAIL \
       --project=PROJECT_ID \
       --kubeconfig=$KUBECONFIG \
       --context=$CONTEXT\
       --apply
   

   El resultado de este comando es similar al siguiente, que se trunca para facilitar la lectura:

   Validating input arguments.
   Specified Cluster Role is: clusterrole/cluster-admin
   Generated RBAC policy is:
   --------------------------------------------
   ...
   
   Applying the generate RBAC policy to cluster with kubeconfig: /root/bmctl-workspace/CLUSTER_NAME/CLUSTER_NAME-kubeconfig, context: CLUSTER_NAME-admin@CLUSTER_NAME
   Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
   Successfully applied the RBAC policy to cluster.
   

5. Cuando termines de explorar, ingresa exit para salir de la estación de trabajo del administrador.

6. Obtén la entrada kubeconfig que puede acceder al clúster a través de la puerta de enlace de Connect.

   gcloud container fleet memberships get-credentials CLUSTER_NAME
   

   El resultado es similar a este:

   Starting to build Gateway kubeconfig...
   Current project_id: PROJECT_ID
   A new kubeconfig entry "connectgateway_PROJECT_ID_global_CLUSTER_NAME" has been generated and set as the current context.
   

7. Ahora puedes ejecutar comandos de kubectl a través de la puerta de enlace de conexión:

   kubectl get nodes
   kubectl get namespaces
   

Accede a tu clúster desde la Google Cloud consola

Para observar tus cargas de trabajo en el clúster en la consola de Google Cloud , debes acceder al clúster. Antes de acceder a la consola por primera vez, debes configurar un método de autenticación. El método de autenticación más sencillo de configurar es la identidad de Google. Este método de autenticación te permite acceder con la dirección de correo electrónico asociada a tu cuenta deGoogle Cloud .

El comando gcloud container fleet memberships generate-gateway-rbac que ejecutaste en la sección anterior configura el clúster para que puedas acceder con tu identidad de Google.

1. En la consola de Google Cloud , ve a la página Clústeres de GKE.

   Ir a los clústeres de GKE

2. Haz clic en Acciones junto al clúster registrado y, luego, en Acceder.

3. Selecciona Usa tu identidad de Google para acceder

4. Haga clic en Acceder.

Limpia

1. Conéctate a la estación de trabajo de administrador para restablecer las VMs 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@abm-ws --zone ${ZONE} << EOF
   set -x
   export clusterid=CLUSTER_NAME
   bmctl reset -c \$clusterid
   EOF
   

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