Controlar los atributos de los nodos autoescalados con ComputeClasses personalizados

En este documento se explica cómo controlar la infraestructura de computación y el comportamiento del escalado automático de los clústeres de Google Kubernetes Engine (GKE) en función de las necesidades específicas de tus cargas de trabajo mediante ComputeClasses personalizadas.

Este documento está dirigido a administradores de plataformas que quieran definir de forma declarativa perfiles de escalado automático para nodos y a operadores de clústeres que quieran ejecutar sus cargas de trabajo en ComputeClasses específicas.

Acerca de las ComputeClasses personalizadas

Las Custom ComputeClasses son recursos personalizados de Kubernetes que te permiten definir prioridades para que GKE las siga al aprovisionar nodos para ejecutar tus cargas de trabajo. Puedes usar un ComputeClass personalizado para hacer lo siguiente:

  • Proporciona a GKE un conjunto de prioridades que debe seguir secuencialmente al aprovisionar nodos, cada uno con parámetros específicos, como una serie de máquinas de Compute Engine o una capacidad de recursos mínima.
  • Define los umbrales y los parámetros del autoescalado para eliminar los nodos infrautilizados y consolidar las cargas de trabajo de forma eficiente en la capacidad de computación disponible.
  • Indicar a GKE que sustituya automáticamente las configuraciones de nodos menos preferidas por configuraciones de nodos más preferidas para optimizar el rendimiento de las cargas de trabajo

Para conocer todas las opciones de configuración y cómo interactúan entre sí y con los modos Autopilot y Standard de GKE, consulta Acerca de las ComputeClasses personalizadas.

Precios

El recurso personalizado ComputeClass se proporciona sin coste adicional en GKE. Se aplican las siguientes consideraciones sobre los precios:

Limitaciones

El nombre de tu ComputeClass no puede empezar por gke ni por autopilot.

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.

Caso de ejemplo de ComputeClasses

En este documento se presenta un ejemplo de situación en la que se define una ComputeClass personalizada. En la práctica, debes tener en cuenta los requisitos de tus cargas de trabajo y tu organización, y definir ComputeClasses que cumplan esos requisitos. Para ver descripciones completas de todas las opciones de ComputeClasses y las consideraciones especiales, consulta el artículo Acerca de las ComputeClasses personalizadas.

Veamos un ejemplo:

  • Tu objetivo es optimizar los costes de ejecución de tus cargas de trabajo
  • Tus cargas de trabajo son tolerantes a fallos y no requieren un cierre suave ni un tiempo de ejecución prolongado.
  • Tus cargas de trabajo necesitan al menos 64 vCPUs para funcionar de forma óptima
  • Solo puedes usar la serie de máquinas N4 de Compute Engine

Según el ejemplo, decides que quieres una ComputeClass que haga lo siguiente:

  • Prioriza los nodos Spot N4 que tienen al menos 64 vCPUs
  • Permite que GKE vuelva a cualquier nodo Spot N4, independientemente de la capacidad de cálculo.
  • Si no hay nodos Spot N4 disponibles, permite que GKE use nodos N4 bajo demanda.
  • Indica a GKE que mueva tus cargas de trabajo a nodos Spot cuando vuelvan a estar disponibles.

Configurar una ComputeClass en el modo Autopilot

En Autopilot de GKE, defines una ComputeClass, la implementas en el clúster y solicitas esa ComputeClass en tus cargas de trabajo. GKE realiza los pasos de configuración de los nodos, como aplicar etiquetas y taints.

Guarda el siguiente archivo de manifiesto como compute-class.yaml:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

Configurar una ComputeClass en modo Estándar

En los clústeres del modo Estándar de GKE, es posible que tengas que realizar una configuración manual para asegurarte de que los pods de ComputeClass se programan según lo previsto. La configuración manual depende de si los grupos de nodos se crean automáticamente, como se indica a continuación:

Para que GKE cree automáticamente grupos de nodos para tu ComputeClass, sigue estos pasos:

  1. En los clústeres del modo Estándar que ejecutan una versión anterior a la 1.33.3-gke.1136000 y no están registrados en el canal de lanzamiento Rápido, habilita el aprovisionamiento automático de nodos a nivel de clúster.

  2. Guarda el siguiente manifiesto de ejemplo como compute-class.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

    Cuando despliegues pods que soliciten este ejemplo de ComputeClass y sea necesario crear nodos, GKE priorizará la creación de nodos en el orden de los elementos del campo priorities. Si es necesario, GKE crea grupos de nodos que cumplen los requisitos de hardware de ComputeClass.

También puedes especificar un tipo de máquina personalizado preciso en tus prioridades. Para usar tipos de máquinas personalizadas, se necesita la versión 1.33.2-gke.1111000 de GKE o una posterior. En el siguiente ejemplo se configura una ComputeClass que prioriza las máquinas virtuales de acceso puntual para el n4-custom-8-20480tipo de máquina personalizado y recurre a las máquinas virtuales bajo demanda del mismo tipo si no hay capacidad de acceso puntual disponible:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: custom-machine-type
spec:
  priorities:
  - machineType: n4-custom-8-20480
    spot: true
  - machineType: n4-custom-8-20480
    spot: false
  nodePoolAutoCreation:
    enabled: true

