Crea clústeres básicos

Version 1.15 

• Versión más reciente
• Versión 1.16
• Versiones anteriores (no compatibles)

Esta es la segunda parte de una guía en la que se explica una pequeña instalación de prueba de concepto de GKE en VMware. La primera parte es Configura una infraestructura mínima, que muestra cómo planificar tus direcciones IP y configurar la infraestructura de vSphere y Google Cloud necesaria para la implementación. En este documento, se basa en la configuración y la planificación que realizaste en la sección anterior, y se muestra cómo crear una estación de trabajo de administrador, un clúster de administrador y un clúster de usuario en el entorno de vSphere con plantillas simples que puedes completar aquí en este documento. Luego, puedes implementar una aplicación.

Al igual que con la configuración de la infraestructura de esta instalación simple, es posible que los clústeres que configures mediante este documento no sean adecuados para tus necesidades de producción y casos de uso reales. Si deseas obtener más información, instrucciones y prácticas recomendadas para las instalaciones de producción, consulta las guías de instalación.

Antes de comenzar

1. Asegúrate de haber configurado los entornos de vSphere y Google Cloud como se describe en Configura la infraestructura mínima.

2. Si deseas usar Terraform para crear el clúster de usuario, necesitas Terraform en tu estación de trabajo de administrador o en otra computadora.

Descripción general del procedimiento

Estos son los pasos principales que implica esta configuración:

1. Accede a Google Cloud CLI con una cuenta que tenga los permisos necesarios para crear cuentas de servicio.

2. Recopila información que necesites para configurar GKE en VMware, incluidos tu nombre de usuario y contraseña de vCenter, y las direcciones IP que preparaste en la sección anterior.

3. Crea una estación de trabajo de administrador con los recursos y las herramientas que necesitas para crear clústeres de administrador y de usuario, incluidas las cuentas de servicio adicionales que necesitas para finalizar la configuración.

4. Crea un clúster de administrador para administrar y actualizar el clúster de usuario.

5. Crea un clúster de usuario para ejecutar tus cargas de trabajo.

1. Accede a Google Cloud CLI

Configurar GKE en VMware requiere varias cuentas de servicio con permisos diferentes. Si bien debes crear la cuenta de servicio de acceso a los componentes de forma manual, la herramienta de línea de comandos de gkeadm puede crear y configurar las cuentas restantes como parte de la creación de la estación de trabajo de administrador. Sin embargo, debes acceder a Google Cloud CLI con una cuenta que tenga los permisos necesarios para crear y configurar cuentas de servicio, ya que gkeadm usa tu propiedad actual account de gcloud CLI cuando realiza esta configuración.

1. Accede a gcloud CLI. Puedes usar cualquier Cuenta de Google, pero esta debe tener los permisos necesarios. Si seguiste la parte anterior de esta guía, es probable que ya hayas accedido con una cuenta adecuada para crear tu cuenta de servicio de acceso a los componentes.

   gcloud auth login
   

2. Verifica que la propiedad account de gcloud CLI esté configurada de forma correcta:

   gcloud config list
   

   En el resultado, se muestra el valor de la propiedad account de tu SDK. Por ejemplo:

   [core]
   account = [e-mail]
   disable_usage_reporting = False
   Your active configuration is: [default]
   

3. Asegúrate de tener instalados los componentes más recientes de gcloud CLI:

   gcloud components update
   

   Según cómo instalaste gcloud CLI, es posible que veas el siguiente mensaje: “No puedes realizar esta acción porque el administrador de componentes de Google Cloud CLI está inhabilitado para esta instalación. Puedes ejecutar el siguiente comando para obtener el mismo resultado en esta instalación:" Sigue las instrucciones para copiar y pegar el comando y actualizar los componentes.

2. Recopila información

Usa la información que preparaste en Configura la infraestructura mínima para editar los marcadores de posición en la siguiente tabla:

Precaución: Los marcadores de posición editables de esta tabla no son persistentes. Todos los valores que ingreses en la tabla se restablecerán si cierras o actualizas esta pestaña del navegador, o si sales de esta página. Si los marcadores de posición de la tabla no se pueden editar, es posible que debas actualizar esta página.

