Configura el ajuste de escala automático vertical de pods

En esta página se explica cómo configurar el ajuste de escala automático vertical de pods en un clúster de Google Kubernetes Engine. El ajuste de escala automático vertical de pods implica ajustar los requisitos de CPU y memoria del pod.

Descripción general

Puedes usar el recurso personalizado VerticalPodAutoscaler para analizar y ajustar los requisitos de CPU y los requisitos de memoria de tus contenedores. Puedes configurar un VerticalPodAutoscaler para hacer recomendaciones de requisitos de CPU y memoria, o lo puedes configurar con el fin de hacer cambios automáticos a los requisitos de CPU y memoria.

Antes de comenzar

Sigue estos pasos a fin de prepararte para esta tarea:

  • Asegúrate de que habilitaste la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Asegúrate de que instalaste el SDK de Cloud.
  • Establece tu ID del proyecto predeterminado:
    gcloud config set project [PROJECT_ID]
  • Si trabajas con clústeres zonales, establece tu zona de procesamiento predeterminada:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Si trabajas con clústeres regionales, establece tu región de procesamiento predeterminada:
    gcloud config set compute/region [COMPUTE_REGION]
  • Actualiza gcloud a la versión más reciente:
    gcloud components update

Nota sobre las versiones de API

En esta guía se supone que tienes instalada la versión v1 de la API del escalador automático vertical de pods en tu clúster de Google Kubernetes Engine. Está disponible en la versión 1.14.7-gke.10 o superior y en 1.15.4-gke.15 o superior.

Te recomendamos que uses esta API. Si deseas obtener instrucciones para migrar desde versiones anteriores de API, consulta la guía de migración.

Habilita el ajuste de escala automático vertical de pods para un clúster

Para crear un clúster nuevo con ajuste de escala automático vertical de pods habilitado, ingresa el siguiente comando:

gcloud container clusters create [CLUSTER_NAME] --enable-vertical-pod-autoscaling --cluster-version=1.14.7

En el ejemplo anterior, se ilustra lo siguiente: [CLUSTER_NAME] es el nombre que eliges para tu clúster.

Si quieres habilitar el ajuste de escala automático vertical de pods para un clúster existente, ingresa el siguiente comando:

gcloud container clusters update [CLUSTER-NAME] --enable-vertical-pod-autoscaling

En el ejemplo anterior, se ilustra lo siguiente: [CLUSTER_NAME] es el nombre del clúster.

Obtén recomendaciones sobre recursos

En este ejercicio creas un VerticalPodAutoscaler que tiene un updateMode de “Desactivado” (Off). Luego, creas una implementación con dos pods, cada uno con un contenedor. Cuando se crean los pods, el VerticalPodAutoscaler analiza las necesidades de CPU y memoria de los contenedores y registra esas recomendaciones en su campo status. El VerticalPodAutoscaler no toma ninguna medida para actualizar los requisitos de recursos de los contenedores en ejecución.

A continuación, se muestra un manifiesto del VerticalPodAutoscaler:

apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: my-rec-vpa
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind:       Deployment
    name:       my-rec-deployment
  updatePolicy:
    updateMode: "Off"

Guarda el manifiesto en un archivo llamado my-rec-vpa.yaml y crea el VerticalPodAutoscaler:

kubectl create -f my-rec-vpa.yaml

A continuación, se muestra un manifiesto de implementación:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-rec-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-rec-deployment
  template:
    metadata:
      labels:
        app: my-rec-deployment
    spec:
      containers:
      - name: my-rec-container
        image: nginx

En el manifiesto puedes ver que no hay requisitos de CPU ni memoria. También puedes ver que los pods en la implementación pertenecen al VerticalPodAutoscaler, porque apunta al objetivo de kind: Deployment y name: my-rec-deployment.

Copia el manifiesto en un archivo llamado my-rec-deployment.yaml y crea la implementación:

kubectl create -f my-rec-deployment.yaml

Espera un minuto y, luego, visualiza el VerticalPodAutoscaler:

kubectl get vpa my-rec-vpa --output yaml

El resultado muestra recomendaciones para requisitos de CPU y memoria:

...
  recommendation:
    containerRecommendations:
    - containerName: my-rec-container
      lowerBound:
        cpu: 25m
        memory: 262144k
      target:
        cpu: 25m
        memory: 262144k
      upperBound:
        cpu: 7931m
        memory: 8291500k
...