Usar ComputeClasses con grupos de nodos creados manualmente

En esta sección se muestra cómo definir una ComputeClass en un clúster que solo usa grupos de nodos creados manualmente.

  1. Guarda el siguiente archivo de manifiesto como compute-class.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true

  2. Crea un grupo de nodos con autoescalado que use máquinas virtuales Spot y asócialo a la ComputeClass:

    gcloud container node-pools create cost-optimized-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n4-standard-64 \
    --spot \
    --enable-autoscaling \
    --max-nodes=9 \
    --node-labels="cloud.google.com/compute-class=cost-optimized" \
    --node-taints="cloud.google.com/compute-class=cost-optimized:NoSchedule"

    Haz los cambios siguientes:

    • LOCATION: la ubicación de tu clúster.
    • CLUSTER_NAME: el nombre del clúster.

  3. Crea un grupo de nodos con escalado automático con VMs bajo demanda y asócialo a ComputeClass:

    gcloud container node-pools create on-demand-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n4-standard-64 \
    --enable-autoscaling \
    --max-nodes=9 \
    --num-nodes=0 \
    --node-labels="cloud.google.com/compute-class=cost-optimized" \
    --node-taints="cloud.google.com/compute-class=cost-optimized:NoSchedule"

Cuando implementas pods que solicitan esta ComputeClass y es necesario crear nodos, GKE prioriza la creación de nodos en el grupo de nodos cost-optimized-pool. Si no se pueden crear nodos nuevos, GKE crea nodos en el on-demand-pool grupo de nodos.

Para obtener más información sobre cómo interactúan los grupos de nodos creados manualmente con las clases de cálculo personalizadas, consulta Configurar grupos de nodos creados manualmente para usar clases de cálculo.

Personalizar los umbrales de autoescalado para la consolidación de nodos

De forma predeterminada, GKE elimina los nodos infrautilizados y vuelve a programar tus cargas de trabajo en otros nodos disponibles. Puedes personalizar aún más los umbrales y el tiempo que debe transcurrir para que un nodo se convierta en candidato a la eliminación mediante el campo autoscalingPolicy de la definición de ComputeClass, como en el siguiente ejemplo:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true
  autoscalingPolicy:
    consolidationDelayMinutes : 5
    consolidationThreshold    : 70

En este ejemplo, un nodo se convierte en candidato para la eliminación si se infrautiliza en un 70% de su capacidad de CPU y memoria disponibles durante más de cinco minutos. Para ver una lista de los parámetros disponibles, consulta Definir parámetros de escalado automático para la consolidación de nodos.

Desplegar un ComputeClass en un clúster

Una vez que hayas definido una ComputeClass, despliégala en el clúster:

kubectl apply -f compute-class.yaml

Esta ComputeClass ya se puede usar en el clúster. Puedes solicitar el ComputeClass en las especificaciones de Pod o, de forma opcional, definirlo como el ComputeClass predeterminado en un espacio de nombres específico.

Solicitar una ComputeClass en una carga de trabajo

Para solicitar una ComputeClass en una carga de trabajo, añade un selector de nodos para esa ComputeClass en tu manifiesto, como en los pasos siguientes:

  1. Guarda el siguiente archivo de manifiesto como cc-workload.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: custom-workload
spec:
  replicas: 2
  selector:
    matchLabels:
      app: custom-workload
  template:
    metadata:
      labels:
        app: custom-workload
    spec:
      nodeSelector:
        cloud.google.com/compute-class: cost-optimized
      containers:
      - name: test
        image: gcr.io/google_containers/pause
        resources:
          requests:
            cpu: 1.5
            memory: "4Gi"

  2. Despliega la carga de trabajo:

    kubectl apply -f cc-workload.yaml

Cuando despliegues esta carga de trabajo, GKE añadirá automáticamente una tolerancia a los pods que corresponda al taint de nodo de la ComputeClass solicitada. Esta tolerancia asegura que solo los pods que soliciten la ComputeClass se ejecuten en nodos de ComputeClass.

Actualizar un ComputeClass desplegado

Para actualizar una ComputeClass implementada, modifica el manifiesto YAML de la ComputeClass. A continuación, implementa el archivo de manifiesto modificado ejecutando el siguiente comando:

kubectl apply -f PATH_TO_FILE

Sustituye PATH_TO_FILE por la ruta al manifiesto modificado. Asegúrate de que el valor del campo name no cambie.

Cuando implementes tu ComputeClass actualizado, GKE usará la configuración actualizada para crear nodos. GKE no modifica ningún nodo con la configuración actualizada.

Con el tiempo, GKE puede mover los pods a nodos que usen la configuración actualizada si la ComputeClass usa la migración activa y si los pods se pueden migrar.

Siguientes pasos