Detalles de vSphere
Es el nombre de usuario de tu cuenta de vCenter	USERNAME
Es la contraseña de tu cuenta de vCenter	PASSWORD
La dirección de vCenter Server	ADDRESS
Es la ruta de acceso al certificado de AC raíz de vCenter Server en la máquina que usarás para crear tu estación de trabajo de administrador.	CA_CERT_PATH
El nombre de tu centro de datos de vSphere	DATA_CENTER
El nombre del clúster de vSphere	VSPHERE_CLUSTER
Es el nombre o la ruta de acceso del grupo de recursos de vSphere. Para obtener más información, consulta vcenter.resourcePool.	RESOURCE_POOL
El nombre del almacén de datos de vSphere	DATASTORE
El nombre de tu red de vSphere	NETWORK
Direcciones IP
Una dirección IP para la estación de trabajo de administrador	ADMIN_WS_IP
Cuatro direcciones IP para los nodos del clúster de administrador Esto incluye una dirección para un nodo adicional que se puede usar durante la actualización.	ADMIN_NODE_IP_1 ADMIN_NODE_IP_2 ADMIN_NODE_IP_3 ADMIN_NODE_IP_4
Una dirección IP para el nodo del plano de control en el clúster de usuario.	USER_CONTROL_PLANE_NODE_IP
Cuatro direcciones IP para los nodos del clúster de usuario. Esto incluye una dirección para un nodo adicional que se puede usar durante la actualización.	USER_NODE_IP_1 USER_NODE_IP_2 USER_NODE_IP_3 USER_NODE_IP_4
Una dirección IP virtual (VIP) para el servidor de la API de Kubernetes del clúster de administrador	ADMIN_CONTROL_PLANE_VIP
Una VIP para el servidor de la API de Kubernetes del clúster de usuario	USER_CONTROL_PLANE_VIP
Una VIP de Ingress para el clúster de usuario	USER_INGRESS_VIP
Dos VIP para los objetos Service de tipo LoadBalancer en tu clúster de usuario.	SERVICE_VIP_1 SERVICE_VIP_2
La dirección IP de un servidor DNS, al que se puede acceder desde la estación de trabajo de administrador y los nodos del clúster	DNS_SERVER_IP
La dirección IP de un servidor NTP al que se puede acceder desde la estación de trabajo de administrador y los nodos del clúster	NTP_SERVER_IP
La dirección IP de la puerta de enlace predeterminada de la subred que tiene la estación de trabajo de administrador y los nodos del clúster	DEFAULT_GATEWAY_IP
La máscara de red de la subred que tiene la estación de trabajo de administrador y los nodos del clúster Ejemplo: 255.255.255.0	NETMASK
Si la red está detrás de un servidor proxy, la URL del servidor proxy. Para obtener más información, consulta proxy. Si es necesario, complétala de forma manual en el archivo de configuración de la estación de trabajo de administrador.	PROXY_URL
Rangos CIDR para objetos Service y Pods
El clúster de administrador y el de usuario necesitan un rango de CIDR para los Services y un rango de CIDR para los Pods. Usa los siguientes valores prepropagados, a menos que necesites cambiarlos para evitar la superposición con otros elementos de tu red:
Un rango de CIDR para los objetos Service en el clúster de administrador	10.96.232.0/24
Un rango CIDR para los Pods del clúster de administrador	192.168.0.0/16
Un rango de CIDR para los objetos Service en el clúster de usuario	10.96.0.0/20
Un rango CIDR para los Pods en el clúster de usuario	192.168.0.0/16
Detalles de Google Cloud
El ID del proyecto de Cloud que elegiste	PROJECT_ID
Es la ruta de acceso al archivo de claves JSON para la cuenta de servicio de acceso a los componentes que configuraste en la sección anterior, en la máquina que usarás para crear el clúster de administrador.	COMPONENT_ACCESS_SA_KEY_PATH
La dirección de correo electrónico asociada con tu cuenta de Google Cloud. Por ejemplo: [e-mail].	GOOGLE_ACCOUNT_EMAIL

3. Crear una estación de trabajo de administrador

