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

Los administradores de clústeres y los operadores de aplicaciones pueden obtener los beneficios de Autopilot de Google Kubernetes Engine (GKE), como los precios y la configuración preestablecida, en los clústeres del modo Standard. En este documento, 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 ComputeClasses de Autopilot

GKE proporciona recursos personalizados de Kubernetes llamados ComputeClasses que se pueden implementar en tu clúster como cualquier otro recurso de Kubernetes. Una 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 cualquier nodo nuevo debe 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 e incluyen muchos de los parámetros de configuración de seguridad y funciones predeterminadas 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 podrías notar cuando implementas esas cargas de trabajo, consulta Acerca de las cargas de trabajo del modo Autopilot en GKE Standard.

Tipos de ComputeClasses 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 existente para usar el modo Autopilot. El tipo de ComputeClass de Autopilot que uses 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 de Autopilot integradas, que colocan 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 opción, 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 la regla de prioridad de ComputeClass que usa GKE para crear nodos para tus cargas de trabajo. 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 deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos de este documento.

Requisitos

  • Tu clúster debe ejecutar una de las siguientes versiones de GKE:

    • Para usar Autopilot en ComputeClasses, el clúster debe ejecutar la versión 1.34.1-gke.1829001 o una posterior.
    • Para usar reglas de prioridad podFamily en ComputeClasses de Autopilot personalizadas, el clúster debe ejecutar la versión 1.35.2-gke.1485000 o una posterior.

  • 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 nodos de GKE protegidos, y están habilitados de forma predeterminada.

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

  • Si usas NetworkPolicies de Kubernetes, tu clúster debe usar GKE Dataplane V2. De forma predeterminada, todos los clústeres nuevos usan GKE Dataplane V2.

    Si tu clúster no usa GKE Dataplane V2, debes inhabilitar la aplicación de la política de red.

Limitaciones

  • La familia de Pods general-purpose-arm y la clase de procesamiento autopilot-arm solo están disponibles a través de clústeres de Autopilot. Los clústeres Standard con nodos de Autopilot serán compatibles en una versión posterior.
  • Para actualizar las ComputeClasses existentes en el clúster para usar el modo Autopilot, debes volver a crear esas ComputeClasses con una especificación actualizada. Para obtener más información, consulta Habilita Autopilot para una ComputeClass personalizada existente.
  • Las ComputeClasses de Autopilot integradas no admiten la habilitación de nodos de GKE protegidos para todo el clúster. Si habilitas los nodos de GKE protegidos para el clúster, los Pods nuevos que seleccionen las ComputeClasses de Autopilot integradas permanecerán en el estado Pending de forma indefinida.
  • No se admite la aplicación de la política de red de Calico. Debes usar GKE Dataplane V2 o inhabilitar la aplicación de la política de red.
  • El nombre de tu ComputeClass no puede comenzar con gke ni autopilot, que son prefijos reservados.

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

Modifica los clústeres para cumplir con los requisitos de Autopilot

Puedes usar la Google Cloud consola para verificar si tu clúster Standard cumple con todos los requisitos para ejecutar cargas de trabajo en modo Autopilot. También puedes usar la Google Cloud consola para modificar el clúster de modo que cumpla con estos requisitos.

Modifica un clúster existente

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

    Ir a clústeres de Kubernetes

  2. En la fila del clúster que deseas modificar, haz clic en Más acciones > Editar. Se abre la página Detalles del clúster.

  3. En la sección Conceptos básicos del clúster, busca la sección Compatibilidad de la clase de procesamiento de Autopilot.

    Si esta sección muestra Habilitado, el clúster ya es compatible con Autopilot. Ve a la sección Selecciona una ComputeClass de Autopilot en una carga de trabajo.

  4. Si la sección Compatibilidad de la clase de procesamiento de Autopilot muestra Inhabilitado, haz clic en Editar la compatibilidad de la clase de procesamiento de Autopilot.

    Si esta sección no está disponible para editar, tu clúster usa un parámetro de configuración permanente que no es compatible con el modo Autopilot. Por ejemplo, no puedes modificar los clústeres para que sean nativos de la VPC después de crearlos. Si no puedes interactuar con la sección Compatibilidad de la clase de procesamiento de Autopilot, debes crear un clúster nuevo.

  5. En el panel Compatibilidad de la clase de procesamiento de Autopilot que se abre, revisa la configuración del clúster que debe cambiar para cumplir con los requisitos del modo Autopilot.

  6. Haz clic en Habilitar la clase de procesamiento de Autopilot. GKE modifica el clúster según sea necesario.

