Partager via

Utiliser l’outil de mise à l’échelle automatique verticale des pods dans AKS (Azure Kubernetes Service)

  • Article

Cet article montre comment utiliser l’outil de mise à l’échelle automatique verticale des pods (VPA, Vertical Pod Autoscaler) sur votre cluster AKS (Azure Kubernetes Service). L’outil VPA ajuste automatiquement les demandes de processeur et de mémoire de vos pods afin qu’elles correspondent aux modèles d’utilisation de vos charges de travail. Cette fonctionnalité permet d’optimiser les performances de vos applications et de réduire le coût d’exécution de vos charges de travail dans AKS.

Pour plus d’informations, consultez la vue d’ensemble de l’outil de mise à l’échelle automatique verticale des pods.

Avant de commencer

  • Si vous disposez d’un cluster AKS existant, vérifiez qu’il exécute Kubernetes version 1.24 ou ultérieure.

  • La version 2.52.0 ou ultérieure d’Azure CLI doit être installée et configurée. Exécutez az --version pour trouver la version. Si vous devez installer ou mettre à niveau, voir Installer Azure CLI.

  • Si vous activez VPA sur un cluster existant, vérifiez que kubectl est installé et configuré pour se connecter à votre cluster AKS à l’aide de la commande az aks get-credentials.

    az aks get-credentials --name <cluster-name> --resource-group <resource-group-name>

Déployer VPA sur un nouveau cluster

  • Créez un cluster AKS avec VPA activé en exécutant la commande az aks create avec l’indicateur --enable-vpa.

    az aks create --name <cluster-name> --resource-group <resource-group-name> --enable-vpa --generate-ssh-keys

    Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster.

Mettre à jour un cluster existant pour utiliser VPA

  • Mettez à jour un cluster existant pour utiliser VPA en exécutant la commande az aks update avec l’indicateur --enable-vpa.

    az aks update --name <cluster-name> --resource-group <resource-group-name> --enable-vpa

    Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster.

Désactiver VPA sur un cluster existant

  • Désactivez VPA sur un cluster existant en exécutant la commande az aks update avec l’indicateur --disable-vpa.

    az aks update --name <cluster-name> --resource-group <resource-group-name> --disable-vpa

    Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster.

Tester l’installation de Vertical Pod Autoscaler

Dans l’exemple suivant, nous créons un déploiement avec deux pods, chacun exécutant un conteneur unique qui demande 100 millicœurs et essaie d’en utiliser un peu plus de 500. Nous créons également une configuration VPA pointant vers le déploiement. VPA observe le comportement des pods et, après environ cinq minutes, il les met à jour afin qu’ils demandent 500 millicœurs.

  1. Créez un fichier nommé hamster.yaml et copiez-y le manifeste suivant de l’exemple de Vertical Pod Autoscaler à partir du dépôt 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"

  2. Déployez l’exemple de Vertical Pod Autoscaler hamster.yaml en exécutant la commande kubectl apply.

    kubectl apply -f hamster.yaml

    Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster.

  3. Affichez les pods en cours d’exécution à l’aide de la commande kubectl get.

    kubectl get pods -l app=hamster

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

  4. Affichez les réservations de processeur et de mémoire sur l’un des pods en exécutant la commande kubectl describe. Veillez à remplacer <example-pod> par l’un des ID de pod retournés dans la sortie de l’étape précédente.

    kubectl describe pod hamster-<example-pod>

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

     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>

    Le pod comprend 100 millicpus et 50 mébioctets (Mio) de mémoire réservés dans cet exemple. Pour cet exemple d’application, le pod ayant besoin de moins de 100 millicpus pour s’exécuter, il n’existe aucune capacité de processeur disponible. Les pods réservent également moins de mémoire que nécessaire. Le déploiement vpa-recommender de Vertical Pod Autoscaler analyse les pods hébergeant l’application hamster pour voir si les besoins en processeur et en mémoire sont appropriés. Si des ajustements sont nécessaires, le vpa-updater relance les pods avec des valeurs mises à jour.

  5. Surveillez les pods en exécutant la commande kubectl get.

    kubectl get --watch pods -l app=hamster

  6. Lorsque le nouveau pod hamster démarre, vous pouvez afficher les réservations de processeur et de mémoire mises à jour en exécutant la commande kubectl describe. Veillez à remplacer <example-pod> par l’un des ID de pod retournés dans la sortie de l’étape précédente.

    kubectl describe pod hamster-<example-pod>

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

    Dans la sortie précédente, vous pouvez voir que la réservation de processeur a augmenté à 587 millicpus, soit plus de cinq fois la valeur d’origine. La mémoire est passée à 262 144 kilo-octets, soit environ 250 mébioctets ou cinq fois la valeur d’origine. Ce pod était sous-doté et le Vertical Pod Autoscaler a corrigé l’estimation avec une valeur beaucoup plus appropriée.

  7. Affichez les recommandations mises à jour du VPA en exécutant la commande kubectl describe pour décrire les informations de ressource hamster-vpa.

    kubectl describe vpa/hamster-vpa

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