Antes de crear cualquier clúster, debes crear una estación de trabajo de administrador y, luego, conectarte a ella mediante SSH. La estación de trabajo de administrador es una VM independiente con las herramientas y los recursos que necesitas para crear clústeres de GKE Enterprise en el entorno de vSphere. Usa la herramienta de línea de comandos de gkeadm para crear la estación de trabajo de administrador.

Descarga gkeadm

Descarga gkeadm en tu directorio actual:

gsutil cp gs://gke-on-prem-release/gkeadm/1.15.9-gke.20/linux/gkeadm ./
chmod +x gkeadm

Necesitas la versión gkeadm (que también es la versión de GKE on VMware) para crear los archivos de configuración del clúster de administrador y de usuario. Para verificar la versión de gkeadm, ejecuta lo siguiente:

./gkeadm version

En el siguiente resultado de ejemplo, se muestra la versión.

gkeadm 1.15.10 (1.15.9-gke.20)

Aunque puedes descargar otra versión de gkeadm, en esta guía, se da por sentado que estás instalando 1.15.9-gke.20 y se usa esa versión en todos los archivos de configuración y comandos.

Crea tu archivo de credenciales

Crea y guarda un archivo llamado credential.yaml en tu directorio actual con el siguiente contenido:

apiVersion: v1
kind: CredentialFile
items:
- name: vCenter
  username: "USERNAME"
  password: "PASSWORD"

Crea el archivo de configuración de la estación de trabajo de administrador

Crea y guarda un archivo llamado admin-ws-config.yaml, nuevamente en tu directorio actual, con el siguiente contenido:

gcp:
  componentAccessServiceAccountKeyPath: "COMPONENT_ACCESS_SA_KEY_PATH"
vCenter:
  credentials:
    address: "ADDRESS"
    fileRef:
      path: "credential.yaml"
      entry: "vCenter"
  datacenter: "DATA_CENTER"
  datastore: "DATASTORE"
  cluster: "VSPHERE_CLUSTER"
  network: "NETWORK"
  resourcePool: "RESOURCE_POOL"
  caCertPath: "CA_CERT_PATH"
proxyUrl: ""
adminWorkstation:
  name: "minimal-installation-admin-workstation"
  cpus: 4
  memoryMB: 8192
  diskGB: 50
  dataDiskName: gke-on-prem-admin-workstation-data-disk/minimal-installation-data-disk.vmdk
  dataDiskMB: 512
  network:
    ipAllocationMode: "static"
    hostConfig:
      ip: "ADMIN_WS_IP"
      gateway: "DEFAULT_GATEWAY_IP"
      netmask: "NETMASK"
      dns:
      - "DNS_SERVER_IP"
  proxyUrl: ""
  ntpServer: ntp.ubuntu.com

Crea tu estación de trabajo de administrador

Crea tu estación de trabajo de administrador con el siguiente comando:

./gkeadm create admin-workstation --auto-create-service-accounts

Ejecuta este comando:

• Crea tu estación de trabajo de administrador.
• Crea automáticamente cualquier cuenta de servicio adicional que necesites para la instalación
• Crea archivos de configuración de plantillas para los clústeres de administrador y de usuario

En el resultado, se proporciona información detallada sobre la creación de tu estación de trabajo de administrador y se proporciona un comando que puedes usar para obtener una conexión SSH a tu estación de trabajo de administrador:

...
Admin workstation is ready to use.
Admin workstation information saved to /usr/local/google/home/me/my-admin-workstation
This file is required for future upgrades
SSH into the admin workstation with the following command:
ssh -i /usr/local/google/home/me/.ssh/gke-admin-workstation ubuntu@172.16.20.49
********************************************************************

Si deseas obtener más información para crear una estación de trabajo de administrador, consulta Crea una estación de trabajo de administrador.

Conéctate a la estación de trabajo de administrador

Usa el comando que se muestra en el resultado anterior para obtener una conexión SSH a tu estación de trabajo de administrador. Por ejemplo:

ssh -i /usr/local/google/home/me/.ssh/gke-admin-workstation ubuntu@172.16.20.49

Si necesitas encontrar este comando de nuevo, gkeadm genera un archivo llamado gke-admin-ws-... en el directorio de la máquina local donde ejecutaste gkeadm create admin-workstation. Contiene detalles sobre la estación de trabajo de administrador, incluido el comando SSH.

