Cómo configurar el ajuste de escala automático vertical de pod

En esta página se explica cómo configurar el ajuste de escala automático vertical de pod en un clúster de Google Kubernetes Engine. El ajuste de escala automático vertical de pod 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

Como preparación para esta tarea, realiza los siguientes pasos:

  • Asegúrate de habilitar la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Asegúrate de instalar el SDK de Cloud.
  • Configura el ID del proyecto predeterminado:
    gcloud config set project [PROJECT_ID]
  • Si trabajas con clústeres por zona, configura tu zona de procesamiento predeterminada:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Si trabajas con clústeres por región, configura 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

Cómo habilitar el ajuste de escala automático vertical de pod para un clúster

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

gcloud beta container clusters create [CLUSTER_NAME] --enable-vertical-pod-autoscaling

en el que [CLUSTER_NAME] es el nombre que eliges para tu clúster.

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

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

en el que [CLUSTER_NAME] es el nombre del clúster.

Cómo obtener recomendaciones sobre recursos

En este ejercicio, creas un VerticalPodAutoscaler que tiene un updateMode en “Apagado”. 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 el 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/v1beta1
kind: VerticalPodAutoscaler
metadata:
  name: my-rec-vpa
spec:
  selector:
    matchLabels:
      purpose: try-recommend
  updatePolicy:
    updateMode: "Off"

Guarda el manifiesto en un archivo con el nombre 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: extensions/v1beta1
kind: Deployment
metadata:
  name: my-rec-deployment
  labels:
    purpose: try-recommend
spec:
  replicas: 2
  template:
    metadata:
      labels:
        purpose: try-recommend
    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 a VerticalPodAutoscaler, porque la etiqueta purpose: try-recommend coincide con el selector del VerticalPodAutoscaler.

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

kubectl create -f my-rec-deployment.yaml

Espera un minuto y, luego, mira 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: extensions/v1beta1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    purpose: try-auto-requests
spec:
  replicas: 2
  template:
    metadata:
      labels:
        purpose: try-auto-requests
    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 con el nombre my-deployment.yaml y crea la implementación:

kubectl create -f my-deployment.yaml

Enumera los pods en ejecución:

kubectl get pods

El resultado muestra los nombres de los pods en my-deployment:

NAME                            READY     STATUS             RESTARTS   AGE
my-deployment-cbcdd49fb-d6bf9   1/1       Running            0          8s
my-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/v1beta1
kind: VerticalPodAutoscaler
metadata:
  name: my-vpa
spec:
  selector:
    matchLabels:
      purpose: try-auto-requests
  updatePolicy:
    updateMode: "Auto"

En el manifiesto, el campo selector determina que cualquier pod con el nombre purpose: try-auto-requests pertenece a este VerticalPodAutoscaler.

El campo updateMode tiene un valor de Auto, que significa que el VerticalPodAutoscaler puede actualizar los requisitos de CPU y memoria durante la vida útil del 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 con el nombre my-vpa.yaml y crea el VerticalPodAutoscaler:

kubectl create -f my-vpa.yaml

Espera unos minutos y vuelve a ver 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 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 funcionará de manera óptima si requiere 587 millicores de CPU y 262,144 KB de memoria.

El VerticalPodAutoscaler usa las recomendaciones lowerBound y upperBound para decidir si debe borrar un pod y reemplazarlo 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.

Los selectores no se deben superponer

El VerticalPodAutoscaler tiene un campo selector que especifica cuáles son los pods que pertenecen al VerticalPodAutoscaler. Si tienes más de un VerticalPodAutoscaler, asegúrate de que los selectores no se superpongan.

Por ejemplo, considera estos dos VerticalPodAutoscalers:

...
kind: VerticalPodAutoscaler
metadata:
  name: my-vpa-1
spec:
  selector:
    matchLabels:
      app: metrics
      department: engineering
 

...
kind: VerticalPodAutoscaler
metadata:
  name: my-vpa-2
spec:
  selector:
    matchLabels:
      department: engineering
 

Esto sería un problema, ya que cualquier pod con la etiqueta app: metrics y con la etiqueta department: engineering estaría administrado por ambos VerticalPodAutoscalers.

Qué sigue

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

Enviar comentarios sobre...