Crea clústeres básicos

bmctl

Cuando se habilita la API de GKE On-Prem (gkeonprem.googleapis.com) en tu proyecto, los clústeres recién creados se inscriben en la API automáticamente. La inscripción ocurre incluso cuando no se especifica spec.gkeOnPremAPI en el archivo de configuración del clúster. Cuando tu clúster esté inscrito con esta API alojada en Google Cloud, puedes usar la consola de Google Cloud o gcloud CLI para administrar el ciclo de vida del clúster.

Para inhabilitar la inscripción automática, quita el comentario de la sección spec.gkeOnPremAPI del archivo de configuración del clúster y establece spec.gkeOnPremAPI.enabled en false antes de crear el clúster. El campo spec.gkeOnPremAPI.enabled es mutable, por lo que puedes dar de baja tu clúster en cualquier momento después de su creación.

1. Genera un archivo de configuración de clúster:

   bmctl create config -c USER_CLUSTER_NAME \
     --project-id=PROJECT_ID

2. Verifica el archivo de configuración del clúster de usuario:

   El siguiente archivo de configuración del clúster se completa con los valores que ingresaste antes en la tabla de planificación. Además de los valores que ingresaste, ten en cuenta las siguientes diferencias con respecto al archivo de configuración generado:

   • Se quitaron los comentarios de esta muestra para facilitar la lectura.
   • El tipo de clúster, spec.type, se estableció en user.
   • Se agregó el campo spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts para otorgar clusterrole/cluster-admin a tu cuenta. Entre otras cosas, este campo te permite acceder a tu clúster en la consola de Google Cloud para ver más detalles.

   ---
   apiVersion: v1
   kind: Namespace
   metadata:
     name: cluster-USER_CLUSTER_NAME
   ---
   apiVersion: baremetal.cluster.gke.io/v1
   kind: Cluster
   metadata:
     name: USER_CLUSTER_NAME
     namespace: cluster-USER_CLUSTER_NAME
   spec:
     type: user
     profile: default
     anthosBareMetalVersion: CLUSTER_VERSION
     gkeConnect:
       projectID: PROJECT_ID
     controlPlane:
       nodePoolSpec:
         nodes:
         - address: USER_CP_NODE_IP
     clusterNetwork:
       pods:
         cidrBlocks:
         - 192.168.0.0/16
       services:
         cidrBlocks:
         - 10.96.0.0/20
     loadBalancer:
       mode: bundled
       ports:
         controlPlaneLBPort: 443
       vips:
         controlPlaneVIP: USER_CP_VIP
         ingressVIP: USER_INGRESS_VIP
       addressPools:
       - name: pool1
         addresses:
         - START_IP-END_IP
     clusterOperations:
       projectID: PROJECT_ID
       location: us-central1
     clusterSecurity:
       authorization:
         clusterAdmin:
           gcpAccounts:
           - GOOGLE_ACCOUNT_EMAIL
     storage:
       lvpNodeMounts:
         path: /mnt/localpv-disk
         storageClassName: local-disks
       lvpShare:
         path: /mnt/localpv-share
         storageClassName: local-shared
         numPVUnderSharedPath: 5
     nodeConfig:
       podDensity:
         maxPodsPerNode: 250
     # GKEOnPremAPI (Optional) Specify if you wish to explicitly enable/disable the cloud hosted gkeonprem
     # API to enable/disable cluster lifecycle management from gcloud UI and Terraform.
     # gkeOnPremAPI:
       # enabled: false
       # location is the Cloud location for the cluster resource metadata where the cluster will be enrolled.
       # location: us-central1
   ---
   apiVersion: baremetal.cluster.gke.io/v1
   kind: NodePool
   metadata:
     name: node-pool-1
     namespace: cluster-USER_CLUSTER_NAME
   spec:
     clusterName: USER_CLUSTER_NAME
     nodes:
     - address: USER_WORKER_NODE_IP
   

3. Reemplaza el contenido del archivo de configuración generado en tu estación de trabajo de administrador por el contenido del ejemplo anterior.

   Abre el archivo generado, bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME.yaml, y reemplaza su contenido por el contenido de la muestra que verificaste en el paso anterior.

4. Crea el clúster de usuario:

   bmctl create cluster -c USER_CLUSTER_NAME \
   --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig

   El comando bmctl muestra el resultado en la pantalla mientras ejecuta las comprobaciones preliminares y crea el clúster. La información detallada se escribe en los registros de la carpeta baremetal/bmctl-workspace/USER_CLUSTER_NAME/log de la estación de trabajo de administrador.

   La creación del clúster puede tomar varios minutos en completarse.