Ver los archivos generados

En la estación de trabajo de administrador, enumera los archivos del directorio principal:

ls -1

El resultado debe incluir lo siguiente:

• admin-cluster.yaml, un archivo de configuración de plantilla para crear el clúster de administrador.
• user-cluster.yaml, un archivo de configuración de plantilla para crear el clúster de usuario.
• El archivo de certificado de vCenter que especificaste en la configuración de la estación de trabajo de administrador
• El archivo credential.yaml que especificaste en la configuración de la estación de trabajo de administrador.
• Archivos de claves JSON para dos cuentas de servicio que gkeadm creó para ti: una cuenta de servicio del registro de conexión y una cuenta de servicio de supervisión de registros, así como el archivo de claves para la cuenta de servicio de acceso a los componentes que creaste antes.

Por ejemplo:

admin-cluster.yaml
admin-ws-config.yaml
sa-key.json
connect-register-sa-2203040617.json
credential.yaml
log-mon-sa-2203040617.json
logs
vc01-cert.pem
user-cluster.yaml

Deberás especificar algunos de estos nombres de archivo en los archivos de configuración para crear clústeres. Usa los nombres de archivo como valores para los marcadores de posición en la siguiente tabla:

Nombre del archivo de claves de la cuenta de servicio del registro de conexión Ejemplo: connect-register-sa-2203040617.json	CONNECT_REGISTER_SA_KEY_PATH
Nombre del archivo de claves de la cuenta de servicio de supervisión de registros Ejemplo: log-mon-sa-2203040617.json	LOG_MON_SA_KEY_PATH
Nombre del archivo de claves de la cuenta de servicio de acceso a los componentes Ejemplo: sa-key.json	COMPONENT_ACCESS_SA_KEY_FILE
Nombre del archivo de certificado de vCenter Ejemplo: vc01-cert.pem	CA_CERT_FILE

4. Crear un clúster de administrador

Ahora que tienes una estación de trabajo de administrador configurada con vCenter y otros detalles, puedes usarla para crear un clúster de administrador en el entorno de vSphere. Antes de comenzar este paso, asegúrate de tener una conexión SSH a la estación de trabajo de administrador, como se describió antes. Todos los comandos siguientes se ejecutan en la estación de trabajo de administrador.

Nota: Si usas nombres de DNS internos o tu estación de trabajo no puede acceder a las direcciones DNS públicas de Google (8.8.8.8 u 8.8.4.4), debes especificar tu servidor de nombres interno en /etc/resolv.conf.

Crea el archivo bloqueador de IP del clúster de administrador

Crea y guarda un archivo llamado admin-ipblock.yaml en el mismo directorio que admin-cluster.yaml en la estación de trabajo de administrador, con el siguiente contenido:

blocks:
  - netmask: "NETMASK"
    gateway: "DEFAULT_GATEWAY_IP"
    ips:
    - ip: "ADMIN_NODE_IP_1"
      hostname: "admin-vm-1"
    - ip: "ADMIN_NODE_IP_2"
      hostname: "admin-vm-2"
    - ip: "ADMIN_NODE_IP_3"
      hostname: "admin-vm-3"
    - ip: "ADMIN_NODE_IP_4"
      hostname: "admin-vm-4"

El campo ips es un arreglo de direcciones IP y nombres de host. Estas son las direcciones IP y los nombres de host que GKE on VMware asignará a los nodos del clúster de administrador.

El archivo de bloque de IP también especifica una máscara de subred y una puerta de enlace predeterminada para los nodos del clúster de administrador.

Crea el archivo de configuración del clúster de administrador

Abre admin-cluster.yaml y reemplaza el contenido por lo siguiente:

apiVersion: v1
kind: AdminCluster
name: "minimal-installation-admin-cluster"
bundlePath: "/var/lib/gke/bundles/gke-onprem-vsphere-1.15.9-gke.20-full.tgz"
vCenter:
  address: "ADDRESS"
  datacenter: "DATA_CENTER"
  cluster: "VSPHERE_CLUSTER"
  resourcePool: "RESOURCE_POOL"
  datastore: "DATASTORE"
  caCertPath: "CA_CERT_FILE"
  credentials:
    fileRef:
      path: "credential.yaml"
      entry: "vCenter"
  dataDisk: "data-disks/minimal-installation-admin-disk.vmdk"
