Uso de Vertical Pod Autoscaler en Azure Kubernetes Service (AKS)

Artículo
08/02/2024

En este artículo se muestra cómo usar Vertical Pod Autoscaler (VPA) en el clúster de Azure Kubernetes Service (AKS). El VPA ajusta automáticamente las solicitudes de CPU y memoria de los pods para que coincidan con los patrones de uso de las cargas de trabajo. Esta característica ayuda a optimizar el rendimiento de las aplicaciones y a reducir el costo de ejecutar las cargas de trabajo en AKS.

Para obtener más información, consulte la introducción a Vertical Pod Autoscaler.

Antes de empezar

Si tiene un clúster de AKS existente, asegúrese de que ejecuta Kubernetes versión 1.24 o posterior.
Es preciso que esté instalada y configurada la versión 2.52.0 de la CLI de Azure, o cualquier otra posterior. Ejecute az --version para encontrar la versión. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.
Si habilita VPA en un clúster existente, asegúrese de que kubectl está instalado y configurado para conectarse al clúster de AKS mediante el comando az aks get-credentials.
```
az aks get-credentials --name <cluster-name> --resource-group <resource-group-name>
```

Implementación de Vertical Pod Autoscaler en un nuevo clúster

Cree un nuevo clúster de AKS con el VPA habilitado mediante el comando az aks create con la marca --enable-vpa.
```
az aks create --name <cluster-name> --resource-group <resource-group-name> --enable-vpa --generate-ssh-keys
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Actualización de un clúster existente para usar Vertical Pod Autoscaler

Actualice un clúster existente para usar el VPA mediante el comando az aks update con la marca --enable-vpa.
```
az aks update --name <cluster-name> --resource-group <resource-group-name> --enable-vpa 
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Deshabilitación del Vertical Pod Autoscaler en un clúster existente

Deshabilitar VPA en un clúster existente mediante el comando az aks update con la marca --disable-vpa.
```
az aks update --name <cluster-name> --resource-group <resource-group-name> --disable-vpa
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Prueba de la instalación de Vertical Pod Autoscaler

En el siguiente ejemplo 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, después de unos cinco minutos, actualiza los pods para solicitar 500 millicores.

Cree un archivo denominado hamster.yaml y copie el siguiente manifiesto del ejemplo de Vertical Pod Autoscaler desde el repositorio de GitHub kubernetes/autoscaler:

apiVersion: "autoscaling.k8s.io/v1"
kind: VerticalPodAutoscaler
metadata:
  name: hamster-vpa
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind: Deployment
    name: hamster
  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
      containers:
        - name: hamster
          image: registry.k8s.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"

Implemente el ejemplo de Vertical Pod Autoscaler hamster.yaml mediante el comando kubectl apply.
```
kubectl apply -f hamster.yaml
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Vea los pods en ejecución mediante el comando kubectl get.

kubectl get pods -l app=hamster

El resultado debería ser similar al ejemplo siguiente:

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

Vea las reservas de CPU y memoria en uno de los pods mediante el comando kubectl describe. Asegúrese de reemplazar <example-pod> por uno de los identificadores de pod devueltos en la salida del paso anterior.
```
kubectl describe pod hamster-<example-pod>
```
El resultado debería ser similar al ejemplo siguiente:
```
 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 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.
Supervise los pods mediante el comando kubectl get.
```
kubectl get --watch pods -l app=hamster
```
Cuando se inicia el nuevo pod de hámster, puede ver las reservas actualizadas de CPU y memoria mediante el comando kubectl describe. Asegúrese de reemplazar <example-pod> por uno de los identificadores de pod devueltos en la salida del paso anterior.
```
kubectl describe pod hamster-<example-pod>
```
El resultado debería ser similar al ejemplo siguiente:
```
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.

Vea las recomendaciones actualizadas de VPA mediante el comando kubectl describe para describir la información del recurso hamster-vpa.

kubectl describe vpa/hamster-vpa

El resultado debería ser similar al ejemplo siguiente:

 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 de Vertical Pod Autoscaler

