Controlar los atributos de los nodos autoescalados con ComputeClasses personalizados

En esta página 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 personalizados. Ya deberías conocer el concepto de ComputeClass personalizado. Para obtener más información, consulta Acerca de las ComputeClasses personalizadas.

Esta página está dirigida 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íficos.

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:

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 gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.

Caso de ejemplo de ComputeClasses

En esta página se presenta un ejemplo de situación en la que se define una clase de cálculo 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 N4 Spot 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, se define una clase de cálculo. Después, 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 tus grupos de nodos se aprovisionan automáticamente, como se indica a continuación:

  • Grupos de nodos gestionados por el aprovisionamiento automático de nodos: no se requiere ninguna configuración manual. El aprovisionamiento automático de nodos realiza automáticamente los pasos de configuración de ComputeClass. Para obtener más información, consulta Aprovisionamiento automático de nodos y ComputeClasses.
  • Grupos de nodos creados manualmente: requieren configuración manual. Debes añadir etiquetas y taints de nodo a los grupos de nodos que hayas creado manualmente para asociar los nodos a una ComputeClass específica. Para obtener más información, consulta Configurar grupos de nodos creados manualmente para usar ComputeClass.

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.

Usar ComputeClasses con grupos de nodos aprovisionados automáticamente

En esta sección se explica cómo definir una ComputeClass en un clúster que usa el aprovisionamiento automático de nodos.

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

Cuando despliegas pods que solicitan este 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 nuevos 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 VMs de Spot para el tipo de máquina personalizado n4-custom-8-20480 y recurre a las VMs bajo demanda 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

Para obtener más información sobre cómo funciona el aprovisionamiento automático de nodos con clases de cálculo personalizadas, consulta Aprovisionamiento automático de nodos y ComputeClasses.

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 disponible 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 la clase de computación en las especificaciones de los pods o, de forma opcional, definirla como la clase de computación predeterminada en un espacio de nombres específico.

Solicitar una ComputeClass en una carga de trabajo

Para solicitar un ComputeClass en una carga de trabajo, añade un selector de nodos para esa clase de cálculo en tu manifiesto.

  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 clase de cálculo se ejecuten en los 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