network:
  hostConfig:
    dnsServers:
    - "DNS_SERVER_IP"
    ntpServers:
    - "NTP_SERVER_IP"
  ipMode:
    type: "static"
    ipBlockFilePath: admin-ipblock.yaml
  serviceCIDR: "10.96.232.0/24"
  podCIDR: "192.168.0.0/16"
  vCenter:
    networkName: "NETWORK"
loadBalancer:
  vips:
    controlPlaneVIP: "ADMIN_CONTROL_PLANE_VIP"
  kind: "MetalLB"
antiAffinityGroups:
  enabled: false
componentAccessServiceAccountKeyPath: "COMPONENT_ACCESS_SA_KEY_FILE"
gkeConnect:
  projectID: "PROJECT_ID"
  registerServiceAccountKeyPath: "CONNECT_REGISTER_SA_KEY_PATH"
stackdriver:
  projectID: "PROJECT_ID"
  clusterLocation: "us-central1"
  enableVPC: false
  serviceAccountKeyPath: "LOG_MON_SA_KEY_PATH"
  disableVsphereResourceMetrics: false

Valida el archivo de configuración de clústeres de administrador

Verifica que el archivo de configuración de tu clúster de administrador sea válido y se pueda usar para crear el clúster:

gkectl check-config --config admin-cluster.yaml

Importa imágenes de SO a vSphere

Ejecuta gkectl prepare con el archivo de configuración completo para importar imágenes de SO de nodo a vSphere:

gkectl prepare --config admin-cluster.yaml --skip-validation-all

Cuando ejecutas este comando, se importan las imágenes a vSphere y se marcan como plantillas de VM, incluida la imagen del clúster de administrador.

Este comando puede tardar unos minutos en mostrarse.

Crea el clúster de administrador

Crea el clúster de administrador:

gkectl create admin --config admin-cluster.yaml

Reanuda la creación del clúster de administrador después de una falla

Si la creación del clúster de administrador falla o se cancela, puedes volver a ejecutar el comando create:

gkectl create admin --config admin-cluster.yaml

Ubica el archivo kubeconfig del clúster de administrador

El comando gkectl create admin crea un archivo kubeconfig llamado kubeconfig en el directorio actual. Necesitarás este archivo kubeconfig más adelante para interactuar con tu clúster de administrador.

Verifica que el clúster de administrador esté en ejecución

Verifica que el clúster de administrador esté en ejecución:

kubectl get nodes --kubeconfig kubeconfig

En el resultado, se muestran los nodos del clúster de administrador. Por ejemplo:

gke-admin-master-hdn4z            Ready    control-plane,master ...
gke-admin-node-7f46cc8c47-g7w2c   Ready ...
gke-admin-node-7f46cc8c47-kwlrs   Ready ...

Habilitar la autorización de RBAC

Para otorgar a tu cuenta de usuario el rol clusterrole/cluster-admin de Kubernetes en el clúster, ejecuta el siguiente comando:

gcloud container fleet memberships generate-gateway-rbac \
    --membership=minimal-installation-admin-cluster \
    --role=clusterrole/cluster-admin \
    --users=GOOGLE_ACCOUNT_EMAIL \
    --project=PROJECT_ID \
    --kubeconfig=kubeconfig \
    --context=minimal-installation-admin-cluster \
    --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: kubeconfig, context: minimal-installation-admin-cluster
Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
Successfully applied the RBAC policy to cluster.

Entre otras cosas, la política de RBAC te permite acceder a tu clúster en la consola de Google Cloud mediante Google Identity para ver más detalles del clúster.

Inscribe el clúster en la API de GKE On-Prem

De manera opcional, inscribe el clúster en la API de GKE On-Prem. La inscripción del clúster de administrador en la API de GKE On-Prem te permite usar la consola de Google Cloud, Google Cloud CLI o Terraform para actualizar los clústeres de usuario que administra el clúster de administrador.

