Configurer l'autoscaling horizontal des pods


Cette page vous explique comment mettre à l'échelle vos déploiements dans Google Kubernetes Engine (GKE) en ajustant automatiquement vos ressources à l'aide de métriques telles que l'allocation de ressources, le trafic de l'équilibreur de charge, les métriques personnalisées ou plusieurs métriques simultanément. Cette page fournit également des instructions détaillées pour configurer un profil Horizontal Pod Autoscaler (AHP), y compris pour afficher, supprimer, nettoyer et résoudre les problèmes liés à votre objet AHP. Un déploiement est un objet de l'API Kubernetes qui vous permet d'exécuter plusieurs instances dupliquées de pods répartis entre les nœuds d'un cluster.

Cette page s'adresse aux opérateurs et aux développeurs qui gèrent le scaling des applications dans GKE et qui souhaitent comprendre comment optimiser dynamiquement les performances et maintenir l'efficacité des coûts grâce à l'autoscaling horizontal des pods. Pour en savoir plus sur les rôles courants et les exemples de tâches mentionnés dans le contenu Google Cloud, consultez Rôles utilisateur et tâches courantes de GKE Enterprise.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

  • Activez l'API Google Kubernetes Engine.
  • Activer l'API Google Kubernetes Engine
  • Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.

Versions de l'API pour les objets HorizontalPodAutoscaler

Lorsque vous utilisez la console Google Cloud , les objets HorizontalPodAutoscaler sont créés à l'aide de l'API autoscaling/v2.

Lorsque vous utilisez kubectl pour créer ou afficher des informations sur un autoscaler horizontal de pods, vous pouvez spécifier l'API autoscaling/v1 ou l'API autoscaling/v2.

  • apiVersion: autoscaling/v1 est la version par défaut et ne vous permet d'effectuer un autoscaling qu'en fonction de l'utilisation du processeur. Pour effectuer un autoscaling à partir d'autres métriques, il est recommandé d'utiliser la version apiVersion: autoscaling/v2. L'exemple présenté dans la section Créer l'exemple de déploiement utilise apiVersion: autoscaling/v1.

  • La version apiVersion: autoscaling/v2 est recommandée pour la création d'objets HorizontalPodAutoscaler. Cette version permet d'effectuer un autoscaling en fonction de plusieurs métriques, y compris des métriques personnalisées ou externes. Tous les autres exemples de cette page utilisent apiVersion: autoscaling/v2.

Pour vérifier quelles versions d'API sont compatibles, utilisez la commande kubectl api-versions.

Vous pouvez spécifier l'API à utiliser lors de l'affichage des détails d'un autoscaler horizontal de pods utilisant apiVersion: autoscaling/v2.

Créer l'exemple de déploiement

Avant de pouvoir créer un autoscaler horizontal de pods, vous devez créer la charge de travail qu'il devra surveiller. Les exemples de cette page appliquent différentes configurations d'autoscaler horizontal de pods au déploiement nginx suivant. Des exemples distincts illustrent l'utilisation d'un autoscaler horizontal de pods basé sur l'utilisation des ressources, sur une métrique personnalisée ou externe et sur plusieurs métriques.

Enregistrez le fichier suivant dans un fichier nommé nginx.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.7.9
        ports:
        - containerPort: 80
        resources:
          # You must specify requests for CPU to autoscale
          # based on CPU utilization
          requests:
            cpu: "250m"

Ce manifeste spécifie une valeur pour les requêtes de processeur. Si vous souhaitez effectuer un scaling automatique en fonction de l'utilisation d'une ressource exprimée en pourcentage, vous devez spécifier les requêtes pour cette ressource. Si vous ne spécifiez pas de requêtes, vous ne pouvez effectuer un autoscaling qu'en fonction de la valeur absolue de l'utilisation de la ressource, par exemple, pour l'utilisation de processeur, exprimée en milliprocesseurs.

Pour créer le déploiement, appliquez le manifeste nginx.yaml :

kubectl apply -f nginx.yaml

