Collecter et afficher les métriques Kube State Metrics

Autopilot Standard

Cette page explique comment configurer un cluster Google Kubernetes Engine (GKE) pour envoyer un ensemble organisé d'états kube, y compris des métriques pour les pods et les déploiements, à Cloud Monitoring à l'aide de Google Cloud Managed Service pour Prometheus. Cette page décrit également le format de ces métriques lorsqu'elles sont écrites dans Monitoring, et comment interroger des métriques.

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.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Conditions requises

Pour collecter des métriques d'état Kube, votre cluster GKE doit répondre aux exigences suivantes :

Le cluster doit exécuter GKE 1.27.2-gke.1200 ou une version ultérieure. Pour les clusters GKE Standard à partir de la version 1.29.2-gke.2000 et les clusters GKE Autopilot à partir de la version 1.27.4-gke.900, le package de métriques d'état Kube est activé par défaut.
Les métriques système doivent être activées sur le cluster.
La collecte gérée de Google Cloud Managed Service pour Prometheus doit être activée sur le cluster. La collecte gérée Google Cloud Managed Service pour Prometheus est activée par défaut sur les nouveaux clusters.

Configurer la collecte de métriques d'état Kube

Vous pouvez activer les métriques d'état de kube à l'aide de la console Google Cloud, de gcloud CLI ou de Terraform:

Console

Vous pouvez activer les métriques d'état kube à partir d'un onglet Observabilité pour un cluster ou un déploiement dans un cluster. Vous pouvez également prévisualiser les graphiques et les métriques disponibles avant d'activer le package de métriques.

Dans l'onglet Observabilité d'un cluster, vous pouvez filtrer l'ensemble de graphiques pour les métriques d'état kube en fonction des deux éléments suivants:

État des charges de travail : inclut les métriques pour les pods, les déploiements, les objets StatefulSet, les objets DaemonSets et les ressources HorizontalPodAutoscaler.
Stockage > Persistent : inclut les métriques des volumes persistants et des revendications de volume persistant.

Vous pouvez activer l'un des ensembles de métriques ou les deux.

Pour activer les métriques d'état Kube à partir de l'onglet Observabilité d'un cluster, procédez comme suit :

Dans la console Cloud Console, accédez à la page des clusters Kubernetes.
Accéder à la page Clusters Kubernetes

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Kubernetes Engine.
Cliquez sur le nom de votre cluster, puis sélectionnez l'onglet Observabilité.
Sélectionnez État des charges de travail ou Stockage > Persistant dans la liste des fonctionnalités.
Cliquez sur Activer le package.

Si le package de métriques d'état kube est déjà activé, vous voyez à la place un ensemble de graphiques pour les métriques d'état Kube.

Pour activer les métriques d'état Kube à partir de l'onglet Observabilité d'un déploiement, procédez comme suit :

Dans la console Google Cloud, accédez à la page Charges de travail.
Accéder à la page Charges de travail

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Kubernetes Engine.
Cliquez sur le nom de votre déploiement, puis sélectionnez l'onglet Observabilité.
Sélectionnez État Kube dans la liste des fonctionnalités.
Cliquez sur Activer le package. Le package est activé pour l'ensemble du cluster.

Si le package de métriques d'état kube est déjà activé, vous voyez à la place un ensemble de graphiques pour les métriques des pods, des déploiements et des autoscalers horizontaux de pods.

Pour configurer les métriques d'état Kube à partir de l'onglet Détails du cluster, procédez comme suit :

Dans la console Cloud Console, accédez à la page des clusters Kubernetes.
Accéder à la page Clusters Kubernetes

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Kubernetes Engine.
Cliquez sur le nom de votre cluster.
Sur la ligne Fonctionnalités intitulée Cloud Monitoring, cliquez sur l'icône Modifier.
Dans la boîte de dialogue Modifier Cloud Monitoring qui s'affiche, vérifiez que l'option Activer Cloud Monitoring est sélectionnée.
Dans le menu déroulant Composants, sélectionnez les composants d'état Kube à partir desquels vous souhaitez collecter des métriques.
Cliquez sur OK.
Cliquez sur Save Changes (Enregistrer les modifications).

gcloud

Mettez à jour votre cluster pour collecter des métriques:

gcloud container clusters update CLUSTER_NAME \
    --location=COMPUTE_LOCATION \
    --enable-managed-prometheus \
    --monitoring=SYSTEM,DAEMONSET,DEPLOYMENT,HPA,POD,STATEFULSET,STORAGE

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster existant.
COMPUTE_LOCATION : emplacement Compute Engine du cluster.

L'ensemble de valeurs fourni à l'option monitoring remplace tous les paramètres précédents.

Terraform

Pour configurer la collecte de métriques d'état kube à l'aide de Terraform, consultez le bloc monitoring_config dans le registre Terraform pour google_container_cluster. Pour obtenir des informations générales sur l'utilisation de Google Cloud avec Terraform, consultez la page Terraform avec Google Cloud.

Quota

Les métriques d'état Kube consomment le quota Requêtes d'ingestion de séries temporelles par minute de l'API Cloud Monitoring. Avant d'activer les métriques d'état Kube, vérifiez votre utilisation maximale récente de ce quota. Si vous avez plusieurs clusters dans le même projet ou que vous approchez déjà de la limite de ce quota, vous pouvez demander une augmentation de la limite de quota avant d'activer un package d'observabilité.

Tarifs

Les métriques d'état Kube utilisent Google Cloud Managed Service pour Prometheus pour charger des métriques dans Cloud Monitoring. Les frais liés à l'ingestion de ces métriques sont calculés par Cloud Monitoring en fonction du nombre d'échantillons ingérés. Toutefois, ces métriques sont gratuites pour les clusters enregistrés qui appartiennent à un projet sur lequel l'édition GKE Enterprise est activée.

Pour en savoir plus, consultez la tarification Cloud Monitoring.

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 Monitoring.
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. 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
```