gcloud container vmware admin-clusters enroll minimal-installation-admin-cluster \
    --project=PROJECT_ID \
    --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/minimal-installation-admin-cluster \
    --location=us-central1

5. Crea un clúster de usuario

En esta sección, se proporcionan los pasos para crear el clúster de usuario mediante la consola, gkectl o Terraform.

gkectl

Asegúrate de tener una conexión SSH a la estación de trabajo de administrador, como se describió antes, antes de comenzar este procedimiento. Todos los comandos siguientes se ejecutan en la estación de trabajo de administrador.

Crea el archivo bloqueador de IP del clúster de usuario

1. Crea un archivo llamado user-ipblock.yaml.

2. Copia y pega el siguiente contenido en user-ipblock.yaml y guarda el archivo:

   blocks:
     - netmask: "NETMASK"
       gateway: "DEFAULT_GATEWAY_IP"
       ips:
       - ip: "USER_NODE_IP_1"
         hostname: "user-vm-1"
       - ip: "USER_NODE_IP_2"
         hostname: "user-vm-2"
       - ip: "USER_NODE_IP_3"
         hostname: "user-vm-3"
       - ip: "USER_NODE_IP_4"
         hostname: "user-vm-4"
   

Crea el archivo de configuración del clúster de usuario

1. Crea un archivo llamado user-cluster.yaml en el mismo directorio que user-ipblock.yaml.

2. Copia y pega el siguiente contenido en user-cluster.yaml y guarda el archivo:

apiVersion: v1
kind: UserCluster
name: "minimal-installation-user-cluster"
gkeOnPremVersion: "1.15.9-gke.20"
enableControlplaneV2: true
network:
  hostConfig:
    dnsServers:
    - "DNS_SERVER_IP"
    ntpServers:
    - "NTP_SERVER_IP"
  ipMode:
    type: "static"
    ipBlockFilePath: "user-ipblock.yaml"
  serviceCIDR: "10.96.0.0/20"
  podCIDR: "192.168.0.0/16"
  controlPlaneIPBlock:
    netmask: "NETMASK"
    gateway: "DEFAULT_GATEWAY_IP"
    ips:
    - ip: "USER_CONTROL_PLANE_NODE_IP"
      hostname: "cp-vm-1"
loadBalancer:
  vips:
    controlPlaneVIP: "USER_CONTROL_PLANE_VIP"
    ingressVIP: "USER_INGRESS_VIP"
  kind: "MetalLB"
  metalLB:
    addressPools:
    - name: "uc-address-pool"
      addresses:
      - "USER_INGRESS_VIP/32"
      - "SERVICE_VIP_1/32"
      - "SERVICE_VIP_2/32"
enableDataplaneV2: true
nodePools:
- name: "uc-node-pool"
  cpus: 4
  memoryMB: 8192
  replicas: 3
  enableLoadBalancer: true
antiAffinityGroups:
  enabled: false
gkeConnect:
  projectID: "PROJECT_ID"
  registerServiceAccountKeyPath: "CONNECT_REGISTER_SA_KEY_PATH"
stackdriver:
  projectID: "PROJECT_ID"
  clusterLocation: "us-central1"
  enableVPC: false
  serviceAccountKeyPath: "LOG_MON_SA_KEY_PATH"
  disableVsphereResourceMetrics: false
autoRepair:
  enabled: true

Valida la configuración y crea el clúster

1. Verifica que el archivo de configuración de tu clúster de usuario sea válido y se pueda usar para crear el clúster:

   gkectl check-config --kubeconfig kubeconfig --config user-cluster.yaml
   

2. Crea el clúster de usuario:

   gkectl create cluster --kubeconfig kubeconfig --config user-cluster.yaml
   

   La creación de clústeres tarda alrededor de 30 minutos.

Ubica el archivo kubeconfig del clúster de usuario

El comando gkectl create cluster crea un archivo kubeconfig llamado USER_CLUSTER_NAME-kubeconfig en el directorio actual. Necesitarás este archivo kubeconfig más adelante para interactuar con tu clúster de usuario.

Verifica que el clúster de usuario esté en ejecución

Verifica que el clúster de usuario esté en ejecución:

kubectl get nodes --kubeconfig USER_CLUSTER_KUBECONFIG