Le déploiement comporte la valeur spec.replicas définie sur 3, donc trois pods sont déployés. Vous pouvez le vérifier à l'aide de la commande kubectl get deployment nginx.

Chacun des exemples de cette page applique un autoscaler horizontal de pods différent à un exemple de déploiement nginx.

Effectuer un autoscaling basé sur l'utilisation des ressources

Cet exemple crée un objet HorizontalPodAutoscaler afin d'effectuer un autoscaling du déploiement nginx lorsque l'utilisation du processeur dépasse 50 %, et garantit l'existence d'au moins 1 instance dupliquée et d'au plus 10 instances dupliquées.

Vous pouvez créer un autoscaler horizontal de pods qui cible l'utilisation du processeur à l'aide de la console Google Cloud , de la commande kubectl apply ou, pour l'utilisation moyenne du processeur, de la commande kubectl autoscale.

Console

  1. Accédez à la page Charges de travail dans la console Google Cloud .

    Accéder à la page Charges de travail

  2. Cliquez sur le nom du déploiement nginx.

  3. Cliquez sur Actions > Évoluer automatiquement.

  4. Spécifiez les valeurs suivantes :

    • Nombre minimal d'instances dupliquées : 1
    • Nombre maximal d'instances dupliquées : 10
    • Métrique d'autoscaling : processeur
    • Cible : 50
    • Unité : %
  5. Cliquez sur OK.

  6. Cliquez sur Évoluer automatiquement.

kubectl apply

Enregistrez le fichier manifeste YAML suivant dans un fichier nommé nginx-hpa.yaml :

apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: nginx
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx
  minReplicas: 1
  maxReplicas: 10
  targetCPUUtilizationPercentage: 50

Pour créer le HPA, appliquez le fichier manifeste à l'aide de la commande suivante :

kubectl apply -f nginx-hpa.yaml

kubectl autoscale

Pour créer un objet HorizontalPodAutoscaler qui ne cible que l'utilisation moyenne du processeur, vous pouvez utiliser la commande kubectl autoscale :

kubectl autoscale deployment nginx --cpu-percent=50 --min=1 --max=10

Pour obtenir la liste des autoscalers horizontaux de pods dans le cluster, exécutez la commande suivante :

kubectl get hpa

Le résultat ressemble à ce qui suit :

NAME    REFERENCE          TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
nginx   Deployment/nginx   0%/50%    1         10        3          61s

Pour obtenir des détails sur l'autoscaler horizontal de pods, vous pouvez utiliser la console Google Cloud ou la commande kubectl.

Console

  1. Accédez à la page Charges de travail dans la console Google Cloud .

    Accéder à la page Charges de travail

  2. Cliquez sur le nom du déploiement nginx.

  3. Affichez la configuration de l'autoscaler horizontal de pods dans la section Autoscaler.

  4. D'autres informations sur les événements d'autoscaling sont disponibles dans l'onglet Événements.

kubectl get

Pour obtenir des détails sur l'autoscaler horizontal de pods, vous pouvez utiliser kubectl get hpa avec l'option -o yaml. Le champ status contient des informations sur le nombre actuel d'instances dupliquées et les événements d'autoscaling récents.

kubectl get hpa nginx -o yaml

Le résultat ressemble à ce qui suit :

apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  annotations:
    autoscaling.alpha.kubernetes.io/conditions: '[{"type":"AbleToScale","status":"True","lastTransitionTime":"2019-10-30T19:42:59Z","reason":"ScaleDownStabilized","message":"recent
      recommendations were higher than current one, applying the highest recent recommendation"},{"type":"ScalingActive","status":"True","lastTransitionTime":"2019-10-30T19:42:59Z","reason":"ValidMetricFound","message":"the
      HPA was able to successfully calculate a replica count from cpu resource utilization
      (percentage of request)"},{"type":"ScalingLimited","status":"False","lastTransitionTime":"2019-10-30T19:42:59Z","reason":"DesiredWithinRange","message":"the
      desired count is within the acceptable range"}]'
    autoscaling.alpha.kubernetes.io/current-metrics: '[{"type":"Resource","resource":{"name":"cpu","currentAverageUtilization":0,"currentAverageValue":"0"}}]'
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"autoscaling/v1","kind":"HorizontalPodAutoscaler","metadata":{"annotations":{},"name":"nginx","namespace":"default"},"spec":{"maxReplicas":10,"minReplicas":1,"scaleTargetRef":{"apiVersion":"apps/v1","kind":"Deployment","name":"nginx"},"targetCPUUtilizationPercentage":50}}
  creationTimestamp: "2019-10-30T19:42:43Z"
  name: nginx
  namespace: default
  resourceVersion: "220050"
  selfLink: /apis/autoscaling/v1/namespaces/default/horizontalpodautoscalers/nginx
  uid: 70d1067d-fb4d-11e9-8b2a-42010a8e013f
spec:
  maxReplicas: 10
  minReplicas: 1
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx
  targetCPUUtilizationPercentage: 50
status:
  currentCPUUtilizationPercentage: 0
  currentReplicas: 3
  desiredReplicas: 3

Avant de suivre les autres exemples présentés sur cette page, supprimez le AHP :

kubectl delete hpa nginx

Lorsque vous supprimez un autoscaler horizontal de pods, le nombre d'instances dupliquées du déploiement reste le même. Le déploiement ne rétablit pas automatiquement l'état qui précède l'application de l'autoscaler de pods horizontaux.

Apprenez-en plus sur la suppression d'un autoscaler horizontal de pods.

Autoscaling basé sur le trafic de l'équilibreur de charge

L'autoscaling basé sur le trafic est une fonctionnalité de GKE qui intègre des signaux d'utilisation du trafic provenant d'équilibreurs de charge à des pods d'autoscaling.

L'utilisation du trafic comme signal d'autoscaling peut être utile, car le trafic est un indicateur principal de la charge, complémentaire aux processeurs et à la mémoire. L'intégration avec GKE garantit que la configuration est facile et que l'autoscaling réagit rapidement aux pics de trafic pour répondre à la demande.

L'autoscaling basé sur le trafic est activé par le contrôleur Gateway et ses fonctionnalités de gestion du trafic globale. Pour en savoir plus, consultez la page Autoscaling basé sur le trafic.

L'autoscaling basé sur le trafic de l'équilibreur de charge n'est disponible que pour les charges de travail passerelle.

Exigences

L'autoscaling basé sur le trafic présente les exigences suivantes:

  • Compatible avec GKE 1.31 et versions ultérieures.
  • API Gateway activée dans votre cluster GKE.
  • Compatible avec le trafic qui transite par des équilibreurs de charge déployés à l'aide de l'API Gateway et de la ressource GatewayClass gke-l7-global-external-managed, gke-l7-regional-external-managed, gke-l7-rilb ou gke-l7-gxlb.

Limites

L'autoscaling basé sur le trafic présente les limites suivantes :

  • Non compatible avec les ressources GatewayClass multicluster (gke-l7-global-external-managed-mc, gke-l7-regional-external-managed-mc, gke-l7-rilb-mc et gke-l7-gxlb-mc).
  • Non compatible avec le trafic utilisant des services de type LoadBalancer.
  • Il doit exister une relation claire et isolée entre les composants impliqués dans l'autoscaling basé sur le trafic. Un autoscaler horizontal de pods doit être dédié à la mise à l'échelle d'un seul déploiement (ou de toute ressource scalable) exposé par un seul service.
  • Après avoir configuré la capacité de votre service à l'aide du champ maxRatePerEndpoint, laissez suffisamment de temps (généralement une minute, mais potentiellement jusqu'à 15 minutes dans les grands clusters) pour que l'équilibreur de charge soit mis à jour avec cette modification, avant de configurer l'autoscaler horizontal de pods avec des métriques basées sur le trafic. Cela permet d'éviter que votre service ne rencontre temporairement une situation où votre cluster tente de faire de l'autoscaling en fonction des métriques émises par un équilibreur de charge encore en cours de configuration.
  • Si l'autoscaling basé sur le trafic est utilisé sur un service desservi par plusieurs équilibreurs de charge (par exemple, par une Ingress et une passerelle, ou par deux passerelles), l'autoscaler de pods horizontaux peut prendre en compte la valeur de trafic la plus élevée des équilibreurs de charge individuels pour prendre des décisions de scaling, plutôt que la somme des valeurs de trafic de tous les équilibreurs de charge.

