Utilisation du VPA (Vertical Pod Autoscaler) de Kubernetes

Découvrez comment utiliser le VPA de Kubernetes pour ajuster automatiquement les demandes et les limites de ressources pour les conteneurs s'exécutant dans des pods d'une grappe que vous avez créée à l'aide de Kubernetes Engine (OKE).

Note

Vous ne pouvez pas utiliser le VPA de Kubernetes avec les groupes de noeuds virtuels.

Vous pouvez utiliser le VPA de Kubernetes pour ajuster automatiquement les demandes et les limites de ressources pour les conteneurs exécutés dans les pods d'un déploiement. Le VPA peut améliorer l'utilisation des ressources des grappes en :

Définissant automatiquement les demandes en fonction de l'utilisation pour garantir que la quantité de ressources appropriée est disponible pour chaque pod.
Tenant à jour les rapports entre les limites et les demandes spécifiées dans les configurations initiales des conteneurs.
Mettant à l'échelle à la baisse les pods qui demandent trop de ressources, en fonction de leur utilisation au fil du temps.
Mettant à l'échelle à la hausse les pods qui ne demandent pas assez de ressources, en fonction de leur utilisation au fil du temps.

Le VPA comporte trois composants :

Recommender : Surveille la consommation courante et passée des ressources et fournit des valeurs de demande d'UC et de mémoire recommandées pour un conteneur.
Updater : Vérifie les pods dont les ressources sont incorrectes et les supprime, afin qu'ils puissent être recréés avec des valeurs de demande mises à jour.
Admission Plugin : Définit les demandes de ressources correctes pour les nouveaux pods (qui viennent d'être créés ou recréés par leur contrôleur en raison des modifications apportées par l'outil Updater).

Pour plus d'informations, voir Vertical Pod Autoscaler Managing Resources for Containers dans la documentation sur Kubernetes.

Vous configurez le VPA à l'aide de l'objet de définition de ressource personnalisée VerticalPodAutoscaler. L'objet VerticalPodAutoscaler vous permet de spécifier les pods à ajuster verticalement et les recommandations de ressources à appliquer (éventuellement). Pour plus d'informations, voir VerticalPodAutoscaler et Custom Resource Definition object dans la documentation sur Kubernetes.

Le VPA nécessite l'installation d'une source de mesures, telle que le serveur de mesures Kubernetes, dans la grappe. Pour plus d'informations, voir Déploiement du serveur de mesures Kubernetes sur une grappe.

Remplacement des intervalles de limites

Le VPA tente de formuler des recommandations comprises entre les valeurs minimales et maximales spécifiées pour un intervalle de limites, si un tel intervalle a été défini. Toutefois, si l'intervalle de limites applicable est en conflit avec les valeurs spécifiées dans la section resourcePolicy du manifeste VerticalPodAutoscaler, le VPA accorde la priorité à la politique de ressources et formule des recommandations en conséquence (même si les valeurs ne sont pas comprises dans l'intervalle de limites). Pour plus d'informations, voir Limit Ranges et Resource Policy Overriding Limit Range dans la documentation sur Kubernetes.

Création de recommandations sans les appliquer

Vous pouvez utiliser le VPA pour créer et appliquer des recommandations, ou simplement pour créer des recommandations (sans mettre à jour les pods). Pour simplement créer des recommandations sans les appliquer, définissez updateMode: "Off" dans la section updatePolicy du manifeste VerticalPodAutoscaler.

Lorsque des pods sont créés, le VPA analyse les besoins en UC et en mémoire des conteneurs et enregistre ces recommandations dans le champ Status. Le VPA ne prend aucune mesure pour mettre à jour les demandes de ressources pour les conteneurs en cours d'exécution.

Exclusion de conteneurs spécifiques

Vous pouvez utiliser le VPA pour créer des recommandations et les appliquer à tous les conteneurs d'un pod, ou vous pouvez exclure des conteneurs sélectionnés. Pour désactiver les recommandations pour un conteneur donné, dans la section resourcePolicy du manifeste VerticalPodAutoscaler, spécifiez un containerName et définissez mode: "Off" dans la section containerPolicies.

Notes sur le VPA (Vertical Pod Autoscaler)

Notez ce qui suit :

