Ejecutar cargas de trabajo de Autopilot en clústeres estándar de GKE

Los administradores de clústeres y los operadores de aplicaciones pueden disfrutar de las ventajas de Autopilot de Google Kubernetes Engine (GKE), como los precios y los ajustes preconfigurados, en los clústeres del modo Standard. En esta página se explica cómo usar ComputeClasses para desplegar una carga de trabajo de Autopilot en un clúster estándar. Ya deberías conocer los siguientes conceptos:

Acerca de las ComputeClasses de Autopilot

GKE proporciona recursos personalizados de Kubernetes denominados ComputeClasses que se pueden desplegar en tu clúster como cualquier otro recurso de Kubernetes. Un objeto ComputeClass define una lista de configuraciones de nodos, como tipos de máquinas o máquinas virtuales de aprovisionamiento esporádico. Puedes seleccionar ComputeClasses en tus cargas de trabajo, lo que indica a GKE que los nodos nuevos deben usar una de las configuraciones de esa lista.

Si una carga de trabajo selecciona un ComputeClass que tiene el campo autopilot habilitado, GKE ejecuta los pods en modo Autopilot. Google gestiona los nodos que crea GKE, que incluyen muchos de los ajustes de seguridad y funciones predeterminados de Autopilot. Para obtener más información sobre las implicaciones de ejecutar una carga de trabajo de Autopilot en tus clústeres Standard, incluidas las diferencias que puedes observar al desplegar esas cargas de trabajo, consulta Acerca de las cargas de trabajo del modo Autopilot en GKE Standard.

Tipos de ComputeClass de Autopilot

GKE proporciona ComputeClasses de Autopilot integradas que puedes usar para la mayoría de las cargas de trabajo de uso general. También puedes configurar una ComputeClass personalizada nueva o ya creada para usar el modo Autopilot. El tipo de Autopilot ComputeClass que utilices depende de si tus cargas de trabajo necesitan hardware específico, como se indica a continuación:

  • Cargas de trabajo de uso general: usa una de las ComputeClasses de Autopilot integradas, que colocan los pods en la plataforma de computación optimizada para contenedores.
  • Cargas de trabajo que requieren hardware específico: habilita el modo Autopilot para cualquier ComputeClass personalizado, despliega ese ComputeClass en el clúster y selecciónalo en tus cargas de trabajo.

Para obtener más información sobre estas opciones, cuándo usarlas y los precios de cada una, consulta Selección de hardware en ComputeClasses de Autopilot.

Precios

Los precios de Autopilot de GKE se aplican a las cargas de trabajo y los nodos que usan una ComputeClass de Autopilot. El modelo de precios que se aplica depende de si usas una ComputeClass de Autopilot integrada o una ComputeClass de Autopilot personalizada. Para obtener más información, consulta la sección Precios del artículo "Acerca de las cargas de trabajo del modo Autopilot en GKE Standard".

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
    • Habilitar la API de Google Kubernetes Engine
  • Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.
  • Usa un clúster estándar de GKE que ejecute la versión 1.33.1-gke.1107000 o una posterior y que esté registrado en el canal de lanzamiento rápido. Para crear un clúster, consulta Crear un clúster regional.
  • Para evitar que se rechacen las cargas de trabajo, consulta los requisitos y las restricciones de seguridad de Autopilot. Para obtener más información, consulta los ajustes predefinidos de los nodos de Autopilot.

Requisitos

  • Al menos un grupo de nodos del clúster no debe tener taints de nodos.

    Este grupo de nodos es necesario para ejecutar pods del sistema estándar de GKE que no se pueden ejecutar en nodos de Autopilot en clústeres estándar debido a los taints que GKE añade a esos nodos.

  • Nodos de GKE blindados es obligatorio y está habilitado de forma predeterminada.

  • Debes usar un clúster nativo de VPC.

