Controlar los atributos de los nodos autoescalados con clases de cálculo personalizadas

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 clases de computación personalizadas. Ya deberías conocer el concepto de clases de computación personalizadas. Para obtener más información, consulta el artículo Información sobre las clases de cálculo 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 clases de computación específicas.

Acerca de las clases de cálculo personalizadas

Las clases de computación personalizadas 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 una clase de cálculo personalizada 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 el artículo Acerca de las clases de computación 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.

Ejemplo de situación de clases de cálculo

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 clases de computación que cumplan esos requisitos. Para ver descripciones completas de todas las opciones de clases de computación y las consideraciones especiales, consulta el artículo Acerca de las clases de computación 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 N2 de Compute Engine

Según el ejemplo, decides que quieres una clase de cálculo que haga lo siguiente:

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

Configurar una clase de cálculo en el modo Autopilot

En Autopilot de GKE, defines una clase de computación, la implementas en el clúster y solicitas esa clase de computación 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: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

Configurar una clase de cálculo en modo Estándar

En los clústeres del modo estándar de GKE, se define una clase de cálculo y, después, es posible que tengas que realizar una configuración manual para asegurarte de que los pods de la clase de cálculo 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 la clase de computación. Para obtener más información, consulta Aprovisionamiento automático de nodos y clases de computación.
  • 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 clase de computación específica. Para obtener más información, consulta Configurar manualmente grupos de nodos para usar clases de cálculo.

Usar clases de computación con grupos de nodos creados manualmente

En esta sección se muestra cómo definir una clase de cálculo 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: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true

  2. Crea un grupo de nodos con escalado automático que use máquinas virtuales de Spot y asócialo a la clase de cálculo:

    gcloud container node-pools create cost-optimized-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n2-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 la clase de cálculo:

    gcloud container node-pools create on-demand-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n2-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 clase de computación 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 clases de computación con pools de nodos aprovisionados automáticamente

En esta sección se muestra cómo definir una clase de cálculo 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: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

Cuando despliegues pods que soliciten esta clase de computación 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 nuevos grupos de nodos que cumplen los requisitos de hardware de la clase de computación.

Para obtener más información sobre cómo funciona el aprovisionamiento automático de nodos con clases de cálculo personalizadas, consulta el artículo Aprovisionamiento automático de nodos y 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 para la eliminación mediante el campo autoscalingPolicy de la definición de la clase de cálculo, como en el siguiente ejemplo:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    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 una clase de Compute en un clúster

Una vez que hayas definido una clase de cálculo, despliégala en el clúster:

kubectl apply -f compute-class.yaml

Esta clase de computación 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 clase de computación en una carga de trabajo

Para solicitar una clase de computación en una carga de trabajo, añade un selector de nodos para esa clase de computación 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 despliegas esta carga de trabajo, GKE añade automáticamente una tolerancia a los pods que corresponde al taint de nodo de la clase de computación solicitada. Esta tolerancia asegura que solo los pods que soliciten la clase de cálculo se ejecuten en los nodos de clase de cálculo.

Actualizar una clase de cálculo implementada

Para actualizar una clase de Compute desplegada, modifica el manifiesto YAML de la clase de Compute. 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 clase de computación actualizada, 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 clase de computación usa la migración activa y si los pods pueden migrarse.

Siguientes pasos