Déployer l'autoscaling basé sur le trafic

L'exercice suivant utilise HorizontalPodAutoscaler pour procéder à l'autoscaling du déploiement store-autoscale en fonction du trafic qu'il reçoit. Une passerelle accepte le trafic entrant provenant d'Internet pour les pods. L'autoscaler compare les signaux de trafic de la passerelle à la capacité de trafic par pod configurée sur la ressource de service store-autoscale. En générant du trafic vers la passerelle, vous influencez le nombre de pods déployés.

Le schéma suivant illustre le fonctionnement de l'autoscaling basé sur le trafic :

HorizontalPodAutoscaler effectue un scaling d'un déploiement en fonction du trafic.

Pour déployer l'autoscaling basé sur le trafic, procédez comme suit:

  1. Pour les clusters standards, vérifiez que les ressources GatewayClasses sont installées dans votre cluster. Pour les clusters Autopilot, les ressources GatewayClasses sont installés par défaut.

    kubectl get gatewayclass
    

    Le résultat confirme que les ressources GatewayClass de GKE sont prêtes à être utilisées dans votre cluster:

    NAME                               CONTROLLER                  ACCEPTED   AGE
    gke-l7-global-external-managed     networking.gke.io/gateway   True       16h
    gke-l7-regional-external-managed   networking.gke.io/gateway   True       16h
    gke-l7-gxlb                        networking.gke.io/gateway   True       16h
    gke-l7-rilb                        networking.gke.io/gateway   True       16h
    

    Si vous n'obtenez pas ce résultat, activez l'API Gateway dans votre cluster GKE.

  2. Déployez l'exemple d'application et l'équilibreur de charge de passerelle sur votre cluster:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/master/gateway/docs/store-autoscale.yaml
    

    L'exemple d'application crée:

    • Un déploiement avec deux instances dupliquées.
    • Service avec un paramètre GCPBackendPolicy associé maxRatePerEndpoint défini sur 10. Pour en savoir plus sur les fonctionnalités de la ressource Gateway, consultez la page Fonctionnalités GatewayClass.
    • Une passerelle externe pour accéder à l'application sur Internet. Pour en savoir plus sur l'utilisation des équilibreurs de charge Gateway, consultez la page Déployer des passerelles.
    • Un objet HTTPRoute qui correspond à tout le trafic et l'envoie au service store-autoscale.

    La capacité du service est un élément essentiel de l'utilisation de l'autoscaling basé sur le trafic, car elle détermine la quantité de trafic par pod qui déclenche un événement d'autoscaling. Elle est configurée à l'aide d'un champ maxRatePerEndpoint sur une GCPBackendPolicy associée au service, qui définit le trafic maximal qu'un service doit recevoir en requêtes par seconde et par pod. La capacité de service est spécifique à l'application.

    Pour en savoir plus, consultez Déterminer la capacité de votre service.

  3. Enregistrez le manifeste suivant sous le nom hpa.yaml :

    apiVersion: autoscaling/v2
    kind: HorizontalPodAutoscaler
    metadata:
      name: store-autoscale
    spec:
      scaleTargetRef:
        apiVersion: apps/v1
        kind: Deployment
        name: store-autoscale
      minReplicas: 1
      maxReplicas: 10
      metrics:
      - type: Object
        object:
          describedObject:
            kind: Service
            name: store-autoscale
          metric:
            name: "autoscaling.googleapis.com|gclb-capacity-fullness"
          target:
            averageValue: 70
            type: AverageValue
    

    Ce fichier manifeste décrit un objet HorizontalPodAutoscaler avec les propriétés suivantes :

    • minReplicas et maxReplicas: définissent le nombre minimal et maximal d'instances dupliquées pour ce déploiement. Dans cette configuration, le nombre de pods peut faire évoluer de 1 à 10 instances dupliquées.
    • describedObject.name: store-autoscale: référence au service store-autoscale qui définit la capacité du trafic.
    • scaleTargetRef.name: store-autoscale: référence au déploiement store-autoscale qui définit la ressource mise à l'échelle par l'autoscaler horizontal de pods.
    • averageValue: 70: valeur moyenne cible de l'utilisation de la capacité. Cela donne à l'autoscaler horizontal des pods une marge de croissance qui permet aux pods en cours d'exécution de traiter le trafic excédentaire pendant la création des pods.

