Indicateurs de suivi communs
Dans cette section, nous découvrirons certains indicateurs courants de surveillance des nœuds, tels que le processeur, la mémoire, la surveillance des E/S, etc.
Surveillance du processeur
Pour les nœuds, la première chose à laquelle nous pouvons penser est de surveiller d'abord le CPU, car le CPU est le cœur des tâches de traitement, et l'état de santé du système actuel peut être analysé en fonction de l'état du CPU. Pour surveiller le CPU du nœud, vous devez utiliser node_cpu_seconds_total cet indicateur de surveillance. Le contenu de l'indicateur dans l'interface des métriques est le suivant :
temps passé par CPU dans chaque mode
# HELP node_cpu_seconds_total Seconds the CPUs spent in each mode.
# TYPE node_cpu_seconds_total counter
node_cpu_seconds_total{cpu="0",mode="idle"} 13172.76
node_cpu_seconds_total{cpu="0",mode="iowait"} 0.25
node_cpu_seconds_total{cpu="0",mode="irq"} 0
node_cpu_seconds_total{cpu="0",mode="nice"} 0.01
node_cpu_seconds_total{cpu="0",mode="softirq"} 87.99
node_cpu_seconds_total{cpu="0",mode="steal"} 0
node_cpu_seconds_total{cpu="0",mode="system"} 309.38
node_cpu_seconds_total{cpu="0",mode="user"} 79.93
node_cpu_seconds_total{cpu="1",mode="idle"} 13168.98
..............................................................
On peut voir d'après la description de l'interface que cet indicateur sert à comptabiliser le temps passé dans chaque mode du CPU. C'est un indicateur de type Compteur, c'est-à-dire qu'il augmentera toujours. Cette valeur est en fait une valeur cumulée de la tranche de temps du processeur, ce qui signifie que lorsque le processeur commence à fonctionner depuis le démarrage du système d'exploitation, il commence à enregistrer le temps total utilisé par lui-même, puis l'enregistre . De plus, le temps d'utilisation du processeur accumulé ici sera également divisé en plusieurs modes différents, tels que le temps d'utilisation du mode utilisateur, le temps d'inactivité et le temps d'interruption. , le temps d'utilisation du mode noyau, etc., c'est-à-dire les informations liées au processeur que nous utilisons généralement la commande top pour afficher, et cet indicateur ici enregistrera ces modes séparément.
Ensuite, surveillons le CPU du nœud. Nous savons également qu'un temps CPU qui a augmenté n'a pas de sens pour nous. Généralement, nous voulons surveiller l'utilisation du CPU du nœud, qui est le pourcentage que nous voyons avec la commande top .
Pour calculer l'utilisation du processeur, vous devez comprendre la signification de cette utilisation. L' utilisation du processeur est le résultat de la division de la somme des temps de tous les états du processeur, à l'exception de l'état d'inactivité, par le temps total du processeur . Comprendre Après avoir compris ce concept, vous pouvez écrivez l'instruction de requête promql correcte.
Pour calculer la somme du temps CPU à l'exception de l'état d'inactivité, une meilleure façon est de calculer directement l'utilisation du temps CPU à l'état d'inactivité, puis de la soustraire de 1 pour obtenir le résultat que nous voulons, donc nous filtrons d'abord idle les indicateurs de la mode, Saisir et filtrer dans l'interface Web de Prometheus node_cpu_seconds_total{mode="idle"} : (l'augmentation correspond en fait à la différence entre le premier échantillon et le dernier échantillon)
Pour calculer le taux d'utilisation, nous devons savoir idle combien de temps le CPU du mode a été utilisé, puis le comparer avec le total. Puisqu'il s'agit de l'indicateur Counter, nous pouvons utiliser la increase fonction pour obtenir les modifications et utiliser l'instruction de requête increase(node_cpu_seconds_total{mode="idle"}[1m]), car la increase fonction nécessite l'entrée d'un vecteur d'intervalle . , nous prenons donc ici les données en 1 minute :
Nous pouvons voir qu'il existe de nombreuses données avec différents numéros de série de processeurs dans les résultats de la requête. Bien sûr, nous devons calculer le temps de tous les processeurs, nous les agrégeons donc. Ce que nous voulons interroger, c'est l'utilisation du processeur de différents nœuds, donc nous devons instance agréger en fonction des balises. , utilisez l'instruction de requête sum(increase(node_cpu_seconds_total{mode="idle"}[1m])) by (instance) : (la durée d'utilisation du processeur inactif en une minute)
De cette façon, nous pouvons obtenir le temps d'utilisation CPU inactif de différents nœuds en 1 minute, puis le comparer avec le temps CPU total (pas besoin de filtrer le mode d'état à ce moment), et utiliser l'instruction de requête sum(increase(node_cpu_seconds_total{mode="idle"}[1m])) by (instance) / sum(increase(node_cpu_seconds_total[1m])) by (instance):
Ensuite, le calcul de l'utilisation du processeur est aussi simple que 1 moins multiplié par 100 : (1 - sum(increase(node_cpu_seconds_total{mode="idle"}[1m])) by (instance) / sum(increase(node_cpu_seconds_total[1m])) by (instance) ) * 100. C'est le moyen le plus direct d'interroger l'utilisation du processeur auquel on puisse penser. Bien sûr, comme mentionné dans la syntaxe promql que nous avons apprise précédemment, nous utiliserons des rate fonctions au lieu de increase fonctions pour le calcul, de sorte que l'utilisation finale du processeur est L'instruction de requête est : (1 - sum(rate(node_cpu_seconds_total{mode="idle"}[1m])) by (instance) / sum(rate(node_cpu_seconds_total[1m])) by (instance) ) * 100.
Il peut être comparé aux résultats de la commande top (la figure ci-dessous montre le nœud node2), qui est fondamentalement la même. C'est la façon de surveiller l'utilisation du processeur du nœud.
surveillance de la mémoire
En plus de la surveillance du processeur, nous pouvons être plus préoccupés par la surveillance de la mémoire du nœud. Habituellement, nous utilisons essentiellement la free commande pour vérifier l'utilisation de la mémoire du nœud :
free La sortie de la commande affichera l'utilisation de la mémoire système, y compris la mémoire physique, la mémoire d'échange (swap) et la mémoire tampon du noyau, etc. Donc, pour surveiller la mémoire, nous devons d'abord comprendre ces concepts. Comprenons d'abord free la sortie de ce qui suit commander:
Mem 行(la deuxième ligne) est l'utilisation de la mémoireSwap 行(troisième ligne) est l'utilisation de l'espace d'échangetotalLes colonnes indiquent la quantité totale de mémoire physique disponible et d'espace d'échange dans le systèmeusedLes colonnes indiquent la mémoire physique et l'espace d'échange qui ont été utilisésfreeLes colonnes indiquent la quantité de mémoire physique et d'espace d'échange disponiblesharedLa colonne indique la quantité de mémoire physique utilisée par le partagebuff/cacheLes colonnes indiquent la quantité de mémoire physique utilisée par les tampons et les cachesavailableLa colonne indique la quantité de mémoire physique qui peut encore être utilisée par l'application
Parmi eux, nous devons nous concentrer sur free et available deux colonnes. free est la quantité de mémoire physique qui n'a pas été utilisée, et available est la mémoire disponible du point de vue de l'application. Afin d'améliorer les performances des opérations sur le disque, le noyau Linux consommera une partie de la mémoire pour mettre en cache les données du disque , c'est-à-dire le tampon et le cache, donc pour le noyau, le tampon et le cache appartiennent à la mémoire qui a été utilisée, mais lorsque l'application a besoin de mémoire, s'il n'y a pas assez de mémoire libre disponible, le noyau récupérera de la mémoire à partir du tampon et cache pour répondre à la demande de l'application. Donc, du point de vue de l'application available = free + buffer + cache, il convient de noter qu'il ne s'agit que d'une méthode de calcul idéale et que les données réelles comportent une erreur importante.
Si vous souhaitez interroger l'utilisation de la mémoire dans Prometheus, vous pouvez utiliser node_memory_* des indicateurs associés. De même, pour calculer l'utilisation, nous pouvons calculer la mémoire disponible et utiliser l'instruction de requête promql node_memory_Buffers_bytes + node_memory_Cached_bytes + node_memory_MemFree_bytes.
Calculez ensuite l'utilisation de la mémoire disponible, divisez-la par la mémoire totale, puis soustrayez-la de 1. L'instruction est (1- (node_memory_Buffers_bytes + node_memory_Cached_bytes + node_memory_MemFree_bytes) / node_memory_MemTotal_bytes) * 100, donc l'utilisation de la mémoire calculée du nœud.
Bien entendu, si vous souhaitez visualiser l'utilisation mémoire de chaque élément, vous pouvez directement utiliser les indicateurs de suivi correspondants. Par exemple, pour visualiser la mémoire totale du nœud, vous pouvez directement utiliser les node_memory_MemTotal_bytes indicateurs pour l'obtenir.
Surveillance de disque
Vient ensuite la surveillance du disque dans la comparaison.Pour la surveillance du disque, nous ne nous intéressons pas seulement à l'utilisation du disque, mais d'une manière générale, la surveillance des E/S du disque est également très nécessaire.
Surveillance de la capacité du disque
Pour surveiller la capacité du disque, vous devez utiliser node_filesystem_* des indicateurs associés. Par exemple, pour interroger l'utilisation de l'espace disque d'un nœud, vous pouvez également utiliser le total moins l'espace disponible pour le calcul. L' node_filesystem_avail_bytes indicateur d'utilisation de l'espace disque libre, mais parce qu'il y aura être certains que nous ne nous soucions pas des informations sur le disque, nous pouvons donc utiliser des fstype balises pour filtrer les informations sur le disque qui nous intéressent, telles que les ext4 disques xfs formatés (filtrez-les pour obtenir le système de fichiers que vous souhaitez):
Pour interroger l'utilisation de l'espace disque, utilisez l'instruction query (1 - node_filesystem_avail_bytes{fstype=~"ext4|xfs"} / node_filesystem_size_bytes{fstype=~"ext4|xfs"}) * 100 :
De cette façon, nous pouvons obtenir l'utilisation de l'espace disque qui nous intéresse.
Surveillance des E/S de disque
Pour surveiller les E/S de disque, il est nécessaire de distinguer s'il s'agit d'E/S de lecture ou d'E/S d'écriture, de lecture des node_disk_reads_completed indicateurs d'utilisation d'E/S et d'écriture d' node_disk_writes_completed_total indicateurs d'utilisation d'E/S.
Les E/S de lecture de disque sum by (instance) (rate(node_disk_reads_completed_total[5m])) peuvent utiliser l'instruction de requête :
Bien sûr, si vous souhaitez device agréger en fonction de cela, c'est également possible, nous sommes tous agrégés ici.
Les E/S d' écriture sur disque sum by (instance) (rate(node_disk_writes_completed_total[5m])) peuvent utiliser l'instruction de requête :
Si vous souhaitez calculer le total des E/S de lecture et d'écriture, vous pouvez additionner `rate(node_disk_reads_completed_total[5m]) + rate(node_disk_writes_completed_total[5m])
Surveillance des E/S réseau
L'indicateur que la bande passante de liaison montante doit être utilisée est que puisque nous sommes plus préoccupés par le changement instantanénode_network_receive_bytes de la bande passante du réseau, nous utilisons généralement des fonctions pour calculer le réseau IO. Par exemple, l'instruction de requête peut être utilisée pour calculer la bande passante de liaison montante : (Cela peut refléter le pic de changement du réseau. )iratesum by(instance) (irate(node_network_receive_bytes_total{device!~"bond.*?|lo"}[5m]))
L'indicateur utilisé pour la bande passante descendante est node_network_transmit_bytes, et l'instruction de requête de la même manière est sum by(instance) (irate(node_network_transmit_bytes{device!~"bond.*?|lo"}[5m])) :
Bien sûr, nous pouvons également agréger et calculer séparément en fonction du périphérique de la carte réseau, et enfin nous pouvons convertir les résultats en unités en fonction de nos propres besoins.