Actuellement, il est recommandé de ne pas utiliser le VPA avec le HPA pour les mesures d'utilisation de l'UC ou de la mémoire. Cependant, notez que vous pouvez utiliser le VPA avec le HPA pour des mesures personnalisées et externes. Voir Prise en charge des mesures personnalisées dans la documentation sur Kubernetes.
Les recommandations du VPA peuvent dépasser les ressources disponibles (par exemple, taille de noeud, taille disponible, quota disponible). Notez que l'application des recommandations peut entraîner la mise en attente des pods.
Chaque fois que le VPA met à jour les ressources du pod, le pod est recréé, ce qui provoque le redémarrage de tous les conteneurs en cours d'exécution. Notez que le pod peut être recréé sur un noeud différent.
Vous pouvez utiliser le VPA de Kubernetes avec les groupes de noeuds gérés, mais pas avec les groupes de noeuds virtuels.

Utilisation du VPA (Vertical Pod Autoscaler)

Les instructions ci-dessous vous guident lors du déploiement du VPA dans une grappe. Elles décrivent comment :

Vérifier que le serveur de mesures Kubernetes a été installé dans une grappe.
Télécharger et déployer le VPA.
Déployer un exemple d'application.
Consulter l'opération d'ajustement en action.
Consulter la recommandation.
Procéder au nettoyage, en supprimant l'exemple d'application et le VPA.

Étape 1 : Vérifier l'installation du serveur de mesures Kubernetes

Si vous ne l'avez pas encore fait, suivez les étapes pour configurer le fichier de configuration kubeconfig de la grappe et (s'il y a lieu) définissez la variable d'environnement KUBECONFIG pour qu'elle pointe vers le fichier. Notez que vous devez configurer votre propre fichier kubeconfig. Vous ne pouvez pas accéder à une grappe à l'aide d'un fichier kubeconfig configuré par un autre utilisateur. Voir Configuration de l'accès aux grappes.
Vérifiez que le serveur de mesures Kubernetes a été déployé dans la grappe et qu'il est disponible en entrant :
```
kubectl -n kube-system get deployment/metrics-server
```
Si la commande retourne une erreur indiquant que le serveur est introuvable, vous devez déployer le serveur de mesures Kubernetes dans la grappe avant de continuer. Voir Déploiement du serveur de mesures Kubernetes sur une grappe.

Étape 2 : Télécharger et déployer le VPA

Téléchargez le code source du VPA à partir de GitHub. Par exemple, en entrant :
```
git clone -b vpa-release-0.8 https://github.com/kubernetes/autoscaler.git
```
Accédez au répertoire vertical-pod-autoscaler :
```
cd autoscaler/vertical-pod-autoscaler
```
Si vous avez déjà déployé le VPA, supprimez-le en entrant :
```
./hack/vpa-down.sh
```
Déployez le VPA en entrant :
```
./hack/vpa-up.sh
```

Vérifiez que les pods du VPA ont été créés en entrant :

kubectl get pods -n kube-system

La sortie de la commande ci-dessus montre les pods :

vpa-admission-controller-59d9965cfb-bzs8l 1/1 Running 0 6m34s
vpa-recommender-5bcb58569-mqdds 1/1 Running 0 6m43s
vpa-updater-5979cbf757-scw2d 1/1 Running 0 6m46s

Notez que vous verrez probablement des noms et des numéros différents.

Étape 3 : Déployer l'exemple d'application

Déployez l'exemple d'application hamster pour créer un déploiement et un VPA correspondant en entrant :
```
kubectl apply -f examples/hamster.yaml
```
La sortie de la commande ci-dessus confirme le déploiement et la création :
```
verticalpodautoscaler.autoscaling.k8s.io/hamster-vpa created
deployment.apps/hamster created
```
Le déploiement de l'application hamster crée un déploiement avec deux pods et un VPA pointant vers le déploiement.
Vérifiez que les pods de l'application hamster ont été créés en entrant :
```
kubectl get pods -l app=hamster
```
La sortie de la commande ci-dessus confirme la création :
```
NAME                     READY STATUS  RESTARTS AGE
hamster-7cbfd64f57-mqqnk 1/1   Running 0        54s
hamster-7cbfd64f57-rq6wv 1/1   Running 0        55s
```
Notez que vous verrez probablement des noms différents pour les pods de l'application hamster.
Consultez les réservations d'UC et de mémoire à l'aide de la commande kubectl describe pod et de l'un des noms de pod de l'application hamster retournés à l'étape précédente. Par exemple :
```
kubectl describe pod hamster-7cbfd64f57-rq6wv
```
Notez que la commande ci-dessus n'est qu'un exemple. Vous devez utiliser l'un des noms de pod de l'application hamster retournés lorsque vous avez exécuté la commande kubectl get pods -l app=hamster à l'étape précédente.
Dans la section de demandes de la sortie, vous pouvez voir les réservations d'UC et de mémoire courantes du pod. Par exemple :
```
Requests:
      cpu:        100m
      memory:     50Mi
```
Le VPA (en particulier, l'outil Recommender) analyse les pods et observe leur comportement pour déterminer si ces réservations d'UC et de mémoire sont appropriées. Notez que les réservations d'UC et de mémoire affichées peuvent être différentes.
Les réserves ne sont pas suffisantes parce que les ressources de l'exemple d'application hamster sont volontairement insuffisantes. Chaque pod exécute un conteneur unique qui :
- demande 100 millicoeurs, mais tente d'utiliser plus de 500 millicoeurs
- réserve beaucoup moins de mémoire que ce dont il a besoin pour s'exécuter

Étape 4 : Consulter l'opération d'ajustement

Après avoir analysé les pods initiaux dans l'exemple d'application hamster et déterminé que les réservations d'UC et de mémoire étaient inadéquates, le VPA (en particulier, l'outil Updater) relance les pods avec des valeurs différentes, selon les propositions de l'outil Recommender. Notez que le VPA ne modifie pas le modèle dans le déploiement, mais qu'il met à jour les demandes réelles des pods.

