Ejecuta cargas de trabajo de Autopilot en clústeres de GKE Standard

Los administradores de clústeres y los operadores de aplicaciones pueden obtener los beneficios de Google Kubernetes Engine (GKE) Autopilot, como los precios y la configuración previa, en los clústeres del modo estándar. En esta página, se muestra cómo usar ComputeClasses para implementar una carga de trabajo de Autopilot en un clúster Standard. Ya debes conocer los siguientes conceptos:

Acerca de las clases de procesamiento de Autopilot

GKE proporciona recursos personalizados de Kubernetes llamados ComputeClasses que se pueden implementar 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 VMs Spot. Puedes seleccionar ComputeClasses en tus cargas de trabajo, lo que le indica a GKE que los nodos nuevos deben usar una de las configuraciones de esa lista.

Si una carga de trabajo selecciona una ComputeClass que tiene habilitado el campo autopilot, GKE ejecuta los Pods en modo Autopilot. Los nodos que crea GKE son administrados por Google y contienen muchos de los parámetros de configuración predeterminados de seguridad y funciones de Autopilot. Para obtener más información sobre las implicaciones de ejecutar una carga de trabajo de Autopilot en tus clústeres de Standard, incluidas las diferencias que podrías notar cuando implementes esas cargas de trabajo, consulta Acerca de las cargas de trabajo del modo Autopilot en GKE Standard.

Tipos de clases de procesamiento de Autopilot

GKE proporciona ComputeClasses integradas de Autopilot que puedes usar para la mayoría de las cargas de trabajo de uso general. También puedes configurar una ComputeClass personalizada nueva o existente para que use el modo Autopilot. El tipo de ComputeClass de Autopilot que usas depende de si tus cargas de trabajo necesitan hardware específico, de la siguiente manera:

  • Cargas de trabajo de uso general: Usa una de las ComputeClasses integradas de Autopilot, que colocan los Pods en la plataforma de procesamiento optimizada para contenedores.
  • Cargas de trabajo que requieren hardware específico: Habilita el modo Autopilot para cualquier ComputeClass personalizada, implementa esa ComputeClass en el clúster y selecciona esa ComputeClass 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 GKE Autopilot 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 Precios en "Acerca de las cargas de trabajo del modo Autopilot en GKE Standard".

Antes de comenzar

Antes de comenzar, asegúrate de haber 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, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
  • Usa un clúster de GKE Standard que ejecute la versión 1.33.1-gke.1107000 o posterior y esté inscrito en el canal de versiones rápidas. Para crear un clúster nuevo, consulta Crea un clúster regional.
  • Para evitar el rechazo de cargas de trabajo, obtén información sobre los requisitos y las restricciones de seguridad de Autopilot. Para obtener más información, consulta la configuración predefinida para nodos de Autopilot.

Requisitos

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

    Este grupo de nodos es necesario para ejecutar Pods del sistema de GKE Standard que no se pueden ejecutar en nodos de Autopilot en clústeres Standard debido a los taints que GKE agrega a esos nodos.

  • Se requieren los nodos de GKE protegidos, que están habilitados de forma predeterminada.

  • Debes usar un clúster nativo de la VPC.

Limitaciones

  • Solo se admite el canal de versiones de lanzamiento rápido.
  • Para actualizar los recursos ComputeClass existentes en el clúster para que usen el modo Autopilot, debes volver a crear esa ComputeClass con una especificación actualizada. Para obtener más información, consulta Cómo habilitar Autopilot para una ComputeClass personalizada existente.
  • No puedes usar la regla de prioridad podFamily en tus propias ComputeClasses. Esta regla solo está disponible en las clases de procesamiento de Autopilot integradas.
  • Las ComputeClasses integradas de Autopilot no admiten la habilitación de Confidential GKE Nodes para todo el clúster. Si habilitas los Confidential GKE Nodes para el clúster, los Pods nuevos que seleccionen las ComputeClasses integradas de Autopilot permanecerán en el estado Pending de forma indefinida.