Reemplaza USER_CLUSTER_KUBECONFIG con la ruta de tu archivo kubeconfig del clúster de usuario.

En el resultado, se muestran los nodos del clúster de usuario. Por ejemplo:

cp-vm-1     Ready    control-plane,master
user-vm-1   Ready
user-vm-2   Ready
user-vm-3   Ready

Habilitar la autorización de RBAC

Para otorgar a tu cuenta de usuario el rol clusterrole/cluster-admin de Kubernetes en el clúster, ejecuta el siguiente comando:

gcloud container fleet memberships generate-gateway-rbac \
  --membership=minimal-installation-user-cluster \
  --role=clusterrole/cluster-admin \
  --users=GOOGLE_ACCOUNT_EMAIL \
  --project=PROJECT_ID \
  --kubeconfig=USER_CLUSTER_KUBECONFIG \
  --context=minimal-installation-user-cluster \
  --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: kubeconfig, context: minimal-installation-admin-cluster
Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
Successfully applied the RBAC policy to cluster.

Entre otras cosas, la política de RBAC te permite acceder a tu clúster en la consola de Google Cloud mediante Google Identity para ver más detalles del clúster.

Inscribe el clúster en la API de GKE On-Prem

De manera opcional, inscribe el clúster en la API de GKE On-Prem. La inscripción del clúster de usuario en la API de GKE On-Prem te permite usar la consola de Google Cloud o Google Cloud CLI para realizar actualizaciones.

gcloud container vmware clusters enroll minimal-installation-user-cluster \
  --project=PROJECT_ID \
  --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/minimal-installation-admin-cluster \
  --location=us-central1

Terraform

En esta sección, se muestra cómo crear un clúster de usuario y un grupo de nodos con Terraform. Para obtener más información y otros ejemplos, consulta los siguientes vínculos:

• google_gkeonprem_vmware_cluster

• google_gkeonprem_vmware_node_pool

• terraform.tfvars.sample

1. Crea un directorio y un archivo nuevo dentro de ese directorio. El nombre del archivo debe tener la extensión .tf. En esta guía, el archivo se llama main.tf.

   mkdir DIRECTORY && cd DIRECTORY && touch main.tf
   

2. Verifica el recurso de Terraform del clúster de usuario:

   El siguiente ejemplo de recurso de Terraform se completa con los valores que ingresaste en la tabla de planificación en la sección anterior.

   resource "google_gkeonprem_vmware_cluster" "cluster-basic" {
     name = "minimal-installation-user-cluster"
     project = "PROJECT_ID"
     location = "us-central1"
     admin_cluster_membership = "projects/PROJECT_ID/locations/global/memberships/minimal-installation-admin-cluster"
     description = "User cluster config with MetalLB, static IPs, and Controlplane V2"
     enable_control_plane_v2 = "true"
     on_prem_version = "1.15.9-gke.20"
     control_plane_node {
       cpus = 4
       memory = 8192
       replicas = 1
     }
     network_config {
       service_address_cidr_blocks = ["10.96.0.0/20"]
       pod_address_cidr_blocks = ["192.168.0.0/16"]
       host_config {
         dns_servers = ["DNS_SERVER_IP"]
         ntp_servers = ["NTP_SERVER_IP"]
       }
       static_ip_config {
         ip_blocks {
           netmask = "NETMASK"
           gateway = "DEFAULT_GATEWAY_IP"
           ips {
             ip = "USER_NODE_IP_1"
             hostname = "user-vm-1"
           }
           ips {
             ip = "USER_NODE_IP_2"
             hostname = "user-vm-2"
           }
           ips {
             ip = "USER_NODE_IP_3"
             hostname = "user-vm-3"
           }
           ips {
             ip = "USER_NODE_IP_4"
             hostname = "user-vm-4"
           }
         }
       }
       control_plane_v2_config {
         control_plane_ip_block {
           netmask = "NETMASK"
           gateway = "DEFAULT_GATEWAY_IP"
           ips {
             ip = "USER_CONTROL_PLANE_NODE_IP"
             hostname = "cp-vm-1"
           }
         }
       }
     }
     load_balancer {
       vip_config {
         control_plane_vip = "USER_CONTROL_PLANE_VIP"
         ingress_vip = "USER_INGRESS_VIP"
       }
       metal_lb_config {
         address_pools {
           pool = "uc-address-pool"
           manual_assign = "true"
           addresses = ["USER_INGRESS_VIP/32", "SERVICE_VIP_1/32", "SERVICE_VIP_2/32"]
         }
       }
     }
     authorization {
       admin_users {
       username = "GOOGLE_ACCOUNT_EMAIL"
     }
   }
     provider = google-beta
   }
   
   resource "google_gkeonprem_vmware_node_pool" "my-node-pool-1" {
     name = "uc-node-pool"
     project = "PROJECT_ID"
     vmware_cluster = "minimal-installation-user-cluster"
     location = "us-central1"
     config {
       replicas = 3
       image_type = "ubuntu_containerd"
       enable_load_balancer = "true"
     }
     depends_on = [
       google_gkeonprem_vmware_cluster.cluster-basic
     ]
     provider = google-beta
   }
   