L'autoscaler horizontal des pods entraîne le comportement de trafic suivant:

  • Le nombre de pods est ajusté entre 1 et 10 instances dupliquées afin d'atteindre 70% du taux maximal par point de terminaison. Cela se traduit par 7 RPS par pod lorsque maxRatePerEndpoint=10.
  • À plus de 7 RPS par pod, les pods font l'objet d'un scaling à la hausse jusqu'à atteindre le nombre maximal de 10 instances dupliquées ou jusqu'à que le trafic moyen atteigne 7 RPS par pod.
  • Si le trafic est réduit, les pods évoluent vers le bas à un taux raisonnable à l'aide de l'algorithme d'autoscaler horizontal des pods.

Vous pouvez également déployer un générateur de trafic pour valider le comportement de l'autoscaling basé sur le trafic.

À 30 RPS, le déploiement est réduit à cinq instances dupliquées de sorte que chaque instance dupliquée reçoive idéalement 6 RPS de trafic, ce qui correspond à 60% d'utilisation par pod. Ce seuil est inférieur à l'objectif de 70% de l'utilisation. Les pods sont donc adaptés de manière appropriée. En fonction des fluctuations du trafic, le nombre d'instances dupliquées avec autoscaling peut également varier. Pour obtenir une description plus détaillée du calcul du nombre d'instances dupliquées, consultez la page Comportement de l'autoscaling.

Effectuer un autoscaling basé sur une métrique personnalisée ou externe

Pour créer des autoscalers horizontaux de pods pour les métriques personnalisées et externes, consultez la section Optimiser l'autoscaling des pods en fonction des métriques.

Procéder à un autoscaling basé sur plusieurs métriques

Cet exemple crée un autoscaler horizontal des pods qui réalise un autoscaling en fonction de l'utilisation du processeur et d'une métrique personnalisée nommée packets_per_second.

Si vous avez suivi l'exemple précédent et que vous disposez toujours d'un autoscaler horizontal de pods nommé nginx, supprimez-le avant de commencer cet exemple.

Vous aurez besoin de la version apiVersion: autoscaling/v2. Pour plus d'informations sur les API disponibles, consultez la page Versions d'API pour les objets HorizontalPodAutoscaler.

Enregistrez ce fichier manifeste YAML en tant que fichier nommé nginx-multiple.yaml :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nginx
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
  - type: Resource
    resource:
      name: memory
      target:
        type: AverageValue
        averageValue: 100Mi
  # Uncomment these lines if you create the custom packets_per_second metric and
  # configure your app to export the metric.
  # - type: Pods
  #   pods:
  #     metric:
  #       name: packets_per_second
  #     target:
  #       type: AverageValue
  #       averageValue: 100

Appliquez le manifeste YAML :

kubectl apply -f nginx-multiple.yaml

Une fois créé, l'autoscaler horizontal des pods surveille le déploiement nginx pour l'utilisation moyenne du processeur, l'utilisation moyenne de la mémoire et la métrique personnalisée packets_per_second si vous avez annulé la mise en commentaire. L'autoscaler horizontal des pods effectue un autoscaling du déploiement en fonction de la métrique dont la valeur crée l'événement d'autoscaling le plus important.

