Escalabilidad automática vertical de pods en Azure Kubernetes Service (AKS)

Artículo
12/26/2023

En este artículo se proporciona información general sobre el escalador automático vertical de pods (VPA) de Azure Kubernetes Service (AKS), que se basa en la versión de código abierto de Kubernetes. Cuando se configura, establece automáticamente las solicitudes de recursos y los límites de los contenedores por carga de trabajo en función del uso pasado. VPA libera CPU y memoria para los demás pods y ayuda a hacer un uso eficaz del clúster de AKS.

La escalabilidad automática vertical de pods proporciona recomendaciones sobre el uso de recursos a lo largo del tiempo. Para administrar aumentos repentinos en el uso de recursos, use el escalador automático horizontal de pods, que escala el número de réplicas de pod según sea necesario.

Ventajas

Vertical Pod Autoscaler proporciona las siguientes ventajas:

Analiza y ajusta los recursos de procesador y memoria para ajustar el tamaño correcto de las aplicaciones. VPA no solo es responsable del escalado vertical, sino también de la reducción vertical en función del uso de recursos a lo largo del tiempo.
Un pod se expulsa si necesita cambiar sus solicitudes de recursos si su modo de escalado está establecido en automático o volver a crear.
Establecimiento de restricciones de CPU y memoria para contenedores individuales mediante la especificación de una directiva de recursos
Garantiza que los nodos tienen los recursos correctos para la programación de pods.
Registro configurable de cualquier ajuste realizado en los recursos de procesador o memoria
Mejore el uso de recursos del clúster y libere CPU y memoria para otros pods.

Limitaciones

La escalabilidad automática vertical de pods admite como máximo 1 000 pods asociados a objetos VerticalPodAutoscaler por clúster.
VPA puede recomendar más recursos de los disponibles en el clúster. Como resultado, esta recomendación impide que el pod se asigne a un nodo y se ejecute, ya que el nodo no tiene recursos suficientes. Para superar esta limitación, establezca LimitRange en el número máximo de recursos disponibles por espacio de nombres, lo que garantiza que los pods no soliciten más recursos de los especificados. Además, puede establecer las recomendaciones máximas de recursos permitidos por pod en un objeto VerticalPodAutoscaler. Tenga en cuenta que VPA no puede superar completamente un problema de recursos de nodo insuficientes. El intervalo de límite es fijo, pero el uso de recursos de nodo cambia dinámicamente.
No se recomienda usar el escalador automático vertical de pods con el escalador automático horizontal de pods, que escala en función de las mismas métricas de uso de CPU y memoria.
El recomendador de VPA solo almacena hasta ocho días de datos históricos.
VPA no admite cargas de trabajo basadas en JVM debido a la visibilidad limitada del uso real de la memoria de la carga de trabajo.
No se recomienda ni se admite ejecutar su propia implementación de VPA junto con esta implementación administrada de VPA. Se admite tener un recomendador adicional o personalizado.
No se admiten actualmente contenedores de Windows de AKS.

Antes de empezar

El clúster de AKS ejecuta la versión 1.24 y posteriores de Kubernetes.
La CLI de Azure, versión 2.52.0 o posterior, instalada y configurada. Ejecute az --version para encontrar la versión. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.
kubectl debe estar conectado al clúster donde quiere instalar VPA.

Información general sobre VPA

Objeto API

Vertical Pod Autoscaler es un recurso de API del grupo de API de escalabilidad automática de Kubernetes. La versión admitida es 0.11 y superior, y se puede encontrar en el repositorio de escaladores automáticos de Kubernetes.

El objeto VPA consta de tres componentes:

Recomendador: supervisa el consumo de recursos actual y pasado y, en función de esta información, proporciona valores recomendados para las solicitudes o límites de CPU y memoria de los contenedores. El recomendador supervisa el historial de métricas, los eventos de memoria insuficiente (OOM) y la especificación de implementación de VPA y sugiere solicitudes justas. Al proporcionar una configuración adecuada de solicitudes y límites de recursos, los límites se elevan y reducen.
Actualizador: comprueba cuál de los pods administrados tiene los recursos correctos establecidos y, si no es así, los elimina para que sus controladores puedan volver a crearlos con las solicitudes actualizadas.
Controlador de admisión de VPA: establece las solicitudes de recursos correctas en los nuevos pods (creados o recreados por su controlador debido a la actividad del actualizador).