Limitaciones

  • Solo se admite el canal de lanzamiento rápido.
  • Para actualizar los recursos ComputeClass de un clúster y usar el modo Autopilot, debes volver a crear esa ComputeClass con una especificación actualizada. Para obtener más información, consulta Habilitar Autopilot en una ComputeClass personalizada.
  • No puedes usar la regla de prioridad podFamily en tus propios ComputeClasses. Esta regla solo está disponible en las clases de cálculo de Autopilot integradas.
  • Las ComputeClasses de Autopilot integradas no admiten la habilitación de nodos de GKE confidenciales en todo el clúster. Si habilitas los nodos de GKE confidenciales en el clúster, los nuevos pods que seleccionen las ComputeClasses de Autopilot integradas permanecerán en el estado Pending indefinidamente.

Roles y permisos necesarios

Para obtener los permisos que necesitas para desplegar ComputeClasses, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Desarrollador de Kubernetes Engine (roles/container.developer) en tu clúster o proyecto . Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Seleccionar una ComputeClass de Autopilot en una carga de trabajo

Para seleccionar un ComputeClass de Autopilot en una carga de trabajo, usa un selector de nodos para la etiqueta cloud.google.com/compute-class. Es la misma etiqueta que usas para seleccionar cualquier otra ComputeClass en GKE. En los siguientes pasos se muestra cómo crear un Deployment de ejemplo que seleccione un ComputeClass y cómo verificar que los Pods se ejecutan en el modo Autopilot:

  1. Guarda el siguiente ejemplo de Deployment como autopilot-cc-deployment.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloweb
  labels:
    app: hello
spec:
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      nodeSelector:
        # Replace with the name of a compute class
        cloud.google.com/compute-class: COMPUTE_CLASS 
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "250m"
            memory: "4Gi"

    Sustituye COMPUTE_CLASS por el nombre de la clase de cálculo que quieras usar. Este valor puede ser cualquiera de los siguientes:

  2. Despliega la carga de trabajo:

    kubectl apply -f autopilot-cc-deployment.yaml

  3. Para verificar que los pods usan Autopilot, comprueba los nombres de los nodos host:

    kubectl get pods -l=app=hello -o wide

    El resultado debería ser similar al siguiente:

    NAME                       READY   STATUS    RESTARTS   AGE     IP             NODE                                         NOMINATED NODE   READINESS GATES
helloweb-79b9f6f75-5wwc9   1/1     Running   0          152m    10.102.1.135   gk3-cluster-1-nap-10abc8ya1-f66c6cef-wg5g   <none>           <none>
helloweb-79b9f6f75-9skb9   1/1     Running   0          4d3h    10.102.0.140   gk3-cluster-1-nap-10abc8ya1-632bac02-hjl6   <none>           <none>
helloweb-79b9f6f75-h7bdv   1/1     Running   0          152m    10.102.1.137   gk3-cluster-1-nap-10abc8ya1-f66c6cef-wg5g   <none>           <none>

    En este resultado, el prefijo gk3- de la columna Nodo indica que el nodo está gestionado por Autopilot.

Configurar un ComputeClass de Autopilot personalizado

Puedes configurar ComputeClasses personalizados para usar Autopilot. Usa una ComputeClass de Autopilot personalizada si tus cargas de trabajo requieren hardware específico para funcionar de forma óptima, como GPUs o una serie de máquinas de Compute Engine concreta.

Si tus cargas de trabajo no requieren hardware específico, te recomendamos que uses una de las ComputeClasses de Autopilot integradas. Para seleccionar una ComputeClass de Autopilot integrada, consulta la sección anterior Seleccionar una ComputeClass de Autopilot en una carga de trabajo.

Crear una clase Compute personalizada de Autopilot

  1. Guarda el siguiente manifiesto de ComputeClass como autopilot-n2-class.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: autopilot-n2-class
