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

Los administradores de clústeres y los operadores de aplicaciones pueden disfrutar de las ventajas de Google Kubernetes Engine (GKE) Autopilot, como los precios y los ajustes preconfigurados, en los clústeres del modo Standard. En este documento se explica cómo usar ComputeClasses para desplegar una carga de trabajo de Autopilot en un clúster Standard. 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 en 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 CLI de gcloud, obtén la versión más reciente ejecutando el comando gcloud components update. Es posible que las versiones anteriores de la interfaz de línea de comandos de gcloud no admitan la ejecución de los comandos de este documento.
  • Usa un clúster Estándar de GKE que ejecute la versión 1.34.1-gke.1829001 o una posterior. 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 de GKE Standard que no se pueden ejecutar en nodos de Autopilot en clústeres Standard 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.

  • Si usas NetworkPolicies de Kubernetes, tu clúster debe usar Dataplane V2 de GKE. 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 políticas de red.

Limitaciones

  • Para actualizar las ComputeClasses de un clúster y que usen el modo Autopilot, debes volver a crear esas ComputeClasses con una especificación actualizada. Para obtener más información, consulta Habilitar Autopilot en un ComputeClass personalizado.
  • No puedes usar la regla de prioridad podFamily en tus 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.
  • 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 empezar por gke ni autopilot, que son prefijos reservados.

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 acceso a proyectos, carpetas y organizaciones.

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

Modificar clústeres para cumplir los requisitos de Autopilot

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

Modificar un clúster

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

    Ir a clústeres de Kubernetes

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

  3. En la sección Información básica de los clústeres, busca la sección Compatibilidad de la clase de computación de Autopilot.

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

  4. Si en la sección Compatibilidad con la clase de computación de Autopilot se muestra el valor Inhabilitada, haz clic en Editar compatibilidad con la clase de computación de Autopilot.

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

  5. En el panel Compatibilidad con la clase de computación de Autopilot que se abre, revisa los ajustes del clúster que deben cambiarse para cumplir los requisitos del modo Autopilot.

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

Modificar un clúster nuevo

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

    Ir a Crear un clúster de Kubernetes

  2. En la página Cluster basics (Conceptos básicos del clúster), busca la sección Maximize deployment options with Autopilot compute class (Maximizar las opciones de implementación con la clase de computación Autopilot). En esta sección se muestran los ajustes del clúster que deben cambiarse para cumplir los requisitos del modo Autopilot.

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

  4. Configura otros ajustes del clúster según tus requisitos. Si modificas un ajuste que hace que el clúster sea incompatible con Autopilot, aparecerá un mensaje de advertencia.

Seleccionar una ComputeClass de Autopilot en una carga de trabajo

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

Consola

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

    Ir a Cargas de trabajo

  2. Haz clic en Implementar o Crear trabajo. Se muestra la página de creación de carga de trabajo de una implementación o una tarea.

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

  4. En la sección Seleccionar clase de computación, en la lista desplegable Clase de computación, 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 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 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: "1Gi"

    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

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 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 despliegues en un clúster de Autopilot, GKE lo ignorará.
    • priorities: define una matriz de tres configuraciones diferentes de la familia de máquinas N4.
    • activeMigration: permite que GKE migre pods a configuraciones que tengan una prioridad más alta en la lista cuando haya recursos disponibles.

  2. Despliega el ComputeClass:

    kubectl apply -f n4-class.yaml

  3. Verifica que ComputeClass exista:

    kubectl get computeclasses

    El resultado debería ser similar al siguiente:

    NAME                  AGE
n4-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. Habilitar Autopilot en una ComputeClass que esté en un clúster 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 para 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

Selecciona una de las opciones siguientes:

Consola

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

    Ir a Cargas de trabajo

  2. En el caso de tu carga de trabajo, comprueba el valor de la columna Tipo de nodo. Si la carga de trabajo usa el modo Autopilot, este valor es Autopilot-managed.

CLI de kubectl

Comprueba los nombres de los nodos que ejecutan tus pods:

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.

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