Utiliser les métriques d'état Kube

Autopilot Standard

Vous pouvez configurer un cluster Google Kubernetes Engine (GKE) pour envoyer un ensemble organisé de métriques d'état kube, y compris des métriques pour les pods, les déploiements, et plus encore à Cloud Monitoring à l'aide de Google Cloud Managed Service pour Prometheus. Ce document décrit le format de ces métriques lorsqu'elles sont écrites dans Cloud Monitoring et comment les interroger. Ce document fournit également des tableaux qui répertorient les métriques de chaque ensemble et fournit des informations sur l'utilisation de ces métriques.

Pour pouvoir utiliser des métriques d'état Kube, vous devez activer leur collecte.

Format de la métrique

Toutes les métriques d'état Kube de Kubernetes écrites dans Cloud Monitoring utilisent le type de ressource prometheus_target. Chaque nom de métrique inclut un préfixe prometheus.googleapis.com/ et un suffixe indiquant le type de métrique Prometheus, tel que /gauge, /histogram ou /counter. En dehors de cela, chaque nom de métrique est identique au nom de métrique exposé par Kubernetes Open Source.

Exporter depuis Cloud Monitoring

Les métriques d'état Kube peuvent être exportées depuis Cloud Monitoring à l'aide de l'API Cloud Monitoring. Comme toutes les métriques d'état kube sont ingérées à l'aide deGoogle Cloud Managed Service pour Prometheus, les métriques d'état kube peuvent être interrogées à l'aide du langage de requête Prometheus (PromQL). Vous pouvez également les interroger à l'aide du langage MQL (Monitoring Query Language).

Interroger les métriques

Lorsque vous interrogez les métriques d'état Kube, le nom que vous utilisez varie selon que vous utilisez des fonctionnalités basées sur PromQL ou Cloud Monitoring, telles que MQL ou l' interface basée sur des menus de l'Explorateur de métriques.

Les tableaux suivants des métriques d'état Kube affichent deux versions de chaque nom de métrique :

Nom de la métrique PromQL : lors de l'utilisation de PromQL sur des pages Cloud Monitoring de la console Google Cloud ou dans les champs PromQL de l'API Cloud Monitoring, utilisez le nom de la métrique PromQL.
Nom de la métrique Cloud Monitoring : lorsque vous utilisez d'autres fonctionnalités de Cloud Monitoring, utilisez le nom de la métrique Cloud Monitoring répertorié dans les tableaux ci-dessous. Ce nom doit être précédé du préfixe prometheus.googleapis.com/, qui a été omis dans les entrées du tableau.

Métriques de stockage

Les noms des métriques Cloud Monitoring figurant dans ce tableau doivent être précédés du préfixe prometheus.googleapis.com/. Ce préfixe a été omis dans les entrées du tableau.