5. Verifica que el clúster se haya creado y se esté ejecutando:

   kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-kubeconfig \
     get nodes

   Si tu clúster está en ejecución, la respuesta es similar a la siguiente:

   NAME    STATUS   ROLES           AGE     VERSION
   nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
   nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

Console

Sigue estos pasos para crear un clúster de usuario en la consola:

1. En la consola, ve a la página Crea un clúster de GKE en Bare Metal.

   Ir a Crea un clúster de GKE en Bare Metal

2. Asegúrate de que la lista de proyectos de Google Cloud tenga PROJECT_ID seleccionado.

3. Haz clic en Crear clúster.

4. En el cuadro de diálogo, haz clic en Local.

5. Junto a Bare Metal, haz clic en Configurar. Aparecerá la página Requisitos previos.

6. En Elige tu tipo de clúster, selecciona Crear un clúster de usuario para un clúster de administrador existente.

7. Haz clic en Siguiente.

Conceptos básicos del clúster

1. Ingresa USER_CLUSTER_NAME como el nombre del clúster de usuario o usa el predeterminado.

2. Asegúrate de que esté seleccionado el clúster de administrador recién creado.

3. En Ubicación de la API de GCP, selecciona us-central1.

4. En la versión de GKE en Bare Metal, selecciona CLUSTER_VERSION o usa la opción predeterminada. Puedes usar los valores predeterminados para el resto de la configuración en esta página.

5. Haz clic en Herramientas de redes en la barra de navegación izquierda.

Redes

1. En la sección Plano de control, ingresa lo siguiente en el campo IP 1 del nodo del plano de control:

   USER_CP_NODE_IP
   

2. En la sección Balanceador de cargas, usa el balanceador de cargas predeterminado, Bundled with MetalLB.

3. Ve a la sección Nuevo grupo de direcciones. Ingresa el rango de direcciones IP en el campo Rango de direcciones IP 1:

   10.200.0.51-10.200.0.70
   

4. Haz clic en Listo.

5. En la sección IP virtuales, ingresa la dirección IP para la VIP del plano de control:

   USER_CP_VIP
   

6. Ingresa la dirección IP de la VIP de Ingress:

   USER_INGRESS_VIP
   

7. En la sección CIDR de servicio y Pod, si no cambiaste los CIDR de servicio y Pod en el Planificador, puedes usar los valores predeterminados.

   Si cambiaste los CIDR, ingresa los que deseas usar:

   • CIDR del servicio:

   10.96.0.0/20
   

   • CIDR del Pod:

   192.168.0.0/16
   

8. Haz clic en grupo predeterminado en la barra de navegación izquierda.

Crear un grupo de nodos

Tu clúster debe tener al menos un grupo de nodos para los nodos trabajadores. Un grupo de nodos es una plantilla para los grupos de nodos trabajadores que se crearon en este clúster.

Ingresa la dirección IP del nodo trabajador del clúster de usuario en el campo Nodes address 1:

USER_WORKER_NODE_IP

Crea el clúster

1. Haz clic en Verificar y crear para crear el clúster de usuario.

   La creación del clúster de usuario tarda 15 minutos o más. La consola muestra mensajes de estado mientras verifica la configuración y crea el clúster.

   Si hay un problema con la configuración, la consola muestra un mensaje de error que debería ser lo suficientemente claro como para que lo soluciones y, luego, intentes crear el clúster.

   Si deseas ver información adicional sobre el proceso de creación, haz clic en Mostrar detalles para mostrar un panel lateral. Haz clic en close para cerrar el panel de detalles.

   Cuando se cree el clúster, se mostrará Cluster status: running.

   

2. Después de crear el clúster, haz clic en arrow_back Clústeres para volver a la página Clústeres.

gcloud CLI

En esta sección, se muestra cómo crear un clúster de usuario y un grupo de nodos con gcloud CLId.

1. Ejecuta el siguiente comando para crear un clúster de usuario:

   gcloud container bare-metal clusters create USER_CLUSTER_NAME \
     --project=PROJECT_ID \
     --location=us-central1 \
     --admin-cluster-membership=ADMIN_CLUSTER_NAME \
     --admin-cluster-membership-project=PROJECT_ID \
     --admin-cluster-membership-location=global \
     --version=CLUSTER_VERSION \
     --admin-users=GOOGLE_ACCOUNT_EMAIL \
     --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
     --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
     --metal-lb-address-pools='pool=lb-pool-1,manual-assign=True,addresses=START_IP-END_IP' \
     --control-plane-node-configs='node-ip=USER_CP_NODE_IP' \
     --control-plane-vip=USER_CP_VIP \
     --control-plane-load-balancer-port=443 \
     --ingress-vip=USER_INGRESS_VIP \
     --lvp-share-path=/mnt/localpv-share \
     --lvp-share-storage-class=local-shared \
     --lvp-node-mounts-config-path=/mnt/localpv-disk \
     --lvp-node-mounts-config-storage-class=local-disks
   

   El resultado del comando es similar al siguiente:

   Waiting for operation [projects/example-project-12345/locations/us-west1/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 bare-metal operations describe OPERATION_ID \
     --project=PROJECT_ID \
     --location=us-central1
   

   La creación del clúster tarda alrededor de 15 minutos o más. Mientras se crea el clúster, puedes ejecutar el comando anterior de vez en cuando para obtener el estado actual.

   Cuando se cree el clúster, verás un resultado como el siguiente:

   Created Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/bareMetalClusters/USER_CLUSTER_NAME].
   