Modifica un clúster nuevo

  1. En la Google Cloud consola de, accede a la página **Crear un clúster de Kubernetes**.

    Ir a Crear un clúster de Kubernetes

  2. En la página Conceptos básicos del clúster, busca la sección Maximiza las opciones de implementación con la clase de procesamiento de Autopilot. En esta sección, se muestra la configuración del clúster que debe cambiar para cumplir con los requisitos del modo Autopilot.

  3. Haz clic en Habilitar la clase de procesamiento de Autopilot. GKE modifica el clúster según sea necesario.

  4. Configura otros parámetros de configuración del clúster según tus requisitos. Si modificas un parámetro de configuración que hace que el clúster no sea compatible con Autopilot, aparecerá un mensaje de advertencia.

Selecciona una ComputeClass de Autopilot en una carga de trabajo

Puedes ejecutar una carga de trabajo en modo Autopilot en tu clúster Standard si seleccionas una ComputeClass que use el modo Autopilot. Para ejecutar una carga de trabajo en modo Autopilot, selecciona una de las siguientes opciones:

Console

  1. En la Google Cloud consola de, ve a la página Cargas de trabajo de GKE.

    Ir a Cargas de trabajo

  2. Haz clic en Implementar o Crear trabajo. Aparecerá la página de creación de cargas de trabajo para una Deployment o un trabajo.

  3. En la sección Nodos, selecciona Clase de procesamiento de Autopilot.

  4. En la sección Seleccionar clase de procesamiento, en la lista desplegable Clase de procesamiento, selecciona una ComputeClass que use el modo Autopilot. Esta ComputeClass puede ser cualquiera de las siguientes:

    • Una de las siguientes ComputeClasses de Autopilot integradas, que colocan cargas de trabajo de uso general en la plataforma de procesamiento optimizada para contenedores de Autopilot:

      • autopilot
      • autopilot-spot

    • Una ComputeClass que creas, como la n4-class ComputeClass que se describe en la sección Configura una ComputeClass de Autopilot personalizada.

  5. Configura y crea la carga de trabajo.

CLI de kubectl

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 una Deployment de ejemplo que selecciona una ComputeClass y verifica 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: "1Gi"

    Reemplaza COMPUTE_CLASS por el nombre de la clase de procesamiento que se usará. Este valor puede ser uno de los que se detallan a continuación:

    • Una de las siguientes ComputeClasses de Autopilot integradas, que colocan cargas de trabajo de uso general en la plataforma de procesamiento optimizada para contenedores de Autopilot:

      • autopilot
      • autopilot-spot

    • Una ComputeClass que creas, como la n4-class ComputeClass que se describe en la sección Configura una ComputeClass de Autopilot personalizada.

  2. Implementa la carga de trabajo:

    kubectl apply -f autopilot-cc-deployment.yaml

Configura una ComputeClass de Autopilot personalizada

Puedes configurar ComputeClasses personalizadas para usar Autopilot. Usa una ComputeClass de Autopilot personalizada en situaciones como las siguientes:

  • 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.
  • Deseas ajustar la configuración de los nodos, como las zonas o los taints, mientras usas la plataforma de procesamiento optimizada para contenedores de Autopilot.

Si tus cargas de trabajo no tienen estos requisitos, te recomendamos que uses una de las ComputeClasses de Autopilot integradas. Para seleccionar una ComputeClass de Autopilot integrada, consulta la sección anterior Selecciona una ComputeClass de Autopilot en una carga de trabajo.

