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

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Establece la configuración de gcloud predeterminada mediante uno de los siguientes métodos:

  • Usa gcloud init si deseas ver una explicación sobre cómo configurar parámetros predeterminados.
  • Usa gcloud config para establecer el ID, la zona y la región del proyecto de manera individual.

Usa gcloud init

  1. Ejecuta gcloud init y sigue las instrucciones:

    gcloud init

    Si usas SSH en un servidor remoto, usa la marca --console-only para evitar que el comando abra un navegador:

    gcloud init --console-only
  2. Sigue las instrucciones a fin de autorizar a gcloud para que use tu cuenta de Google Cloud.
  3. Crea una configuración nueva o selecciona una existente.
  4. Elige un proyecto de Google Cloud.
  5. Elige una zona predeterminada de Compute Engine.

Usa gcloud config

  • 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 la 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 el 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, cluster-name es el nombre que eliges para el 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, cluster-name es el nombre del clúster.

Obtén recomendaciones sobre recursos

En este ejercicio creas un VerticalPodAutoscaler que tiene un updateMode establecido como “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.

Inhabilita contenedores específicos

En este ejercicio, creas un VerticalPodAutoscaler que tiene un contenedor específico inhabilitado. Luego, creas una implementación que tiene un pod con dos contenedores. Cuando se crea el pod, el recurso VerticalPodAutoscaler crea y aplica una recomendación solo para un contenedor, de manera que ignora el que se inhabilitó.

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

apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: my-opt-vpa
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind:       Deployment
    name:       my-opt-deployment
  updatePolicy:
    updateMode: "Auto"
  resourcePolicy:
    containerPolicies:
    - containerName: my-opt-sidecar
      mode: "Off"

Ten en cuenta que el VerticalPodAutoscaler tiene información adicional en la sección resourcePolicy. mode "Off" desactiva las recomendaciones de un contenedor con un nombre especificado, en este caso my-opt-sidecar.

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

kubectl create -f my-opt-vpa.yaml

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-opt-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-opt-deployment
  template:
    metadata:
      labels:
        app: my-opt-deployment
    spec:
      containers:
      - name: my-opt-container
        image: nginx
      - name: my-opt-sidecar
        image: busybox
        command: ["sh","-c","while true; do echo Doing sidecar stuff!; sleep 60; done"]

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

kubectl create -f my-opt-deployment.yaml

Espera un minuto y, luego, visualiza el VerticalPodAutoscaler:

kubectl get vpa my-opt-vpa --output yaml

En el resultado, se muestran recomendaciones para las solicitudes de CPU y memoria:

...
  recommendation:
    containerRecommendations:
    - containerName: my-opt-container
...

Ten en cuenta que solo hay recomendaciones para un contenedor. No hay recomendaciones para my-opt-sidecar debido a que el contenedor se inhabilita.

El recurso VerticalPodAutoscaler nunca actualiza los recursos en los contenedores inhabilitados. Si esperas unos minutos, el pod se vuelve a crear, pero solo un contenedor tiene solicitudes de recursos actualizadas.

Actualiza 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-auto-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 uno de los pods en ejecución:

kubectl get pod pod-name --output yaml

En el ejemplo anterior, pod-name es el nombre de uno de tus pods.

En la salida, puedes ver que 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