2. Después de crear el clúster, ejecuta el siguiente comando para crear un grupo de nodos en el clúster recién creado.

   gcloud container bare-metal node-pools create node-pool-1 \
     --cluster=USER_CLUSTER_NAME \
     --project=PROJECT_ID \
     --location=us-central1 \
     --node-configs node-ip=USER_WORKER_NODE_IP

Para obtener más información y otros ejemplos, consulta los siguientes vínculos:

• gcloud container bare-metal clusters

• gcloud container bare-metal node-pools

• Crear un clúster de usuario

Terraform

En esta sección, se muestra cómo crear un clúster de usuario y un grupo de nodos con Terraform.

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_bare_metal_cluster"  "cluster-basic" {
     provider = google-beta
     name = "USER_CLUSTER_NAME"
     project = "PROJECT_ID"
     location = "us-central1"
     admin_cluster_membership = "projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME"
     bare_metal_version = "CLUSTER_VERSION"
     network_config {
       island_mode_cidr {
         service_address_cidr_blocks = ["10.96.0.0/20"]
         pod_address_cidr_blocks = ["192.168.0.0/16"]
       }
     }
     control_plane {
       control_plane_node_pool_config {
         node_pool_config {
           labels = {}
           operating_system = "LINUX"
           node_configs {
             labels = {}
             node_ip = "USER_CP_NODE_IP"
           }
         }
       }
     }
     load_balancer {
       port_config {
         control_plane_load_balancer_port = 443
       }
       vip_config {
         control_plane_vip = "USER_CP_VIP"
         ingress_vip = "USER_INGRESS_VIP"
       }
       metal_lb_config {
         address_pools {
           pool = "pool1"
           addresses = [
             "START_IP-END_IP"
           ]
           avoid_buggy_ips = true
           manual_assign = true
         }
       }
     }
     storage {
       lvp_share_config {
         lvp_config {
           path = "/mnt/localpv-share"
           storage_class = "local-shared"
         }
         shared_path_pv_count = 5
       }
       lvp_node_mounts_config {
         path = "/mnt/localpv-disk"
         storage_class = "local-disks"
       }
     }
     security_config {
       authorization {
         admin_users {
           username = "GOOGLE_ACCOUNT_EMAIL"
         }
       }
     }
   }
   
   resource "google_gkeonprem_bare_metal_node_pool" "node-pool-default" {
     provider = google-beta
     name =  "node-pool-1"
     bare_metal_cluster = google_gkeonprem_bare_metal_cluster.cluster-basic.name
     project = "PROJECT_ID"
     location = "us-central1"
     node_pool_config {
       operating_system = "LINUX"
       node_configs {
         node_ip = "USER_WORKER_NODE_IP"
       }
     }
   }
   

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).

7. Si deseas crear un archivo kubeconfig para el clúster de usuario, ejecuta el siguiente comando en la estación de trabajo de administrador:

   bmctl get credentials --cluster USER_CLUSTER_NAME \
   --admin-kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig

   En el resultado del comando, se muestra el nombre del archivo kubeconfig del clúster de usuario, por ejemplo:

   bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig

   El TIMESTAMP en el nombre de archivo indica la fecha y hora en que se creó el archivo.

   Debido a que este archivo contiene credenciales de autenticación para tu clúster, debes almacenarlo en una ubicación segura con acceso restringido.

8. Verifica que el clúster se haya creado y se esté ejecutando:

   kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig \
       get nodes

   Si tu clúster está en ejecución, la respuesta es similar a la siguiente:

   NAME    STATUS   ROLES           AGE     VERSION
   nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
   nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

Para obtener más información y otros ejemplos, consulta los siguientes vínculos:

• google_gkeonprem_bare_metal_cluster

• google_gkeonprem_bare_metal_node_pool

• terraform.tfvars.sample

• Crear un clúster de usuario