Définir les demandes Vertical Pod Autoscaler

L’objet VerticalPodAutoscaler définit automatiquement les demandes de ressources sur les pods avec un updateMode défini sur Auto. Vous pouvez définir une valeur différente en fonction de vos besoins et des tests réalisés. Dans cet exemple, nous créons et testons un manifeste de déploiement avec deux pods, chacun exécutant un conteneur qui demande 100 millicpus et 50 Mio de mémoire, et définit updateMode sur Recreate.

  1. Créez un fichier nommé azure-autodeploy.yaml et copiez-y le manifeste suivant :

    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"]

  2. Créez le pod à l’aide de la commande kubectl create.

    kubectl create -f azure-autodeploy.yaml

    Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster.

  3. Affichez les pods en cours d’exécution à l’aide de la commande kubectl get.

    kubectl get pods

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

    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

  4. Créez un fichier nommé azure-vpa-auto.yaml et copiez-y le manifeste suivant :

    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"

    La valeur targetRef.name spécifie que tout pod contrôlé par un déploiement nommé vpa-auto-deployment appartient à VerticalPodAutoscaler. La valeur Recreate pour updateMode signifie que le contrôleur de Vertical Pod Autoscaler peut supprimer un pod, ajuster les demandes de processeur et de mémoire, puis créer un pod.

  5. Appliquez le manifeste au cluster en exécutant la commande kubectl apply.

    kubectl create -f azure-vpa-auto.yaml

  6. Patientez quelques minutes, puis affichez les pods en cours d’exécution en exécutant la commande kubectl get.

    kubectl get pods

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

    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

  7. Obtenez des informations détaillées sur l’un de vos pods en cours d’exécution en exécutant la commande kubectl get. Veillez à remplacer <pod-name> par le nom de l’un de vos pods obtenu dans la sortie précédente.

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

    Votre sortie doit ressembler à l’exemple de sortie suivant, qui montre que le contrôleur VPA a augmenté la demande de mémoire à 262 144k et la demande de processeur à 25 millicpus :

    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

  8. Obtenez des informations détaillées sur le Vertical Pod Autoscaler et ses recommandations pour le processeur et la mémoire en exécutant la commande kubectl get.

    kubectl get vpa vpa-auto --output yaml

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

     recommendation:
  containerRecommendations:
  - containerName: mycontainer
    lowerBound:
      cpu: 25m
      memory: 262144k
    target:
      cpu: 25m
      memory: 262144k
    uncappedTarget:
      cpu: 25m
      memory: 262144k
    upperBound:
      cpu: 230m
      memory: 262144k

    Dans cet exemple, les résultats dans l’attribut target indiquent qu’il n’est pas nécessaire de modifier le processeur ou la mémoire cible pour que le conteneur s’exécute de manière optimale. Toutefois, les résultats peuvent varier en fonction de l’application et de son utilisation des ressources.

    L’outil de mise à l’échelle automatique de pod utilise les attributs lowerBound et upperBound pour décider s’il faut supprimer un pod et le remplacer par un nouveau. Si un pod a des demandes inférieures à la limite inférieure ou supérieures à la limite supérieure, l’outil de mise à l’échelle automatique de pod supprime le pod et le remplace par un pod répondant à l’attribut cible.

Générateur de recommandations supplémentaire pour l’outil de mise à l’échelle automatique de pod