Configurer le profil HPA "Performance"

Le profil HPA "Performances" accélère le temps de réaction de l'autoscaler horizontal de pods et lui permet de recalculer rapidement jusqu'à 1 000 objets HorizontalPodAutoscaler. Vous pouvez l'activer pour les clusters nouveaux et existants.

Le profil HPA "Performances" est automatiquement activé pour les clusters Autopilot dont le plan de contrôle exécute la version 1.32 de GKE ou une version ultérieure et qui répondent aux exigences.

Conditions requises

Assurez-vous que vos clusters Autopilot et Standard répondent aux exigences suivantes :

Activer le profil HPA "Performances" dans un nouveau cluster

Autopilot

Pour créer un cluster Autopilot avec le profil HPA "Performances" activé, exécutez la commande suivante :

gcloud container clusters create-auto CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --cluster-version=CLUSTER_VERSION \
    --hpa-profile=performance

Remplacez :

  • CLUSTER_NAME : nom du cluster que vous créez.
  • LOCATION : zone ou région de calcul (par exemple, us-central1-a ou us-central1) pour le cluster.
  • PROJECT_ID : ID de votre projet Google Cloud .
  • CLUSTER_VERSION : version 1.31 de GKE ou ultérieure.

Standard

Pour créer un cluster Standard avec le profil HPA "Performances" activé, exécutez la commande suivante :

gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --cluster-version=CLUSTER_VERSION \
    --hpa-profile=performance

Remplacez :

  • CLUSTER_NAME : nom du cluster que vous créez.
  • LOCATION : zone ou région de calcul (par exemple, us-central1-a ou us-central1) pour le cluster.
  • PROJECT_ID : ID de votre projet Google Cloud .
  • CLUSTER_VERSION : version 1.31 de GKE ou ultérieure.

Activer le profil HPA "Performance" dans un cluster existant

Pour activer le profil HPA des performances dans un cluster existant, utilisez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --hpa-profile=performance

Remplacez :

  • CLUSTER_NAME : nom du cluster.
  • LOCATION : zone ou région de calcul (par exemple, us-central1-a ou us-central1) pour le cluster.
  • PROJECT_ID : ID de votre projet Google Cloud .

Désactiver le profil HPA des performances

Pour désactiver le profil HPA des performances dans un cluster, utilisez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --hpa-profile=none

Remplacez :

  • CLUSTER_NAME : nom du cluster.
  • LOCATION : zone ou région de calcul (par exemple, us-central1-a ou us-central1) pour le cluster.
  • PROJECT_ID : ID de votre projet Google Cloud .

Afficher les détails d'un autoscaler horizontal de pods

Pour afficher la configuration et les statistiques d'un autoscaler horizontal de pods, exécutez la commande suivante :

kubectl describe hpa HPA_NAME

Remplacez HPA_NAME par le nom de votre objet HorizontalPodAutoscaler.

Si l'autoscaler horizontal de pods utilise apiVersion: autoscaling/v2 et qu'il est basé sur plusieurs métriques, la commande kubectl describe hpa n'affiche que la métrique d'utilisation du processeur. Pour afficher toutes les métriques, exécutez la commande suivante :

kubectl describe hpa.v2.autoscaling HPA_NAME

Remplacez HPA_NAME par le nom de votre objet HorizontalPodAutoscaler.

L'état actuel de chaque autoscaler horizontal de pods est indiqué dans le champ Conditions et les événements d'autoscaling sont répertoriés dans le champ Events.

Le résultat ressemble à ce qui suit :