Nom de la métrique PromQL Nom de la métrique Cloud Monitoring
Genre, Type, Unité Ressources surveillées Version de GKE requise	Description Libellés
`kube_persistentvolume_capacity_bytes` `kube_persistentvolume_capacity_bytes/gauge`
`GAUGE`, `DOUBLE`, `By` prometheus_target 1.27.2-gke.1200	Capacité persistentvolume en octets. Cette valeur est échantillonnée toutes les 30 secondes. `persistentvolume` : persistentvolume.
`kube_persistentvolume_claim_ref` `kube_persistentvolume_claim_ref/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Informations sur la référence de revendication de volume persistant. Cette valeur est échantillonnée toutes les 30 secondes. `claim_name` : claim_name. `name` : name. `persistentvolume` : persistentvolume.
`kube_persistentvolume_info` `kube_persistentvolume_info/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Informations sur persistentvolume. Cette valeur est échantillonnée toutes les 30 secondes. `csi_driver` : csi_driver. `csi_volume_handle` : csi_volume_handle. `local_fs` : local_fs. `local_path` : local_path. `persistentvolume` : persistentvolume. `storageclass` : storageclass.
`kube_persistentvolume_status_phase` `kube_persistentvolume_status_phase/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	La phase indique si un volume est disponible, lié à une revendication ou fourni par une revendication. Cette valeur est échantillonnée toutes les 30 secondes. `persistentvolume` : persistentvolume. `phase` : phase.
`kube_persistentvolumeclaim_info` `kube_persistentvolumeclaim_info/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Informations sur la revendication de volume persistant. Cette valeur est échantillonnée toutes les 30 secondes. `persistentvolumeclaim` : persistentvolumeclaim. `storageclass` : storageclass. `volumename` : volumename.
`kube_persistentvolumeclaim_resource_requests_storage_bytes` `kube_persistentvolumeclaim_resource_requests_storage_bytes/gauge`
`GAUGE`, `DOUBLE`, `By` prometheus_target 1.27.2-gke.1200	Capacité de stockage demandée par la revendication de volume persistant. Cette valeur est échantillonnée toutes les 30 secondes. `persistentvolumeclaim` : persistentvolumeclaim.
`kube_persistentvolumeclaim_status_phase` `kube_persistentvolumeclaim_status_phase/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Phase où se trouve actuellement la revendication de volume persistant. Cette valeur est échantillonnée toutes les 30 secondes. `persistentvolumeclaim` : persistentvolumeclaim. `phase` : phase.

Pour en savoir plus, consultez les pages Métriques PersistentVolume et Métriques PersistentVolumeClaim.

Métriques de pod

Un pod est un groupe d'un ou plusieurs conteneurs avec une spécification d'exécution des conteneurs, qui partagent des ressources réseau et de stockage.

Tableau des métriques des pods

Les métriques des pods vous permettent de surveiller le comportement de vos pods et d'envoyer des alertes. Le tableau suivant présente les métriques disponibles dans le package de métriques d'état kube :

Les noms des métriques Cloud Monitoring figurant dans ce tableau doivent être précédés du préfixe prometheus.googleapis.com/. Ce préfixe a été omis dans les entrées du tableau.

Nom de la métrique PromQL Nom de la métrique Cloud Monitoring
Genre, Type, Unité Ressources surveillées Version de GKE requise	Description Libellés
`kube_pod_container_status_ready` `kube_pod_container_status_ready/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Décrit si la vérification de préparation des conteneurs a réussi. Cette valeur est échantillonnée toutes les 30 secondes. `container` : container. `pod` : pod. `uid` : uid.
`kube_pod_container_status_waiting_reason` `kube_pod_status_container_status_waiting_reason/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Décrit la raison pour laquelle le conteneur est actuellement en attente. Cette valeur est échantillonnée toutes les 30 secondes. `container` : container. `pod` : pod. `reason` : reason. `uid` : uid.
`kube_pod_status_phase` `kube_pod_status_phase/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Phase actuelle des pods. Cette valeur est échantillonnée toutes les 30 secondes. `phase` : phase. `pod` : pod. `uid` : uid.
`kube_pod_status_unschedulable` `kube_pod_status_unschedulable/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Décrit l'état non programmable du pod. Cette valeur est échantillonnée toutes les 30 secondes. `pod` : pod. `uid` : uid.

Pour en savoir plus, consultez la page Métriques des pods.

Exemples de requêtes pour les métriques de pod

Pour déterminer si vous disposez de pods non programmables, utilisez l'expression PromQL suivante :

sum(kube_pod_status_unschedulable{cluster="CLUSTER", namespace="NAMESPACE"})

Pour émettre des alertes sur un certain nombre de pods non programmables dans un espace de noms, vous pouvez utiliser l'expression PromQL suivante :

sum(kube_pod_status_unschedulable{cluster="CLUSTER", namespace="NAMESPACE"}) > LIMIT

Vous pouvez utiliser la métrique kube_pod_container_status_waiting_reason pour créer une alerte pour un conteneur bloqué dans un état d'attente spécifique à l'aide d'une expression PromQL comme suit :

max_over_time(kube_pod_container_status_waiting_reason{reason="REASON", cluster="CLUSTER", namespace="NAMESPACE"}[5m]) >= 1

La valeur de REASON spécifie l'état d'attente du conteneur, par exemple :

CrashLoopBackOff
ImagePullBackOff
ContainerCreating

Pour créer une alerte pour un conteneur bloqué dans l'un des états d'attente, utilisez l'expression PromQL suivante :

max_over_time(kube_pod_container_status_waiting_reason{cluster="CLUSTER", namespace="NAMESPACE"}[5m]) >= 1

Pour déterminer combien de conteneurs échouent aux vérifications d'aptitude, utilisez l'expression PromQL suivante

sum(kube_pod_container_status_ready) by (pod, container) == 0

Certaines des expressions de requête et d'alerte de cette section ont été adaptées à partir du fichier kubernetes-apps.yaml du dépôt de charts Helm Kubernetes Helm de la communauté Prometheus sur GitHub.

Playbooks interactifs

Les métriques Kube State Metrics sont également utilisées dans les playbooks interactifs de GKE pour le dépannage des pods non programmables ou qui subissent des plantages en boucle. Pour plus d'informations sur ces modes de défaillance, consultez les documents de dépannage suivants :

Si le package de métriques d'état kube n'est pas activé, le principal moyen de détecter les problèmes de planification des pods consiste à interroger les événements de journaux "Failed scheduling" (Planification ayant échoué). Après avoir activé le package Kube State Metrics, vous pouvez utiliser la métrique kube_pod_status_unschedulable, qui a le même objectif, mais est plus facile à agréger et à représenter graphiquement. En utilisant la métrique, vous pouvez voir combien de pods ne peuvent pas être programmés et quand le problème a commencé.

De même, la métrique système GKE kubernetes.io/container/restart_count peut vous aider à détecter le plantage en boucle des pods. La métrique kube_pod_container_status_waiting_reason énumère également les plantages en boucle des pods et vous permet aussi de déterminer si les pods sont bloqués dans des états d'attente autres que CrashLookBackOff, comme ImagePullBackOff et ContainerCreating.

Pour explorer les playbooks interactifs, procédez comme suit :

Dans la console Google Cloud, accédez à la page Tableaux de bord .
Accéder à la page Tableaux de bord

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Surveillance.
Filtrez la liste des tableaux de bord en cliquant sur la catégorie GCP.
Cliquez sur le nom d'un tableau de bord "GKE Interactive Playbook" dans la liste.

Métriques de déploiement

Un déploiement est un contrôleur qui met à jour l'état des ressources telles que les pods, afin de gérer des événements tels que les déploiements et les arrêts.

Tableau des métriques de déploiement

Les métriques de déploiement vous permettent de surveiller le comportement du contrôleur et d'envoyer des alertes. Le tableau suivant présente les métriques disponibles dans le package de métriques d'état kube :

Les noms des métriques Cloud Monitoring figurant dans ce tableau doivent être précédés du préfixe prometheus.googleapis.com/. Ce préfixe a été omis dans les entrées du tableau.

Nom de la métrique PromQL Nom de la métrique Cloud Monitoring
Genre, Type, Unité Ressources surveillées Version de GKE requise	Description Libellés
`kube_deployment_spec_replicas` `kube_deployment_spec_replicas/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre de pods souhaités pour un déploiement. Cette valeur est échantillonnée toutes les 30 secondes. `deployment` : deployment.
`kube_deployment_status_replicas_available` `kube_deployment_status_replicas_available/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre d'instances répliquées disponibles par déploiement. Cette valeur est échantillonnée toutes les 30 secondes. `deployment` : deployment.
`kube_deployment_status_replicas_updated` `kube_deployment_status_replicas_updated/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre d'instances répliquées mises à jour par déploiement. Cette valeur est échantillonnée toutes les 30 secondes. `deployment` : deployment.