Controlador de admisión de VPA

El controlador de admisión de VPA es un binario que se registra como un webhook de admisión de mutación. Con cada pod creado, obtiene una solicitud del servidor de API y evalúa si hay una configuración de VPA coincidente, o busca una correspondiente y usa la recomendación actual para establecer solicitudes de recursos en el pod.

Un trabajo independiente se ejecuta fuera del controlador de admisión de VPA, llamado overlay-vpa-cert-webhook-check. overlay-vpa-cert-webhook-check se usa para crear y renovar los certificados y registrar el controlador de admisión de VPA como MutatingWebhookConfiguration.

Para lograr una alta disponibilidad, AKS admite dos réplicas de controlador de admisión.

Modos de operación de objetos de VPA

Se inserta un recurso de escalador automático vertical de pods por cada controlador cuyos requisitos de recursos quiera que se calculen automáticamente. Normalmente, se trata de una implementación. Hay cuatro modos en los que funcionan los VPA:

Auto: VPA asigna solicitudes de recursos durante la creación de pods y actualiza los pods existentes mediante el mecanismo de actualización preferido. Actualmente, Auto es equivalente a Recreate, y también es el modo predeterminado. Una vez que esté disponible la actualización sin reinicio ("in situ") de las solicitudes de pods, el modo Auto podrá utilizarla como mecanismo de actualización preferente. Al usar el modo Recreate, VPA expulsa un pod si necesita cambiar sus solicitudes de recursos. Esto puede hacer que los pods se reinicien todos a la vez, lo que provoca incoherencias de la aplicación. Puede limitar los reinicios y mantener la coherencia en esta situación mediante PodDisruptionBudget.
Recreate: VPA asigna solicitudes de recursos durante la creación de los pods y actualiza los pods existentes expulsándolos cuando los recursos solicitados difieren significativamente de la nueva recomendación (respetando el presupuesto de interrupción de pods, si se define). Este modo se usará en contadas ocasiones, solo si necesita asegurarse de que los pods se reinician cada vez que cambia la solicitud de recursos. De lo contrario, se prefiere el modo Auto, que puede aprovechar las actualizaciones sin reinicio una vez que estén disponibles.
Initial: VPA solo asigna solicitudes de recursos durante la creación de los pods y nunca cambia después.
Off: VPA no cambia automáticamente los requisitos de recursos de los pods. Las recomendaciones se calculan y se pueden inspeccionar en el objeto de VPA.

Patrón de implementación durante el desarrollo de aplicaciones

Un patrón de implementación común recomendado si no está familiarizado con VPA es realizar los pasos siguientes durante el desarrollo de aplicaciones con el fin de identificar sus características de uso de recursos únicos, probar VPA para comprobar que funciona correctamente y probarlo junto con otros componentes de Kubernetes para optimizar el uso de recursos del clúster.

Establezca UpdateMode = "Off" en el clúster de producción y ejecute VPA en modo de recomendación para que pueda probar VPA y familiarizarse con él. UpdateMode = "Off" puede evitar la introducción de una configuración incorrecta que puede provocar una interrupción.
Establezca primero la observabilidad mediante la recopilación de información de telemetría de uso real de recursos durante un período de tiempo determinado. Esto le ayuda a comprender el comportamiento y las señales de síntomas o problemas de los recursos de contenedores y pods influidos por las cargas de trabajo que se ejecutan en ellos.
Familiarícese con los datos de supervisión para comprender las características de rendimiento. En función de esta información, establezca las solicitudes o límites deseados en consecuencia y, luego, en la siguiente implementación o actualización.
Establezca el valor updateMode en Auto, Recreate o Initial, según sus requisitos.

Implementación, actualización o deshabilitación de VPA en un clúster

En esta sección, implementará, actualizará o deshabilitará Vertical Pod Autoscaler en el clúster.