Name:                                                  nginx
Namespace:                                             default
Labels:                                                <none>
Annotations:                                           kubectl.kubernetes.io/last-applied-configuration:
                                                         {"apiVersion":"autoscaling/v2","kind":"HorizontalPodAutoscaler","metadata":{"annotations":{},"name":"nginx","namespace":"default"},"s...
CreationTimestamp:                                     Tue, 05 May 2020 20:07:11 +0000
Reference:                                             Deployment/nginx
Metrics:                                               ( current / target )
  resource memory on pods:                             2220032 / 100Mi
  resource cpu on pods  (as a percentage of request):  0% (0) / 50%
Min replicas:                                          1
Max replicas:                                          10
Deployment pods:                                       1 current / 1 desired
Conditions:
  Type            Status  Reason              Message
  ----            ------  ------              -------
  AbleToScale     True    ReadyForNewScale    recommended size matches current size
  ScalingActive   True    ValidMetricFound    the HPA was able to successfully calculate a replica count from memory resource
  ScalingLimited  False   DesiredWithinRange  the desired count is within the acceptable range
Events:                                                <none>

Supprimer un autoscaler horizontal de pods

Vous pouvez supprimer un autoscaler horizontal de pods à l'aide de la console Google Cloud ou de la commande kubectl delete.

Console

Pour supprimer l'autoscaler horizontal de pods nginx, procédez comme suit :

  1. Accédez à la page Charges de travail dans la console Google Cloud .

    Accéder à la page Charges de travail

  2. Cliquez sur le nom du déploiement nginx.

  3. Cliquez sur Actions > Évoluer automatiquement.

  4. Cliquez sur Supprimer.

kubectl delete

Pour supprimer l'autoscaler horizontal de pods nginx, utilisez la commande suivante :

kubectl delete hpa nginx

Lorsque vous supprimez un autoscaler horizontal de pods, le déploiement (ou un autre objet de déploiement) n'est pas mis à l'échelle et ne revient pas au nombre d'instances dupliquées du manifeste de déploiement d'origine. Pour rétablir manuellement le scaling du déploiement sur trois pods, vous pouvez utiliser la commande kubectl scale :

kubectl scale deployment nginx --replicas=3

Nettoyer

  1. Supprimez l'autoscaler horizontal de pods, si ce n'est pas déjà fait :

    kubectl delete hpa nginx
    
  2. Supprimez le déploiement nginx :

    kubectl delete deployment nginx
    
  3. Vous pouvez également supprimer le cluster.

Dépannage

Cette section décrit les étapes de dépannage pour les problèmes liés à l'autoscaling horizontal des pods.

L'autoscaler horizontal de pods affiche une erreur unable to fetch pod metrics for pod

Lorsque vous configurez un autoscaler horizontal de pods, des messages d'avertissement semblables aux suivants peuvent s'afficher :

unable to fetch pod metrics for pod

Il est normal que ce message s'affiche au démarrage du serveur de métriques. Toutefois, si vous continuez à voir des avertissements et que vous remarquez que les pods ne sont pas mis à l'échelle pour votre charge de travail, assurez-vous d'avoir spécifié des requêtes de ressources pour chaque conteneur de votre charge de travail. Pour utiliser des pourcentages cibles d'utilisation d'une ressource avec l'autoscaling horizontal des pods, vous devez configurer les requêtes pour cette ressource pour chaque conteneur et dans chaque pod de la charge de travail. Sinon, l'autoscaler de pods horizontaux ne peut pas effectuer les calculs nécessaires et n'effectue aucune action en lien avec cette métrique.

L'autoscaler horizontal de pods affiche un événement multiple services selecting the same target of...

Un autoscaler horizontal de pods affiche une erreur multiple services selecting the same target of <hpa>: <services> s'il détecte que vous utilisez l'autoscaling basé sur le trafic avec plusieurs services associés à la cible de l'autoscaler horizontal de pods (généralement un déploiement).

L'autoscaling basé sur le trafic n'est compatible qu'avec les configurations où un seul service est associé à la ressource à autoscaler. Pour en savoir plus, consultez Autoscaling basé sur le trafic de l'équilibreur de charge. Le message d'erreur liste les services qui ont été trouvés.

Pour résoudre le problème, assurez-vous qu'un seul service est associé à l'autoscaler horizontal de pods.

Étapes suivantes