Controla los atributos de los nodos con ajuste de escala automático con ComputeClasses personalizadas

En este documento, se muestra cómo controlar la infraestructura de procesamiento y el comportamiento del ajuste de escala automático de los clústeres de Google Kubernetes Engine (GKE) según las necesidades específicas de tus cargas de trabajo con ComputeClasses personalizadas.

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

Acerca de las ComputeClasses personalizadas

Las ComputeClasses personalizadas son recursos personalizados de Kubernetes que te permiten definir prioridades para que GKE las siga cuando aprovisiona nodos para ejecutar tus cargas de trabajo. Puedes usar una ComputeClass personalizada para hacer lo siguiente:

  • Proporcionar a GKE un conjunto de prioridades para seguir de forma secuencial cuando se aprovisionan 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 parámetros del ajuste de escala automático para quitar los nodos subutilizados y consolidar las cargas de trabajo de manera eficiente en la capacidad de procesamiento existente.
  • Indícale a GKE que reemplace automáticamente las configuraciones de nodos menos preferidas por configuraciones de nodos más preferidas para lograr un rendimiento óptimo de la carga de trabajo.

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

Precios

El recurso personalizado ComputeClass se proporciona sin costo adicional en GKE. Se aplican las siguientes consideraciones de precios:

Limitaciones

El nombre de tu ComputeClass no puede comenzar con gke ni autopilot.

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.

Situación de ejemplo para ComputeClasses

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

Considera la siguiente situación de ejemplo:

  • Tu objetivo es optimizar los costos de ejecución de tus cargas de trabajo.
  • Tus cargas de trabajo son tolerantes a errores y no requieren un cierre ordenado ni un tiempo de ejecución extendido.
  • Tus cargas de trabajo necesitan al menos 64 CPU virtuales para ejecutarse de manera óptima
  • Estás limitado a la serie de máquinas N4 de Compute Engine

Según la situación de ejemplo, decides que quieres una ComputeClass que haga lo siguiente:

  • Prioriza los nodos Spot N4 que tienen al menos 64 CPU virtuales
  • Permite que GKE recurra a cualquier nodo N4 Spot, independientemente de la capacidad de procesamiento
  • Si no hay nodos N4 Spot disponibles, permite que GKE use nodos N4 según demanda
  • Le indica a GKE que mueva tus cargas de trabajo a los nodos Spot cuando vuelvan a estar disponibles

Configura un ComputeClass en modo Autopilot

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

Guarda el siguiente 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

Configura un ComputeClass en el modo estándar

En los clústeres del modo GKE Standard, es posible que debas realizar una configuración manual para asegurarte de que los Pods de ComputeClass se programen según lo esperado. La configuración manual depende de si tus grupos de nodos se crean automáticamente, de la siguiente manera:

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

  1. En el caso de los clústeres del modo estándar que ejecutan una versión anterior a la 1.33.3-gke.1136000 y no están inscritos en el canal de versiones rápidas, habilita el aprovisionamiento automático de nodos a nivel del 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 implementas Pods que solicitan este ejemplo de ComputeClass y se deben crear nodos nuevos, GKE prioriza la creación de nodos en el orden de los elementos del campo priorities. Si es necesario, GKE crea grupos de nodos nuevos que cumplen con los requisitos de hardware de ComputeClass.

También puedes especificar un tipo personalizado de máquina preciso en tus prioridades. Para usar tipos de máquinas personalizados, se requiere la versión 1.33.2-gke.1111000 o posterior de GKE. En el siguiente ejemplo, se configura una ComputeClass que prioriza las VMs Spot para el tipo de máquina personalizado n4-custom-8-20480 y recurre a las VMs a pedido del mismo tipo si no hay capacidad de Spot 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

Usa ComputeClasses con grupos de nodos creados de forma manual

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

  1. Guarda el siguiente 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 nuevo grupo de nodos con ajuste de escala automático que use VMs Spot y asócialo con 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"

    Reemplaza lo siguiente:

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

  3. Crea un nuevo grupo de nodos con ajuste de escala automático con VMs según demanda y asócialo con la 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 se deben crear nodos nuevos, 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 grupo de nodos on-demand-pool.

Para obtener más detalles sobre cómo interactúan los grupos de nodos creados de forma manual con las ComputeClasses personalizadas, consulta Configura grupos de nodos creados de forma manual para el uso de ComputeClass.

Personaliza los umbrales de ajuste de escala automático para la consolidación de nodos

De forma predeterminada, GKE quita los nodos poco utilizados y reprograma tus cargas de trabajo en otros nodos disponibles. Puedes personalizar aún más los umbrales y el tiempo después del cual un nodo se convierte en candidato para la eliminación con el campo autoscalingPolicy en 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 subutiliza en un 70% de su capacidad disponible de CPU y memoria durante más de cinco minutos. Para obtener una lista de los parámetros disponibles, consulta Configura parámetros de ajuste de escala automático para la consolidación de nodos.

Implementa un objeto ComputeClass en un clúster

Después de definir un ComputeClass, impleméntalo en el clúster:

kubectl apply -f compute-class.yaml

Esta ComputeClass está lista para usarse en el clúster. Puedes solicitar ComputeClass en las especificaciones de Pod o, de manera opcional, establecerla como la ComputeClass predeterminada en un espacio de nombres específico.

Solicita una ComputeClass en una carga de trabajo

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

  1. Guarda el siguiente 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. Implementa la carga de trabajo:

    kubectl apply -f cc-workload.yaml

Cuando implementas esta carga de trabajo, GKE agrega automáticamente una tolerancia a los Pods que corresponde al taint del nodo para la ComputeClass solicitada. Esta tolerancia garantiza que solo los Pods que soliciten la ComputeClass se ejecuten en nodos de ComputeClass.

Actualiza una ComputeClass implementada

Para actualizar una ComputeClass implementada, modifica el manifiesto YAML de la ComputeClass. Luego, implementa el manifiesto modificado ejecutando el siguiente comando:

kubectl apply -f PATH_TO_FILE

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

Cuando implementas tu ComputeClass actualizada, GKE usa la configuración actualizada para crear nodos nuevos. GKE no modifica ningún nodo existente con la configuración actualizada.

Con el tiempo, es posible que GKE mueva los Pods existentes a nodos que usen tu configuración actualizada si ComputeClass usa la migración activa y si los Pods existentes son aptos para migrar.

¿Qué sigue?