El objeto VerticalPodAutoscaler establece automáticamente solicitudes de recursos en pods con un updateMode de Auto. Puede establecer un valor diferente en función de sus requisitos y pruebas. En este ejemplo, creamos y probamos un manifiesto de implementación con dos pods, cada uno que ejecuta un contenedor que solicita 100 miliCPU y 50 MiB de memoria, y establece el updateMode en Recreate.

Cree un archivo denominado azure-autodeploy.yaml y cópielo en el siguiente 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"]

Cree el pod mediante el comando kubectl create.
```
kubectl create -f azure-autodeploy.yaml
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.

Vea los pods en ejecución mediante el comando kubectl get.

kubectl get pods

El resultado debería ser similar al ejemplo siguiente:

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:
```
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, a continuación, vea los pods en ejecución mediante el comando kubectl get.

kubectl get pods

El resultado debería ser similar al ejemplo siguiente:

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. Asegúrese de reemplazar <pod-name> por el nombre de uno de los pods de la salida anterior.

kubectl get pod <pod-name> --output yaml

La salida debe ser similar a la siguiente salida de ejemplo, que muestra que el controlador VPA aumentó la solicitud de memoria a 262144000 y la solicitud de CPU a 25 miliCPU:

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

Obtenga información detallada sobre el escalador automático de pods verticales y sus recomendaciones para CPU y memoria mediante el comando kubectl get.
```
kubectl get vpa vpa-auto --output yaml
```
El resultado debería ser similar al 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
```
En este ejemplo, los resultados del atributo target especifican que no es necesario cambiar la CPU o el destino de memoria para que el contenedor se ejecute de forma óptima. Sin embargo, los resultados pueden variar en función de la aplicación y su uso de recursos.

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

El Recomendador 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 crear particiones de VPN para usar diferentes recomendadores.

En el ejemplo siguiente, se crea un recomendador adicional, se aplica a un clúster de AKS existente y se configura 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
      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 Vertical Pod Autoscaler extra-recomender.yaml mediante el comando kubectl apply.
```
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 hamster-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 ejemplo, solo se establece la 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 Auto y las recomendaciones de computación para CPU y memoria.

Implemente el ejemplo hamster-extra-recomender.yaml mediante el comando kubectl apply.
```
kubectl apply -f hamster-extra-recommender.yaml
```
Supervise los pods mediante el comando [kubectl get]kubectl-get.
```
kubectl get --watch pods -l app=hamster
```
Cuando se inicia el nuevo pod de hámster, vea las reservas actualizadas de CPU y memoria mediante el comando kubectl describe. Asegúrese de reemplazar <example-pod> por uno de los identificadores de pod.
```
kubectl describe pod hamster-<example-pod>
```
El resultado debería ser similar al ejemplo siguiente:
```
State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```

Vea las recomendaciones actualizadas de VPA mediante el comando kubectl describe.

kubectl describe vpa/hamster-vpa

El resultado debería ser similar al ejemplo siguiente:

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 de Vertical Pod Autoscaler

Si tiene problemas con Vertical Pod Autoscaler, puede solucionar problemas de los componentes del sistema y la definición de recursos personalizados para identificar el problema.

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, todo ello con un estado de Running.
Para cada uno de los pods devueltos en la salida anterior, compruebe que los componentes del sistema registran los errores mediante el comando siguiente:
```
kubectl --namespace=kube-system logs [pod name] | grep -e '^E[0-9]\{4\}'
```
Compruebe que la definición de recurso personalizada se creó con el comando siguiente:
```
kubectl get customresourcedefinition | grep verticalpodautoscalers
```

Pasos siguientes

Para obtener más información sobre el objeto VPA, consulte la referencia de API de Vertical Pod Autoscaler.

Compartir a través de

Uso de Vertical Pod Autoscaler en Azure Kubernetes Service (AKS)

Antes de empezar

Implementación de Vertical Pod Autoscaler en un nuevo clúster

Actualización de un clúster existente para usar Vertical Pod Autoscaler

Deshabilitación del Vertical Pod Autoscaler en un clúster existente

Prueba de la instalación de Vertical Pod Autoscaler

Establecimiento de solicitudes de Vertical Pod Autoscaler

Recomendador adicional para el escalador automático vertical de pods

Solución de problemas de Vertical Pod Autoscaler

Pasos siguientes

Recursos adicionales