Surveillez les pods dans l'exemple d'application hamster et attendez que l'outil Updater démarre un nouveau pod de l'application hamster avec un nouveau nom, en entrant :
```
kubectl get --watch pods -l app=hamster
```
Lorsque vous voyez qu'une nouveau pod de l'application hamster a démarré, consultez ses réservations d'UC et de mémoire à l'aide de la commande kubectl describe pod et du nom du pod. Par exemple :
```
kubectl describe pod hamster-7cbfd64f57-wmg4
```
Dans la section de demandes de la sortie, vous pouvez voir les réservations d'UC et de mémoire du nouveau pod.
```
    Requests:
      cpu:        587m
      memory:     262144k
```
Dans l'exemple ci-dessus, notez que la réservation d'UC est passée à 587 millicoeurs et que la réservation de mémoire est passée à 262 144 Ko. Les ressources du pod initial étaient insuffisantes et le VPA a corrigé les réservations initiales en appliquant des valeurs plus appropriées. Notez que les réservations d'UC et de mémoire affichées peuvent être différentes.

Étape 5 : Consulter la recommandation

Consultez les recommandations fournies par le VPA (en particulier, l'outil Recommender) en entrant :

kubectl describe vpa/hamster-vpa

La sortie de la commande ci-dessus montre les recommandations :

Name:         hamster-vpa
Namespace:    default
Labels:       <none>
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"autoscaling.k8s.io/v1beta2","kind":"VerticalPodAutoscaler","metadata":{"annotations":{},"name":"hamster-vpa","namespace":"d...
API Version:  autoscaling.k8s.io/v1
Kind:         VerticalPodAutoscaler
Metadata:
  Creation Timestamp:  2020-09-22T18:08:09Z
  Generation:          27
  Resource Version:    19466955
  Self Link:           /apis/autoscaling.k8s.io/v1/namespaces/default/verticalpodautoscalers/hamster-vpa
  UID:                 689cee90-6fed-404d-adf9-b6fa8c1da660
Spec:
  Resource Policy:
    Container Policies:
      Container Name:  *
      Controlled Resources:
        cpu
        memory
      Max Allowed:
        Cpu:     1
        Memory:  500Mi
      Min Allowed:
        Cpu:     100m
        Memory:  50Mi
  Target Ref:
    API Version:  apps/v1
    Kind:         Deployment
    Name:         hamster
  Update Policy:
    Update Mode:  Auto
Status:
  Conditions:
    Last Transition Time:  2020-09-22T18:10:10Z
    Status:                True
    Type:                  RecommendationProvided
  Recommendation:
    Container Recommendations:
      Container Name:  hamster
      Lower Bound:
        Cpu:     519m
        Memory:  262144k
      Target:
        Cpu:     587m
        Memory:  262144k
      Uncapped Target:
        Cpu:     587m
        Memory:  262144k
      Upper Bound:
        Cpu:     1
        Memory:  500Mi
Events:          <none>

Notez que vous pouvez voir des recommandations différentes.

Étape 6 : Nettoyer

Supprimez l'exemple d'application en entrant :
```
kubectl delete -f examples/hamster.yaml
```
Dans le répertoire vertical-pod-autoscaler, supprimez le déploiement du VPA en entrant :
```
./hack/vpa-down.sh
```

Documentation sur Oracle Cloud Infrastructure