Pour en savoir plus, consultez la page Métriques de déploiement.

Exemples de requêtes pour les métriques de déploiement

Vous pouvez créer des graphiques et des règles d'alerte pour des déploiements individuels en filtrant les métriques de déploiement par cluster, espace de noms et nom du déploiement.

Par exemple, pour comparer le nombre d'instances répliquées disponibles au nombre attendu dans un déploiement unique, vous pouvez utiliser les requêtes PromQL suivantes pour tracer les deux métriques sur un seul graphique :

kube_deployment_spec_replicas{cluster="CLUSTER", namespace="NAMESPACE", deployment=DEPLOYMENT"}

kube_deployment_status_replicas_available{cluster="CLUSTER", namespace="NAMESPACE", deployment=DEPLOYMENT"}

Pour émettre une alerte en cas de déploiement ayant échoué ou bloqué, vous pouvez utiliser l'expression PromQL suivante :

(
  kube_deployment_spec_replicas{cluster="CLUSTER", namespace="NAMESPACE", deployment="DEPLOYMENT"}
    >
  kube_deployment_status_replicas_available{cluster="CLUSTER", namespace="NAMESPACE", deployment="DEPLOYMENT"}
) and (
  changes(kube_deployment_status_replicas_updated{cluster="CLUSTER", namespace="NAMESPACE", deployment="DEPLOYMENT"}[10m])
    ==
  0
)

Métriques StatefulSet

Un StatefulSet est un contrôleur qui gère le déploiement et le scaling d'un ensemble de pods pour les applications avec état. Ce contrôleur gère l'ordre et l'unicité des pods.

Tableau des métriques StatefulSet

Les métriques StatefulSet vous permettent de surveiller le comportement du contrôleur et d'envoyer des alertes. Le tableau suivant présente les métriques disponibles dans le package de métriques d'état kube :

Les noms des métriques Cloud Monitoring figurant dans ce tableau doivent être précédés du préfixe prometheus.googleapis.com/. Ce préfixe a été omis dans les entrées du tableau.

Nom de la métrique PromQL Nom de la métrique Cloud Monitoring
Genre, Type, Unité Ressources surveillées Version de GKE requise	Description Libellés
`kube_statefulset_replicas` `kube_statefulset_replicas/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre de pods souhaités pour un StatefulSet. Cette valeur est échantillonnée toutes les 30 secondes. `statefulset` : statefulset.
`kube_statefulset_status_replicas_ready` `kube_statefulset_status_replicas_ready/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre d'instances répliquées mises à jour par StatefulSet. Cette valeur est échantillonnée toutes les 30 secondes. `statefulset` : statefulset.
`kube_statefulset_status_replicas_updated` `kube_statefulset_status_replicas_updated/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre d'instances répliquées mises à jour par StatefulSet. Cette valeur est échantillonnée toutes les 30 secondes. `statefulset` : statefulset.

Pour plus d'informations, consultez la page Métriques StatefulSet.

Exemples de requêtes pour les métriques StatefulSet

Vous pouvez créer des graphiques et des règles d'alerte pour des StatefulSets individuels en filtrant les métriques statefulset par cluster, espace de noms et nom du StatefulSet.

Par exemple, pour comparer le nombre d'instances répliquées disponibles au nombre attendu dans un seul objet StatefulSet, vous pouvez utiliser les requêtes PromQL suivantes pour tracer les deux métriques sur un seul graphique :

kube_statefulset_replicas{cluster="CLUSTER", namespace="NAMESPACE", statefulset="STATEFULSET"}

kube_statefulset_status_replicas_ready{cluster="CLUSTER", namespace="NAMESPACE", statefulset="STATEFULSET"}

Pour émettre une alerte en cas de déploiement d'un StatefulSet ayant échoué ou bloqué, vous pouvez utiliser l'expression PromQL suivante :

(
  kube_statefulset_replicas{cluster="CLUSTER", namespace="NAMESPACE", statefulset="STATEFULSET"}
    >
  kube_statefulset_status_replicas_ready{cluster="CLUSTER", namespace="NAMESPACE", statefulset="STATEFULSET"}
) and (
  changes(kube_statefulset_status_replicas_updated{cluster="CLUSTER", namespace="NAMESPACE", statefulset="STATEFULSET"}[10m])
    ==
  0
)

Métriques DaemonSet

Un DaemonSet est un contrôleur qui garantit que certains ensembles de nœuds exécutent une copie d'un pod. Par exemple, lorsque des nœuds sont ajoutés à un cluster, le DaemonSet ajoute des pods aux nœuds. Ce contrôleur permet de s'assurer que certains processus s'exécutent sur chaque nœud.

Tableau des métriques DaemonSet

Les métriques DaemonSet vous permettent de surveiller le comportement du contrôleur et d'envoyer des alertes. Le tableau suivant présente les métriques disponibles dans le package de métriques d'état kube :

Les noms des métriques Cloud Monitoring figurant dans ce tableau doivent être précédés du préfixe prometheus.googleapis.com/. Ce préfixe a été omis dans les entrées du tableau.

Nom de la métrique PromQL Nom de la métrique Cloud Monitoring
Genre, Type, Unité Ressources surveillées Version de GKE requise	Description Libellés
`kube_daemonset_status_desired_number_scheduled` `kube_daemonset_status_desired_number_scheduled/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre de nœuds devant exécuter le pod daemon. Cette valeur est échantillonnée toutes les 30 secondes. `daemonset` : daemonset.
`kube_daemonset_status_number_misscheduled` `kube_daemonset_status_number_misscheduled/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre de nœuds exécutant un pod daemon, mais qui ne sont pas censés le faire. Cette valeur est échantillonnée toutes les 30 secondes. `daemonset` : daemonset.
`kube_daemonset_status_number_ready` `kube_daemonset_status_number_ready/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre de nœuds qui doivent exécuter le pod daemon et disposer d'un ou de plusieurs pods daemon en cours d'exécution et prêts. Cette valeur est échantillonnée toutes les 30 secondes. `daemonset` : daemonset.
`kube_daemonset_status_updated_number_scheduled` `kube_daemonset_status_updated_number_scheduled/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre de nœuds qui exécutent un pod daemon mis à jour. Cette valeur est échantillonnée toutes les 30 secondes. `daemonset` : daemonset.

Pour plus d'informations, consultez la page Métriques DaemonSet.

Exemples de requêtes pour les métriques DaemonSet

Vous pouvez créer des graphiques et des règles d'alerte pour des DaemonSets individuels en filtrant les métriques Daemonset par cluster, espace de noms et nom du DaemonSet.

Par exemple, pour comparer le nombre d'instances répliquées disponibles au nombre attendu dans un seul DaemonSet, vous pouvez utiliser les requêtes PromQL suivantes pour tracer les deux métriques sur un seul graphique :

kube_daemonset_status_updated_number_scheduled{cluster="CLUSTER", namespace="NAMESPACE", daemonsetset=DAEMONSET"}

kube_daemonset_status_desired_number_scheduled{cluster="CLUSTER", namespace="NAMESPACE", daemonset=DAEMONSET"}

Pour émettre une alerte en cas de déploiement de DaemonSet défaillant ou bloqué, vous pouvez utiliser l'expression PromQL suivante :

(
  (
    kube_daemonset_status_number_misscheduled{cluster="CLUSTER", namespace="NAMESPACE", daemonset="DAEMONSET"}
      !=
    0
  ) or (
    kube_daemonset_status_updated_number_scheduled{cluster="CLUSTER", namespace="NAMESPACE", daemonset="DAEMONSET"}
      !=
    kube_daemonset_status_desired_number_scheduled{cluster="CLUSTER", namespace="NAMESPACE", daemonset="DAEMONSET"}
  )
) and (
  changes(kube_daemonset_status_updated_number_scheduled{cluster="CLUSTER", namespace="NAMESPACE", daemonset="DAEMONSET"}[5m])
    ==
  0
)

Métriques HorizontalPodAutoscaler

Un objet HorizontalPodAutoscaler (HPA) est un contrôleur qui modifie régulièrement le nombre de pods dans une charge de travail, comme un déploiement ou un StatefulSet, en réponse à une métrique telle que l'utilisation du processeur ou de la mémoire. La modification du nombre de pods disponibles pour une charge de travail permet de maintenir cette dernière réactive, mais efficace.

Pour en savoir plus sur les HPA, consultez la page Afficher les détails d'un autoscaler horizontal de pods.

Tableau des métriques HPA

Les métriques HorizontalPodAutoscaler vous permettent de surveiller le comportement du contrôleur et d'envoyer des alertes. Le tableau suivant présente les métriques disponibles dans le package de métriques d'état kube :

Les noms des métriques Cloud Monitoring figurant dans ce tableau doivent être précédés du préfixe prometheus.googleapis.com/. Ce préfixe a été omis dans les entrées du tableau.

Nom de la métrique PromQL Nom de la métrique Cloud Monitoring
Genre, Type, Unité Ressources surveillées Version de GKE requise	Description Libellés
`kube_horizontalpodautoscaler_spec_max_replicas` `kube_horizontalpodautoscaler_spec_max_replicas/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Limite supérieure pour le nombre de pods pouvant être définis par l'autoscaler, qui ne peut pas être inférieur à la valeur de MinReplicas. Cette valeur est échantillonnée toutes les 30 secondes. `horizontalpodautoscaler` : horizontalpodautoscaler.
`kube_horizontalpodautoscaler_spec_min_replicas` `kube_horizontalpodautoscaler_spec_min_replicas/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Limite inférieure pour le nombre de pods pouvant être définis par l'autoscaler, par défaut 1. Cette valeur est échantillonnée toutes les 30 secondes. `horizontalpodautoscaler` : horizontalpodautoscaler.
`kube_horizontalpodautoscaler_spec_target_metric` `kube_horizontalpodautoscaler_spec_target_metric/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Spécifications de métriques utilisées par l'autoscaler lors du calcul du nombre d'instances dupliquées souhaité. Cette valeur est échantillonnée toutes les 30 secondes. `horizontalpodautoscaler` : horizontalpodautoscaler. `metric_name` : metric_name. `metric_target_type` : metric_target_type.
`kube_horizontalpodautoscaler_status_condition` `kube_horizontalpodautoscaler_status_condition/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Condition de l'autoscaler. Cette valeur est échantillonnée toutes les 30 secondes. `condition` : condition. `horizontalpodautoscaler` : horizontalpodautoscaler. `namespace` : namespace. `status` : status.
`kube_horizontalpodautoscaler_status_current_replicas` `kube_horizontalpodautoscaler_status_status_current_replicas/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre actuel d'instances dupliquées de pods gérés par cet autoscaler. Cette valeur est échantillonnée toutes les 30 secondes. `horizontalpodautoscaler` : horizontalpodautoscaler.
`kube_horizontalpodautoscaler_status_desired_replicas` `kube_horizontalpodautoscaler_status_desired_replicas/gauge`
`GAUGE`, `DOUBLE`, `1` prometheus_target 1.27.2-gke.1200	Nombre souhaité d'instances dupliquées de pods gérés par cet autoscaler. Cette valeur est échantillonnée toutes les 30 secondes. `horizontalpodautoscaler` : horizontalpodautoscaler.

Pour en savoir plus, consultez la page Métriques de l'autoscaler horizontal de pods.

Exemples de requêtes pour les métriques HPA

Par exemple, pour déterminer si le HPA approche du nombre maximal d'instances répliquées, vous pouvez tracer le ratio suivant :

kube_horizontalpodautoscaler_status_current_replicas{cluster="CLUSTER", namespace="NAMESPACE", horizontalpodautoscaler="HPA"} /
kube_horizontalpodautoscaler_spec_max_replicas{cluster="CLUSTER", namespace="NAMESPACE", horizontalpodautoscaler="HPA"}

Lorsque le HPA est exécuté avec le nombre maximal d'instances répliquées, vous pouvez augmenter la spécification pour le nombre maximal de pods. Vous pouvez utiliser l'expression PromQL suivante pour créer une alerte vous informant de ce cas :

kube_horizontalpodautoscaler_status_current_replicas{cluster="CLUSTER", namespace="NAMESPACE", horizontalpodautoscaler="HPA"}
  ==
kube_horizontalpodautoscaler_spec_max_replicas{cluster="CLUSTER", namespace="NAMESPACE", horizontalpodautoscaler="HPA"}

Vous pouvez également comparer les valeurs des métriques kube_horizontalpodautoscaler_status_current_replicas et kube_horizontalpodautoscaler_status_desired_replicas pour déterminer s'il existe une différence entre le nombre actuel et le nombre requis d'instances répliquées. Une différence peut indiquer une contrainte de ressource dans le cluster. L'expression PromQL suivante recherche les différences entre le nombre actuel d'instances répliquées et le nombre requis/minimal/maximal d'instances répliquées, ainsi que les modifications du nombre actuel d'instances répliquées :

(kube_horizontalpodautoscaler_status_desired_replicas{job="kube-state-metrics", namespace=~"NAMESPACE"}
  !=
kube_horizontalpodautoscaler_status_current_replicas{job="kube-state-metrics", namespace=~"NAMESPACE"})
  and
(kube_horizontalpodautoscaler_status_current_replicas{job="kube-state-metrics", namespace=~"NAMESPACE"}
  >
kube_horizontalpodautoscaler_spec_min_replicas{job="kube-state-metrics", namespace=~"NAMESPACE"})
  and
(kube_horizontalpodautoscaler_status_current_replicas{job="kube-state-metrics", namespace=~"NAMESPACE"}
  <
kube_horizontalpodautoscaler_spec_max_replicas{job="kube-state-metrics", namespace=~"NAMESPACE"})
  and
changes(kube_horizontalpodautoscaler_status_current_replicas{job="kube-state-metrics", namespace=~"NAMESPACE"}[15m]) == 0

Les libellés condition et status de la métrique kube_horizontalpodautoscaler_status_condition peuvent également vous aider à détecter les cas d'exécution des HPA dans différents modes de défaillance. Par exemple :

La condition ScalingLimited et l'état true indiquent que le HPA est lié au nombre minimal ou maximal d'instances répliquées :
```
kube_horizontalpodautoscaler_status_condition{status="true", condition="ScalingLimited"} == 1
```
La condition AbleToScale et l'état false indiquent que le HPA rencontre des problèmes pour récupérer ou mettre à jour les échelles :
```
kube_horizontalpodautoscaler_status_condition{status="false", condition="AbleToScale"} == 1
```
La condition ScalingActive et l'état false indiquent que le HPA est désactivé ou qu'il ne peut pas calculer une nouvelle échelle :
```
kube_horizontalpodautoscaler_status_condition{status="false", condition="ScalingActive"} == 1
```