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 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. 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 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 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 que se describen en este documento.
  • Usa un clúster de GKE Standard que ejecute la versión 1.34.1-gke.1829001 o posterior. 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.

  • 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

  • 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.
  • 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.
  • 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 o 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 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 estándar 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 el 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 si tus cargas de trabajo requieren hardware específico para ejecutarse de manera óptima, como GPU 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 n4-class.yaml:

    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.

  2. Implementa ComputeClass:

    kubectl apply -f n4-class.yaml

  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

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?