Ejecuta cargas de trabajo en modo Autopilot en clústeres estándar

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 este documento, se muestra cómo usar ComputeClasses para implementar una carga de trabajo de Autopilot en un clúster estándar. 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 un ComputeClass que tiene habilitado el campo autopilot, GKE ejecuta los Pods en modo Autopilot. Google administra los nodos que crea GKE, los cuales incluyen 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 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 la gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de la gcloud CLI no admitan la ejecución de los comandos que se describen en 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 de podFamily en ComputeClasses personalizadas de Autopilot, el clúster debe ejecutar la versión 1.35.2-gke.1485000 o 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 los nodos de GKE protegidos, que 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 los clústeres de Autopilot. Los clústeres estándar con nodos de Autopilot serán compatibles en una versión posterior.
  • Para actualizar las ComputeClasses existentes en el clúster para que usen el modo Autopilot, debes volver a crear esas ComputeClasses con una especificación actualizada. Para obtener más información, consulta Cómo habilitar Autopilot para una ComputeClass personalizada existente.
  • 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.
  • No se admite la aplicación de políticas 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 que cumplan con los requisitos de Autopilot

Puedes usar la consola de Google Cloud 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 consola Google Cloud para modificar el clúster y cumplir con estos requisitos.

Cómo modificar un clúster existente

  1. En la consola de Google Cloud , 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 abrirá la página Detalles del clúster.

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

    Si en esta sección se 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 en la sección Compatibilidad de la clase de procesamiento de Autopilot se muestra Inhabilitada, 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 con 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 consola de Google Cloud , ve a la página Crea un clúster de Kubernetes.

    Ir a Crea 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 muestran los parámetros de configuración del clúster que deben cambiarse 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 del clúster según tus requisitos. Si modificas un parámetro de configuración que hace que el clúster sea incompatible con Autopilot, aparecerá un mensaje de advertencia.

Selecciona una ComputeClass de Autopilot en una carga de trabajo

Para ejecutar una carga de trabajo en modo Autopilot en tu clúster estándar, selecciona una ComputeClass que use el modo Autopilot. Para ejecutar una carga de trabajo en el modo Autopilot, selecciona una de las siguientes opciones:

Console

  1. En la consola de Google Cloud , 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 Selecciona la clase de procesamiento, en la lista desplegable Clase de procesamiento, selecciona una ComputeClass que use el modo Autopilot. Este ComputeClass puede ser cualquiera de los siguientes:

  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 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: "1Gi"

    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

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 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 uno de los siguientes manifiestos de ejemplo de ComputeClass:

    • 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 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 N4.
      • 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.

    • 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 ComputeClass. Si especificas este campo en una ComputeClass que implementas en un clúster de Autopilot, GKE lo ignorará.
      • 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 ComputeClass.

  2. Implementa 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 lo siguiente:

    NAME                  AGE
n4-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. 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 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

Selecciona una de las siguientes opciones:

Console

  1. En la consola de Google Cloud , 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 lo 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- 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 explícitamente una ComputeClass diferente. Si estableces una ComputeClass de Autopilot como predeterminada, puedes asegurarte de que todos los Pods se ejecuten en el modo Autopilot, a menos que una carga de trabajo seleccione una opción diferente.

Si la ComputeClass que estableciste como predeterminada usa reglas de prioridad de podFamily, los Pods que no seleccionen 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 especiales de hardware.

Para obtener más información, consulta Cómo aplicar ComputeClasses a los Pods de forma predeterminada.

¿Qué sigue?