Para habilitar VPA en un nuevo clúster, use el parámetro --enable-vpa con el comando az aks create.
```
az aks create -n myAKSCluster -g myResourceGroup --enable-vpa
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.
Opcionalmente, para habilitar VPA en un clúster existente, use el --enable-vpa con el comando [https://learn.microsoft.com/en-us/cli/azure/aks?view=azure-cli-latest#az-aks-update].
```
az aks update -n myAKSCluster -g myResourceGroup --enable-vpa 
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.
Opcionalmente, para deshabilitar VPA en un clúster existente, use el --disable-vpa con el comando [https://learn.microsoft.com/en-us/cli/azure/aks?view=azure-cli-latest#az-aks-update].
```
az aks update -n myAKSCluster -g myResourceGroup --disable-vpa
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.
Para comprobar que los pods de Vertical Pod Autoscaler se han creado correctamente, use el comando kubectl get.

kubectl get pods -n kube-system

La salida del comando incluye los siguientes resultados específicos de los pods de VPA. Los pods deben mostrar un estado en ejecución.

NAME                                        READY   STATUS    RESTARTS   AGE
vpa-admission-controller-7867874bc5-vjfxk   1/1     Running   0          41m
vpa-recommender-5fd94767fb-ggjr2            1/1     Running   0          41m
vpa-updater-56f9bfc96f-jgq2g                1/1     Running   0          41m

Prueba de la instalación de Vertical Pod Autoscaler

En los pasos siguientes se crea una implementación con dos pods, cada uno de los cuales ejecuta un único contenedor que solicita 100 millicores e intenta usar algo más de 500 millicores. También se crea una configuración de VPA que apunta a la implementación. El VPA observa el comportamiento de los pods y, al cabo de unos cinco minutos, estos se actualizan con una solicitud de CPU superior.

Cree un archivo denominado hamster.yaml y copie el siguiente manifiesto del ejemplo de Vertical Pod Autoscaler desde el repositorio de GitHub kubernetes/autoscaler.
Implemente el ejemplo de Vertical Pod Autoscaler hamster.yaml mediante el comando kubectl apply y especifique el nombre del manifiesto YAML:
```
kubectl apply -f hamster.yaml
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Ejecute el siguiente comando kubectl get para obtener los pods de la aplicación de ejemplo del hámster:

kubectl get pods -l app=hamster

La salida de ejemplo se parece a la siguiente:

hamster-78f9dcdd4c-hf7gk   1/1     Running   0          24s
hamster-78f9dcdd4c-j9mc7   1/1     Running   0          24s

Use el comando kubectl describe en uno de los pods para ver su reserva de CPU y memoria. Reemplace "exampleID" por uno de los identificadores de pod devueltos en la salida del paso anterior.
```
kubectl describe pod hamster-exampleID
```
La salida de ejemplo es un fragmento de código de la información sobre el clúster:
```
 hamster:
    Container ID:  containerd://
    Image:         k8s.gcr.io/ubuntu-slim:0.1
    Image ID:      sha256:
    Port:          <none>
    Host Port:     <none>
    Command:
      /bin/sh
    Args:
      -c
      while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done
    State:          Running
      Started:      Wed, 28 Sep 2022 15:06:14 -0400
    Ready:          True
    Restart Count:  0
    Requests:
      cpu:        100m
      memory:     50Mi
    Environment:  <none>
```
En este ejemplo, el pod tiene 100 millicpu y 50 mibibytes de memoria reservada. En esta aplicación de ejemplo, el pod necesita menos de 100 milicpu para ejecutarse, por lo que no hay capacidad de CPU disponible. Los pods también reservan mucha menos memoria de la necesaria. La implementación de vpa-recommender de Vertical Pod Autoscaler analiza los pods que hospedan la aplicación del hámster para ver si los requisitos de CPU y memoria son adecuados. Si se necesitan ajustes, vpa-updater vuelve a iniciar los pods con valores actualizados.
Espere a que el actualizador de VPA inicie un nuevo pod de hámster, proceso que debería tardar unos minutos. Puede supervisar los pods mediante el comando kubectl get.
```
kubectl get --watch pods -l app=hamster
```
Cuando se inicie un nuevo pod de hámster, describa el pod ejecutando el comando kubectl describe y vea las reservas actualizadas de CPU y memoria.
```
kubectl describe pod hamster-<exampleID>
```
La salida de ejemplo es un fragmento de código de la información que describe el pod:
```
State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```
En la salida anterior, puede ver que la reserva de CPU aumentó a 587 milicpu, lo que supera cinco veces el valor original. La memoria aumentó a 262 144 kilobytes, que es alrededor de 250 mibibytes, o cinco veces el valor original. Este pod no tenía los recursos necesarios y Vertical Pod Autoscaler corrigió la estimación con un valor mucho más adecuado.
Para ver las recomendaciones actualizadas de VPA, ejecute el comando kubectl describe para describir la información del recurso hamster-vpa.
```
kubectl describe vpa/hamster-vpa
```
La salida de ejemplo es un fragmento de código de la información sobre el uso de recursos:
```
 State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```

Establecimiento de solicitudes del escalador automático de pods

La escalabilidad automática vertical de pods usa el objeto VerticalPodAutoscaler para establecer automáticamente las solicitudes de recursos de los pods cuando updateMode está establecido en Automático. Puede establecer un valor diferente en función de sus requisitos y pruebas. En este ejemplo, updateMode se establece en Recreate.

Habilite VPA para el clúster con el siguiente comando: Reemplace el nombre del clúster myAKSCluster por el nombre del clúster de AKS y reemplace myResourceGroup por el nombre del grupo de recursos en el que se hospeda el clúster.
```
az aks update -n myAKSCluster -g myResourceGroup --enable-vpa
```

Cree un archivo denominado azure-autodeploy.yaml y cópielo en el siguiente código manifiesto.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vpa-auto-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vpa-auto-deployment
  template:
    metadata:
      labels:
        app: vpa-auto-deployment
    spec:
      containers:
      - name: mycontainer
        image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
        resources:
          requests:
            cpu: 100m
            memory: 50Mi
        command: ["/bin/sh"]
        args: ["-c", "while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done"]

Este manifiesto describe una implementación que tiene dos pods. Cada pod tiene un contenedor que solicita 100 milliCPU y 50 MiB de memoria.

Cree el pod con el comando kubectl create, tal como se muestra en el ejemplo siguiente:
```
kubectl create -f azure-autodeploy.yaml
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Ejecute el siguiente comando kubectl get para obtener los pods:

kubectl get pods

La salida es similar al ejemplo siguiente que muestra el nombre y el estado de los pods:

NAME                                   READY   STATUS    RESTARTS   AGE
vpa-auto-deployment-54465fb978-kchc5   1/1     Running   0          52s
vpa-auto-deployment-54465fb978-nhtmj   1/1     Running   0          52s

Cree un archivo denominado azure-vpa-auto.yaml y cópielo en el siguiente manifiesto que describe un objeto VerticalPodAutoscaler:
```
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: vpa-auto
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind:       Deployment
    name:       vpa-auto-deployment
  updatePolicy:
    updateMode: "Recreate"
```
El valor targetRef.name especifica que cualquier pod controlado por una implementación denominada vpa-auto-deployment pertenece a este objeto VerticalPodAutoscaler. El valor updateMode de Recreate significa que el controlador del escalador automático vertical de pods puede eliminar un pod, ajustar las solicitudes de CPU y memoria y, luego, iniciar un nuevo pod.
Aplique el manifiesto al clúster mediante el comando kubectl apply:
```
kubectl create -f azure-vpa-auto.yaml
```

Espere unos minutos y vea cómo se ejecutan de nuevo los pods mediante el comando kubectl get:

kubectl get pods

La salida es similar al ejemplo siguiente que muestra que los nombres de pod han cambiado y el estado de los pods:

NAME                                   READY   STATUS    RESTARTS   AGE
vpa-auto-deployment-54465fb978-qbhc4   1/1     Running   0          2m49s
vpa-auto-deployment-54465fb978-vbj68   1/1     Running   0          109s

Obtenga información detallada sobre uno de los pods en ejecución mediante el comando Kubectl get. Reemplace podName por el nombre de uno de los pods que recuperó en el paso anterior.

kubectl get pod podName --output yaml

La salida es similar al ejemplo siguiente, que muestra que el controlador de Vertical Pod Autoscaler ha aumentado la solicitud de memoria a 262144 k y la solicitud de CPU a 25 milliCPU.

apiVersion: v1
kind: Pod
metadata:
  annotations:
    vpaObservedContainers: mycontainer
    vpaUpdates: 'Pod resources updated by vpa-auto: container 0: cpu request, memory
      request'
  creationTimestamp: "2022-09-29T16:44:37Z"
  generateName: vpa-auto-deployment-54465fb978-
  labels:
    app: vpa-auto-deployment

spec:
  containers:
  - args:
    - -c
    - while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done
    command:
    - /bin/sh
    image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
    imagePullPolicy: IfNotPresent
    name: mycontainer
    resources:
      requests:
        cpu: 25m
        memory: 262144k

Para obtener información detallada sobre Vertical Pod Autoscaler y sus recomendaciones para CPU y memoria, use el comando kubectl get:
```
kubectl get vpa vpa-auto --output yaml
```
La salida se parece a la del ejemplo siguiente:
```
 recommendation:
  containerRecommendations:
  - containerName: mycontainer
    lowerBound:
      cpu: 25m
      memory: 262144k
    target:
      cpu: 25m
      memory: 262144k
    uncappedTarget:
      cpu: 25m
      memory: 262144k
    upperBound:
      cpu: 230m
      memory: 262144k
```
Los resultados muestran el atributo target que especifica que, para que el contenedor se ejecute de forma óptima, no es necesario cambiar la CPU ni el destino de memoria. Los resultados pueden variar en aquellos casos en los que se recomienda CPU y memoria de destino más elevadas.

El escalador automático vertical de pods usa los atributos lowerBound y upperBound para decidir si eliminar un pod y reemplazarlo por uno nuevo. Si un pod tiene solicitudes menores que el límite inferior o mayores que el límite superior, el escalador automático vertical de pods elimina el pod y lo reemplaza por uno que cumpla el atributo de destino.

Recomendador adicional para el escalador automático vertical de pods

En el VPA, uno de los componentes principales es el recomendador. Este componente proporciona recomendaciones para el uso de recursos en función del consumo de recursos en tiempo real. AKS implementa un recomendador cuando un clúster habilita el VPA. Puede implementar un recomendador personalizado o un recomendador adicional con la misma imagen que la predeterminada. La ventaja de tener un recomendador personalizado es que puede personalizar la lógica de recomendación. Con un recomendador adicional, puede dividir VPA en varios recomendadores si hay muchos objetos VPA.

El ejemplo siguiente es un recomendador adicional que se aplica al clúster de AKS existente. A continuación, configure el objeto VPA para usar el recomendador adicional.

Cree un archivo denominado extra_recommender.yaml y cópielo en el siguiente manifiesto:

apiVersion: apps/v1 
kind: Deployment 
metadata: 
  name: extra-recommender 
  namespace: kube-system 
spec: 
  replicas: 1 
  selector: 
    matchLabels: 
      app: extra-recommender 
  template: 
    metadata: 
      labels: 
        app: extra-recommender 
    spec: 
      serviceAccountName: vpa-recommender 
      securityContext: 
        runAsNonRoot: true 
        runAsUser: 65534 # nobody 
      containers: 
      - name: recommender 
        image: registry.k8s.io/autoscaling/vpa-recommender:0.13.0 
        imagePullPolicy: Always 
        args: 
          - --recommender-name=extra-recommender 
        resources: 
          limits: 
            cpu: 200m 
            memory: 1000Mi 
          requests: 
            cpu: 50m 
            memory: 500Mi 
        ports: 
        - name: prometheus 
          containerPort: 8942

Implemente el ejemplo de escalador automático vertical de pods de extra-recomender.yaml mediante el comando kubectl apply y especifique el nombre del manifiesto YAML.
```
kubectl apply -f extra-recommender.yaml 
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Cree un archivo denominado hamnster_extra_recommender.yaml y cópielo en el siguiente manifiesto:

apiVersion: "autoscaling.k8s.io/v1" 
kind: VerticalPodAutoscaler 
metadata: 
  name: hamster-vpa 
spec: 
  recommenders:  
    - name: 'extra-recommender' 
  targetRef: 
    apiVersion: "apps/v1" 
    kind: Deployment 
    name: hamster 
  updatePolicy: 
    updateMode: "Auto" 
  resourcePolicy: 
    containerPolicies: 
      - containerName: '*' 
        minAllowed: 
          cpu: 100m 
          memory: 50Mi 
        maxAllowed: 
          cpu: 1 
          memory: 500Mi 
        controlledResources: ["cpu", "memory"] 
--- 
apiVersion: apps/v1 
kind: Deployment 
metadata: 
  name: hamster 
spec: 
  selector: 
    matchLabels: 
      app: hamster 
  replicas: 2 
  template: 
    metadata: 
      labels: 
        app: hamster 
    spec: 
      securityContext: 
        runAsNonRoot: true 
        runAsUser: 65534 # nobody 
      containers: 
        - name: hamster 
          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"

Si memory no se especifica en controlledResources, el recomendador no responde a eventos OOM. En este caso, solo va a establecer CPU en controlledValues. controlledValues le permite elegir si quiere actualizar las solicitudes de recursos del contenedor mediante la opción RequestsOnly, o bien las solicitudes de recursos y los límites mediante la opción RequestsAndLimits. El valor predeterminado es RequestsAndLimits. Si usa la opción RequestsAndLimits, las solicitudes se calculan en función del uso real y los límites se calculan en función de la relación entre límites y solicitudes del pod actual.

Por ejemplo, si empieza con un pod que solicita 2 CPU y limita a 4 CPU, el VPA siempre establece el límite en el doble de solicitudes. El mismo principio se aplica a la memoria. Cuando se usa el modo RequestsAndLimits, puede servir como plano técnico para las solicitudes y límites iniciales de los recursos de la aplicación.

Puede simplificar el objeto VPA mediante el modo automático y las recomendaciones de computación para CPU y memoria.

Implemente el ejemplo hamster_extra-recomender.yaml mediante el comando kubectl apply y especifique el nombre del manifiesto de YAML.
```
kubectl apply -f hamster_customized_recommender.yaml
```
Espere a que el actualizador de VPA inicie un nuevo pod de hámster, proceso que debería tardar unos minutos. Puede supervisar los pods mediante el comando kubectl get.
```
kubectl get --watch pods -l app=hamster
```
Cuando se inicie un nuevo pod de hámster, describa el pod ejecutando el comando kubectl describe y vea las reservas actualizadas de CPU y memoria.
```
kubectl describe pod hamster-<exampleID>
```
La salida de ejemplo es un fragmento de código de la información que describe el pod:
```
State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```

Para ver las recomendaciones actualizadas de VPA, ejecute el comando kubectl describe para describir la información del recurso hamster-vpa.

kubectl describe vpa/hamster-vpa

La salida de ejemplo es un fragmento de código de la información sobre el uso de recursos:

State:          Running
 Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
Spec:
  recommenders:
    Name: customized-recommender

Solución de problemas

Para diagnosticar problemas con una instalación de VPA, realice los pasos siguientes.

Use el siguiente comando para comprobar que todos los componentes del sistema se ejecutan:
```
kubectl --namespace=kube-system get pods|grep vpa
```

La salida debe enumerar tres pods: recomendador, actualizador y controlador de admisión con el estado Running.

Confirme que los componentes del sistema registran errores. Para cada uno de los pods devueltos por el comando anterior, ejecute el siguiente comando:
```
kubectl --namespace=kube-system logs [pod name] | grep -e '^E[0-9]\{4\}'
```
Ejecute el siguiente comando para confirmar que se ha creado la definición de recursos personalizada:
```
kubectl get customresourcedefinition | grep verticalpodautoscalers
```

Pasos siguientes

En este artículo se muestra cómo escalar automáticamente el uso de recursos, como CPU y la memoria, de los nodos de clúster para que coincidan con los requisitos de la aplicación.

Asimismo, también puede usar el escalado automático horizontal de pods para ajustar automáticamente el número de pods ejecutan la aplicación. Para obtener instrucciones sobre cómo usar el escalado automático horizontal de pods, consulte Escalado de aplicaciones en AKS.
Consulte el escalador automático vertical de pods [referencia de API] para obtener más información sobre las definiciones de objetos VPA relacionados.