Le générateur de recommandations fournit des recommandations pour l’utilisation des ressources en fonction de la consommation des ressources en temps réel. AKS déploie un générateur de recommandations quand un cluster active VPA. Vous pouvez déployer un générateur de recommandations personnalisé ou un générateur de recommandations supplémentaire avec la même image que celle du générateur de recommandations par défaut. L’avantage d’un générateur de recommandations personnalisé est que vous pouvez personnaliser votre logique de recommandation. Avec un générateur de recommandations supplémentaire, vous pouvez partitionner des VPA pour utiliser différents générateurs de recommandations.

Dans l’exemple suivant, nous créons un générateur de recommandations supplémentaire, nous l’appliquons à un cluster AKS existant, et nous configurons l’objet VPA de façon à utiliser le générateur de recommandations supplémentaire.

  1. Créez un fichier nommé extra_recommender.yaml et copiez-y le manifeste suivant :

    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

  2. Déployez l’exemple de Vertical Pod Autoscaler extra-recomender.yaml en exécutant la commande kubectl apply.

    kubectl apply -f extra-recommender.yaml

    Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster.

  3. Créez un fichier nommé hamster-extra-recommender.yaml et copiez-y le manifeste suivant :

    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 n’est pas spécifié dans controlledResources, le générateur de recommandations ne répond pas aux événements OOM. Dans cet exemple, nous définissons uniquement le processeur dans controlledValues. controlledValues vous permet de choisir s’il faut mettre à jour les demandes de ressources du conteneur avec l’option RequestsOnly, ou bien à la fois les demandes de ressources et les limites en utilisant l’option RequestsAndLimits. La valeur par défaut est RequestsAndLimits. Si vous utilisez l’option RequestsAndLimits, les demandes sont calculées en fonction de l’utilisation réelle, et les limites sont calculées en fonction du ratio des demandes et des limites du pod actuel.

    Par exemple, si vous commencez avec un pod qui demande 2 processeurs et limite à 4 processeurs, VPA définit toujours la limite pour que sa valeur soit de deux fois les demandes. Le même principe s’applique à la mémoire. Quand vous utilisez le mode RequestsAndLimits, il peut servir de blueprint pour vos demandes et vos limites de ressources d’application initiales.

    Vous pouvez simplifier l’objet VPA en utilisant le mode Auto et en calculant des recommandations à la fois pour le processeur et pour la mémoire.

  4. Déployez l’exemple hamster-extra-recomender.yaml en exécutant la commande kubectl apply.

    kubectl apply -f hamster-extra-recommender.yaml

  5. Vous pouvez surveiller les pods à l’aide de la commande [kubectl get]kubectl-get.

    kubectl get --watch pods -l app=hamster

  6. Lorsque le nouveau pod hamster démarre, affichez les réservations de processeur et de mémoire mises à jour en exécutant la commande kubectl describe. Veillez à remplacer <example-pod> par l’un de vos ID de pod.

    kubectl describe pod hamster-<example-pod>

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

  7. Affichez les recommandations mises à jour à partir de VPA en exécutant la commande kubectl describe.

    kubectl describe vpa/hamster-vpa

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

    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

Résoudre les problèmes liés à Vertical Pod Autoscaler

Si vous rencontrez des problèmes avec Vertical Pod Autoscaler, vous pouvez procéder à un dépannage des composants système et de la définition de ressource personnalisée pour identifier le problème.

  1. Vérifiez que tous les composants système sont en cours d’exécution à l’aide de la commande suivante :

    kubectl --namespace=kube-system get pods|grep vpa

    La sortie doit lister trois pods : générateur de recommandation, outil de mise à jour et contrôleur d’admission, tous à l’état Running.

  2. Pour chacun des pods retournés dans la sortie précédente, vérifiez que les composants système journalisent les erreurs en exécutant la commande suivante :

    kubectl --namespace=kube-system logs [pod name] | grep -e '^E[0-9]\{4\}'

  3. Vérifiez que la définition de ressource personnalisée a été créée en exécutant la commande suivante :

    kubectl get customresourcedefinition | grep verticalpodautoscalers

Étapes suivantes

Pour en savoir plus sur l’objet VPA, consultez les informations de référence sur l’API Vertical Pod Autoscaler.