Ahora que tienes los requisitos de CPU y memoria recomendados, es posible que quieras borrar la implementación, agregar requisitos de CPU y memoria al manifiesto de la implementación, y volver a iniciar la implementación.

Cómo actualizar requisitos de recursos de manera automática

En este ejercicio, creas una implementación que tiene dos pods. Cada pod tiene un contenedor que requiere 100 millicores de CPU y 50 MB de memoria. Luego, creas un VerticalPodAutoscaler que ajusta de manera automática los requisitos de CPU y memoria.

A continuación, se muestra un manifiesto de implementación:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-auto-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-rec-deployment
  template:
    metadata:
      labels:
        app: my-auto-deployment
    spec:
      containers:
      - name: my-container
        image: k8s.gcr.io/ubuntu-slim:0.1
        resources:
          requests:
            cpu: 100m
            memory: 50Mi
        command: ["/bin/sh"]
        args: ["-c", "while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done"]

Copia el manifiesto en un archivo llamado my-auto-deployment.yaml y crea la implementación:

kubectl create -f my-auto-deployment.yaml

Enumera los pods en ejecución:

kubectl get pods

En el resultado se muestran los nombres de los pods en my-deployment:

NAME                            READY     STATUS             RESTARTS   AGE
my-auto-deployment-cbcdd49fb-d6bf9   1/1       Running            0          8s
my-auto-deployment-cbcdd49fb-th288   1/1       Running            0          8s

Toma nota de los nombres de los pods para más adelante.

Los requisitos de CPU y memoria para la implementación son muy bajos, por eso la implementación se beneficiaría con un aumento de los recursos.

A continuación, se muestra un manifiesto de un VerticalPodAutoscaler:

apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: my-vpa
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind:       Deployment
    name:       my-auto-deployment
  updatePolicy:
    updateMode: "Auto"

En el manifiesto, el campo targetRef indica que cualquier pod que esté controlado por una implementación llamada my-deployment pertenece a este VerticalPodAutoscaler.

El campo updateMode tiene un valor de Auto, lo que significa que el VerticalPodAutoscaler puede actualizar los requisitos de CPU y memoria durante la vida útil de un pod. Esto implica que el VerticalPodAutoscaler puede borrar un pod, ajustar los requisitos de CPU y memoria y, luego, comenzar un pod nuevo.

Copia el manifiesto en un archivo llamado my-vpa.yaml y crea el VerticalPodAutoscaler:

kubectl create -f my-vpa.yaml

Espera unos minutos y vuelve a visualizar los pods en ejecución:

kubectl get pods

Observa que cambiaron los nombres de los pods. Si los nombres de los pods no cambiaron, espera un poco más y vuelve a enumerar los pods en ejecución.

Obtén información detallada sobre unos de los pods en ejecución:

kubectl get pod [POD_NAME] --output yaml

en el que [POD_NAME] es el nombre de uno de los pods.

En el resultado, puedes ver que el VerticalPodAutoscaler aumentó los requisitos de CPU y memoria. También puedes ver una anotación que documenta la actualización:

apiVersion: v1
kind: Pod
metadata:
  annotations:
    vpaUpdates: 'Pod resources updated by my-vpa: container 0: cpu capped to node
      capacity, memory capped to node capacity, cpu request, memory request'
...
spec:
  containers:
  ...
    resources:
      requests:
        cpu: 510m
        memory: 262144k
    ...

Obtén información detallada sobre el VerticalPodAutoscaler:

kubectl get vpa my-vpa --output yaml

El resultado muestra los tres conjuntos de recomendaciones para requisitos de CPU y memoria lower bound, target y upper bound:

...
  recommendation:
    containerRecommendations:
    - containerName: my-container
      lowerBound:
        cpu: 536m
        memory: 262144k
      target:
        cpu: 587m
        memory: 262144k
      upperBound:
        cpu: 27854m
        memory: "545693548"

La recomendación target determina que el contenedor se ejecutará de manera óptima si requiere 587 millicores de CPU de CPU y 262,144 KB de memoria.

El VerticalPodAutoscaler usa las recomendaciones lowerBound y upperBound para decidir si borra un pod y lo reemplaza por uno nuevo. Si un pod tiene requisitos menores que lower bound o mayores que upper bound, el VerticalPodAutoscaler borra el pod y los reemplaza por un pod que tenga las recomendaciones de target.

Próximos pasos

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Documentación de Kubernetes Engine