Crea una ComputeClass de Autopilot personalizada nueva

  1. Guarda uno de los siguientes manifiestos de ComputeClass de ejemplo:

    • Selecciona máquinas específicas:

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

      Este manifiesto incluye los siguientes campos:

      • autopilot: Habilita el modo Autopilot para la ComputeClass. Si especificas este campo en una ComputeClass que implementas en un clúster de Autopilot, GKE ignora el campo.
      • priorities: Define un array de tres configuraciones diferentes de la familia de máquinas N4.
      • activeMigration: Permite que GKE migre Pods a configuraciones que tienen una prioridad más alta en la lista cuando los recursos estén disponibles.

    • Usa la plataforma de procesamiento optimizada para contenedores con modificaciones:

      apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: general-purpose-class
spec:
  autopilot:
    enabled: true
  priorities:
  - podFamily: general-purpose
  priorityDefaults:
    location:
      zones: ['us-central1-a','us-central1-b','us-central1-f']

      Este manifiesto incluye los siguientes campos:

      • autopilot: Habilita el modo Autopilot para la ComputeClass. Si especificas este campo en una ComputeClass que implementas en un clúster de Autopilot, GKE ignora el campo.
      • priorities.podFamily: Usa la regla de prioridad podFamily para ejecutar Pods en la plataforma de procesamiento optimizada para contenedores de Autopilot.
      • priorityDefaults.location: Define las zonas en las que GKE debe crear nodos para los Pods que usan la ComputeClass.

  2. Implementa la ComputeClass:

    kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST

    Reemplaza PATH_TO_COMPUTECLASS_MANIFEST por la ruta de acceso al manifiesto de ComputeClass del paso anterior.

  3. Verifica que exista la ComputeClass:

    kubectl get computeclasses

    El resultado es similar a este:

    NAME                  AGE
n4-class              3s

Habilita Autopilot para una ComputeClass personalizada existente

Puedes habilitar Autopilot en ComputeClasses personalizadas existentes que se encuentran en un clúster Standard. Habilitar Autopilot en una ComputeClass 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 una ComputeClass existente, GKE usa Autopilot para ejecutar Pods nuevos que seleccionen la ComputeClass. Si tienes Pods existentes en nodos Standard que seleccionan la ComputeClass de Autopilot, esos Pods usan Autopilot solo cuando se vuelven 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 a tu 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, cualquier nodo nuevo que cree GKE para esta ComputeClass usará 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

Selecciona una de las siguientes opciones:

Console

  1. En la Google Cloud consola de, ve a la página Cargas de trabajo de GKE.

    Ir a Cargas de trabajo

  2. Para tu carga de trabajo, verifica el valor en la columna Tipo de nodo. Si la carga de trabajo usa el modo Autopilot, este valor es Administrado por Autopilot.

CLI de kubectl

Verifica los nombres de los nodos que ejecutan tus Pods:

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.

Aplica una ComputeClass de Autopilot de forma predeterminada

Puedes establecer una ComputeClass integrada o personalizada como la ComputeClass predeterminada para un espacio de nombres o para todo un clúster. La ComputeClass predeterminada se aplica a cualquier Pod que no seleccione de forma explícita una ComputeClass diferente. Si estableces una ComputeClass de Autopilot como la predeterminada, puedes asegurarte de que todos los Pods se ejecuten en modo Autopilot, a menos que una carga de trabajo seleccione una opción diferente.

Si la ComputeClass que estableces como predeterminada usa reglas de prioridad podFamily, los Pods que no seleccionan una ComputeClass diferente pueden ejecutarse como Pods de Autopilot de uso general. Este método te permite usar el modelo de facturación basado en Pods de forma predeterminada en tu clúster o espacio de nombres, y es útil cuando muchas de tus cargas de trabajo no tienen requisitos de hardware especiales.

Para obtener más información, consulta Aplica ComputeClasses a Pods de forma predeterminada.

¿Qué sigue?