3. Copia el recurso de Terraform en main.tf y guarda el archivo.

4. Inicializa y crea terraform plan:

   terraform init
   

   Terraform instala las bibliotecas necesarias, como el proveedor de Google Cloud.

5. Revisa la configuración y realiza cambios si es necesario:

   terraform plan
   

6. Aplica el plan de Terraform para crear el clúster de usuario:

   terraform apply
   

   Cuando se te solicite, ingresa yes.

   La creación del clúster de usuario básico y el grupo de nodos tarda alrededor de 15 minutos (o más, según tu red).

gcloud

Crea el clúster:

gcloud container vmware clusters create minimal-installation-user-cluster \
  --project=PROJECT_ID \
  --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/minimal-installation-admin-cluster \
  --location=us-central1 \
  --version=1.15.9-gke.20 \
  --admin-users=GOOGLE_ACCOUNT_EMAIL \
  --service-address-cidr-blocks=10.96.0.0/20 \
  --pod-address-cidr-blocks=192.168.0.0/16 \
  --metal-lb-config-address-pools='pool=uc-address-pool,avoid-buggy-ips=False,manual-assign=False,addresses=USER_INGRESS_VIP/32;SERVICE_VIP_1/32;SERVICE_VIP_2/32' \
  --control-plane-vip=USER_CONTROL_PLANE_VIP \
  --ingress-vip=USER_INGRESS_VIP \
  --static-ip-config-ip-blocks='gateway=DEFAULT_GATEWAY_IP,netmask=NETMASK,ips=USER_NODE_IP_1;USER_NODE_IP_2;USER_NODE_IP_3;USER_NODE_IP_4' \
  --dns-servers=DNS_SERVER_IP \
  --ntp-servers=NTP_SERVER_IP \
  --enable-control-plane-v2 \
  --enable-dataplane-v2 \
  --control-plane-ip-block='gateway=DEFAULT_GATEWAY_IP,netmask=NETMASK,ips=USER_CONTROL_PLANE_NODE_IP'

El resultado del comando es similar al siguiente:

Waiting for operation [projects/example-project-12345/locations/us-central1/operations/operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179] to complete.

En el resultado de ejemplo, la string operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179 es la OPERATION_ID de la operación de larga duración. Puedes averiguar el estado de la operación con el siguiente comando:

gcloud container vmware operations describe OPERATION_ID \
  --project=PROJECT_ID \
  --location=us-central1

Para obtener más información, consulta gcloud container vmware operations.

La creación del clúster de usuario tarda 15 minutos o más. Puedes ver el clúster en Google Cloud Console en la página Clústeres de Anthos.

Crea un grupo de nodos:

gcloud container vmware node-pools create  uc-node-pool \
  --cluster=minimal-installation-user-cluster \
  --project=PROJECT_ID \
  --location=us-central1 \
  --image-type=ubuntu_containerd  \
  --boot-disk-size=40 \
  --cpus=4 \
  --memory=8192 \
  --replicas=3 \
  --enable-load-balancer

¿Qué sigue?

Completaste esta instalación mínima de GKE en VMware. Como seguimiento opcional, puedes ver la instalación en acción si implementas una aplicación.