Simple Log Service:PromQL and SQL query Metricstore common cases

Interroger les données d'une métrique unique

process_resident_memory_bytes rapporte la mémoire résidente d'un processus. La requête suivante renvoie toutes les séries temporelles pour cette métrique sur la plage de temps sélectionnée.

process_resident_memory_bytes

Filtrer les données de métrique par libellé

Ajoutez des sélecteurs de libellés entre accolades {} pour limiter les résultats à une valeur de libellé spécifique. La requête suivante renvoie la mémoire résidente uniquement pour le cluster sls-mall, puis convertit les octets en Mo.

process_resident_memory_bytes{cluster="sls-mall"}/1024/1024

Utiliser des expressions régulières pour le filtrage des libellés

Utilisez =~ au lieu de = pour faire correspondre les valeurs de libellé avec une expression régulière. La requête suivante renvoie les données où le cluster est sls-mall ou sls-demo.

process_resident_memory_bytes{cluster=~"sls-mall|sls-demo"}

Calculer la valeur maximale d'une métrique

max by (cluster) regroupe toutes les séries temporelles de chaque cluster en une seule série, en ne conservant que la valeur la plus élevée à chaque horodatage. La clause by (cluster) conserve le libellé du cluster et supprime tous les autres. La requête suivante renvoie la mémoire heap maximale par cluster en Mo.

max by (cluster) (go_memstats_heap_inuse_bytes) / 1024 / 1024

Calculer le nombre de séries temporelles pour une métrique

count() renvoie le nombre de séries temporelles actives qui correspondent à un sélecteur. Utilisez cette fonction pour vérifier combien d'instances signalent une métrique donnée. La requête suivante compte toutes les séries temporelles pour apiserver_request_total dans le cluster sls-mall.

count(apiserver_request_total{cluster="sls-mall"})

Calculer le taux de variation d'une métrique dans le temps

rate() calcule le taux de variation moyen par seconde sur une fenêtre de temps. Elle est conçue pour les métriques de type compteur qui ne font qu'augmenter ; utilisez-la pour calculer l'utilisation du CPU, le débit des requêtes et des taux similaires. La requête suivante renvoie le taux d'utilisation du CPU par seconde sur la dernière minute.

rate(process_cpu_seconds_total[1m])

Calculer la différence d'une métrique par rapport à il y a n minutes

delta() calcule la différence entre la première et la dernière valeur d'une métrique au sein d'une fenêtre de temps. Contrairement à rate(), delta() fonctionne avec les jauges, c'est-à-dire les métriques qui peuvent augmenter ou diminuer. La requête suivante renvoie la variation du nombre de goroutines sur la dernière minute.

delta(go_goroutines[1m])

Utilisation imbriquée de plusieurs opérateurs et fonctions

Les opérateurs et fonctions PromQL peuvent être imbriqués. Les expressions internes sont évaluées en premier et transmises en entrée à la fonction externe. La requête suivante calcule d'abord le nombre maximal de requêtes par cluster et ressource, puis sélectionne les trois combinaisons les plus élevées.

topk(3, max by (cluster, resource)(apiserver_request_total))

Calculs entre plusieurs valeurs

PromQL supporte les opérateurs arithmétiques standards (+, -, *, /, %) sur les nombres simples. L'exemple suivant s'évalue à 3.

1 + 2

Calculs entre des métriques et des valeurs

Les opérateurs arithmétiques s'appliquent également entre une métrique et un scalaire. La requête suivante convertit la métrique process_resident_memory_bytes d'octets en Mo.

process_resident_memory_bytes / 1024 / 1024

Opérations binaires entre plusieurs métriques

PromQL prend en charge les opérations binaires entre deux métriques. La mise en correspondance s'effectue sur les ensembles de libellés : seules les séries temporelles ayant des libellés identiques dans les deux métriques sont appariées. La requête suivante calcule le ratio entre les pods DaemonSet prêts et les pods planifiés.

kube_daemonset_status_number_ready{job="kube-state-metrics"} 
/ 
kube_daemonset_status_desired_number_scheduled{job="kube-state-metrics"}

Comment utiliser correctement une sous-requête

Des fonctions telles que rate(), delta(), increase() et {agg}_over_time() opèrent uniquement sur les données brutes de métrique ; elles ne peuvent pas prendre en entrée le résultat d'un opérateur d'agrégation. Utilisez une sous-requête pour contourner cette contrainte.

La syntaxe [a:b] dans une sous-requête spécifie la plage (a) et le pas (b).

• Pris en charge — max_over_time appliqué à une métrique brute :

  max_over_time(go_goroutines[1m]) # Returns the maximum goroutine count in the previous minute, per time series.

• Non pris en charge — max_over_time appliqué à un résultat agrégé :

  max_over_time(max(go_goroutines)[1m]) # Invalid: max(go_goroutines) produces a scalar, not a raw metric.

• Utilisation correcte — utilisez une sous-requête pour appliquer la fonction de plage après l'agrégation :

  # First aggregate across time series, then apply the range function via subquery.
  max_over_time(max(go_goroutines)[1m:10s])
  # [1m:10s] — evaluate max(go_goroutines) at 10-second steps over the past 1 minute, then take the max of those values.

Interroger toutes les données brutes sous une métrique

Renvoyez toutes les séries temporelles et échantillons pour process_resident_memory_bytes dans la plage de temps sélectionnée. (Démo )

 *| SELECT * FROM "metrics_store_name.prom" WHERE __name__ = 'process_resident_memory_bytes'

Interroger les données brutes avec une valeur d'instance spécifique pour une métrique

Étendez la requête précédente avec element_at() pour filtrer par une valeur de libellé spécifique. La requête suivante renvoie tous les échantillons où la métrique est process_resident_memory_bytes et l'instance est 172.20.0.143:8084. (Démo)

*| SELECT * FROM "metrics_store_name.prom" WHERE __name__ = 'process_resident_memory_bytes' and element_at(__labels__, 'instance')='172.20.0.143:8084' limit all

Agréger les données de série temporelle par minute

Alignez les horodatages sur les limites des minutes et calculez la valeur maximale de la métrique par instance. (Démo)

*| SELECT (__time_nano__ - __time_nano__ % 60000000)/1000000.0 as t, element_at(__labels__, 'instance') as instance, max(__value__) as val FROM "metrics_store_name.prom" WHERE __name__ = 'process_resident_memory_bytes' group by t, instance limit all