Roles y permisos requeridos

Para obtener los permisos que necesitas para implementar ComputeClasses, pídele a tu administrador que te otorgue el rol de IAM Desarrollador de Kubernetes Engine (roles/container.developer) en tu clúster o proyecto . Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Selecciona una ComputeClass de Autopilot en una carga de trabajo

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

  1. Guarda el siguiente Deployment de ejemplo 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"

    Reemplaza COMPUTE_CLASS por el nombre de la clase de procesamiento que deseas usar. Este valor puede ser cualquiera de los siguientes:

  2. Implementa la carga de trabajo:

    kubectl apply -f autopilot-cc-deployment.yaml

  3. Para verificar que los Pods usen Autopilot, comprueba los nombres de los nodos host:

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

    El resultado es similar a este:

    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- en la columna Nodo indica que Autopilot administra el nodo.

Configura una ComputeClass de Autopilot personalizada

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

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

Crea una nueva ComputeClass personalizada de Autopilot

  1. Guarda el siguiente manifiesto de ComputeClass de ejemplo 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 implementas en un clúster de Autopilot, GKE lo ignorará.
    • priorities: Define un array de tres configuraciones diferentes de la familia de máquinas N2.
    • activeMigration: Permite que GKE migre los Pods a configuraciones que tienen una prioridad más alta en la lista cuando los recursos están disponibles.
    • whenUnsatisfiable: El valor de DoNotScaleUp en este campo hace que sea obligatorio que GKE use una de las reglas en el campo priorities para los nodos nuevos. Si no se puede cumplir con ninguna de estas reglas de prioridad, GKE deja el Pod en estado Pending hasta que haya recursos disponibles. DoNotScaleUp es el valor predeterminado y recomendado para este campo.

  2. Implementa ComputeClass:

    kubectl apply -f autopilot-n2-class.yaml

  3. Verifica que exista la ComputeClass:

    kubectl get computeclasses

    El resultado es similar a este:

    NAME                  AGE
autopilot-n2-class    3s

Habilita Autopilot para una ComputeClass personalizada existente

Puedes habilitar Autopilot en las ComputeClasses personalizadas existentes que se encuentran en un clúster estándar y tienen el campo nodePoolAutoCreation.enabled en la especificación establecido en true. Habilitar Autopilot en una clase de procesamiento que se encuentra 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 para un ComputeClass existente, GKE usa Autopilot para ejecutar los Pods nuevos que seleccionan el ComputeClass. Si tienes Pods existentes en nodos estándar que seleccionan la ComputeClass de Autopilot, esos Pods usarán Autopilot solo cuando se vuelvan a crear.

Para actualizar una ComputeClass personalizada existente para usar el modo Autopilot, sigue estos pasos:

  1. En un editor de texto, actualiza el archivo de manifiesto de tu ComputeClass existente para agregar el campo spec.autopilot:

    spec:
  autopilot:
    enabled: true

  2. Reemplaza el recurso ComputeClass existente en la API de Kubernetes por la especificación actualizada:

    kubectl replace --force -f PATH_TO_UPDATED_MANIFEST

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

  3. Para activar la creación de nodos nuevos, vuelve a crear las cargas de trabajo que usan la clase de procesamiento.

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 existente que se haya creado antes de la actualización.

Verifica que tu carga de trabajo use Autopilot

  • Obtén una lista de los Pods de tu clúster con el comando kubectl get:

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

    El resultado es similar a este:

    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 ejecuta en modo Autopilot.

Aplica una ComputeClass de Autopilot de forma predeterminada

GKE te permite establecer una ComputeClass como la 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 seleccionan de forma explícita una ComputeClass diferente. Establecer una ComputeClass de Autopilot como predeterminada significa que puedes ejecutar todos los Pods en un espacio de nombres en modo Autopilot de forma predeterminada, a menos que la carga de trabajo seleccione una opción diferente.

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

¿Qué sigue?