spec:
  autopilot:
    enabled: true
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  whenUnsatisfiable: DoNotScaleUp

    Este manifiesto incluye los siguientes campos:

    • autopilot: habilita el modo Autopilot para ComputeClass. Si especificas este campo en una ComputeClass que despliegues en un clúster de Autopilot, GKE lo ignorará.
    • priorities: define una matriz de tres configuraciones diferentes de la familia de máquinas N2.
    • activeMigration: permite que GKE migre pods a configuraciones que tengan una prioridad más alta en la lista cuando haya recursos disponibles.
    • whenUnsatisfiable: el valor de DoNotScaleUp en este campo hace que sea obligatorio que GKE use una de las reglas del campo priorities para los nodos nuevos. Si no se puede cumplir ninguna de estas reglas de prioridad, GKE dejará el pod en estado Pending hasta que haya recursos disponibles. DoNotScaleUp es el valor predeterminado y recomendado para este campo.

  2. Despliega el ComputeClass:

    kubectl apply -f autopilot-n2-class.yaml

  3. Verifica que la clase ComputeClass exista:

    kubectl get computeclasses

    El resultado debería ser similar al siguiente:

    NAME                  AGE
autopilot-n2-class    3s

Habilitar Autopilot en una ComputeClass personalizada

Puedes habilitar Autopilot en las clases de Compute personalizadas que ya tengas en un clúster Standard y que tengan el campo nodePoolAutoCreation.enabled en la especificación definido como true. Habilitar Autopilot en una clase de cálculo que esté en un clúster de Autopilot no tiene ningún efecto, ya que todo el clúster usa el modo Autopilot.

Después de habilitar Autopilot en un ComputeClass, GKE usa Autopilot para ejecutar los nuevos pods que seleccionen el ComputeClass. Si tienes pods en nodos Standard que seleccionan la clase de computación Autopilot, esos pods solo usarán Autopilot cuando se vuelvan a crear.

Para actualizar una ComputeClass personalizada que ya tengas y usar el modo Autopilot, sigue estos pasos:

  1. En un editor de texto, actualiza el archivo de manifiesto de tu ComputeClass para añadir el campo spec.autopilot:

    spec:
  autopilot:
    enabled: true

  2. Sustituye el recurso ComputeClass de la API de Kubernetes por la especificación actualizada:

    kubectl replace --force -f PATH_TO_UPDATED_MANIFEST

    Sustituye PATH_TO_UPDATED_MANIFEST por la ruta de acceso al archivo de manifiesto actualizado.

  3. Para activar la creación de nodos, vuelve a crear las cargas de trabajo que usen la clase de cálculo.

Después de aplicar el manifiesto actualizado, los nodos nuevos que GKE cree para esta ComputeClass usarán Autopilot. GKE no modifica ningún nodo que se haya creado antes de la actualización.

Verificar que tu carga de trabajo usa Autopilot

  • Para obtener una lista de los pods de tu clúster, usa el comando kubectl get:

    kubectl get pods --output=custom-columns=Pod:.metadata.name,Node:.spec.nodeName

    El resultado debería ser similar al siguiente:

    Pod                         Node
helloweb-84c865764b-nzhxt   gk3-cluster-1-pool-3-68fc8dca-t54b
# lines omitted for clarity

    El prefijo gk3- en el nombre del nodo indica que el pod se está ejecutando en modo Autopilot.

Aplicar un ComputeClass de Autopilot de forma predeterminada

GKE te permite definir una ComputeClass como predeterminada para un espacio de nombres. La clase predeterminada del espacio de nombres se aplica a todos los pods de ese espacio de nombres que no seleccionen explícitamente otra ComputeClass. Si defines una ComputeClass de Autopilot como predeterminada, podrás ejecutar todos los pods de un espacio de nombres en el modo Autopilot de forma predeterminada, a menos que la carga de trabajo seleccione otra opción.

Para obtener más información, consulta Configurar una ComputeClass predeterminada para un espacio de nombres.

Siguientes pasos