La surveillance des I/O de disque sur un système Linux est cruciale pour chaque administrateur système.  Lorsque vous effectuez un dépannage système de base, vous souhaitez avoir une vue d'ensemble complète de chaque métrique de votre système: processeur, mémoire, mais surtout, une vue imprenable sur l'utilisation des I/O du disque.  

Dans notre précédent tutoriel, nous avions construit un tableau de bord complet Grafana afin de surveiller les utilisations du processeur et de la mémoire.  Dans ce tutoriel, nous allons créer un autre tableau de bord qui surveille l'utilisation des I/O du disque sur notre système Linux, ainsi que l'utilisation des systèmes de fichiers et même des inodes.  Nous allons utiliser Prometheus pour suivre ces métriques, mais nous verrons que ce n’est pas le seul moyen de le faire sur un système Linux.  Ce tutoriel est divisé en trois parties, chacune fournissant une étape vers une compréhension complète de notre sujet.  

Tout d'abord, nous verrons comment la surveillance des entrées/sorties sur disque peut être effectuée sur un système Linux, à partir du système de fichiers lui-même (oui, les métriques sont en mode natif sur votre machine!) Ou à partir d'outils externes tels que iotop ou iostat;

Ensuite, nous verrons comment Prometheus peut nous aider à surveiller notre utilisation du disque avec l’exportateur Node. Nous allons configurer les outils, les définir en tant que services et les exécuter;

Enfin, nous allons configurer un rapide dashboard Grafana afin de surveiller les métriques que nous avons rassemblées précédemment.

Leçon 1 - Notions de base sur les I/O de disque  

Sur les systèmes Linux, les métriques d'E / S de disque peuvent être contrôlées à partir de la lecture de quelques fichiers sur votre système de fichiers.  Rappelez-vous le vieil adage: “Sous Linux, tout est fichier“  Eh bien, cela ne pourrait être plus vrai!  Si vos disques ou processus sont des fichiers, certains fichiers stockent les métriques associées à un moment donné.  

Un tour complet de procfs  

Comme vous le savez déjà, les systèmes de fichiers Linux sont organisés à partir d'un point racine (également appelé «racine»), chacun générant plusieurs répertoires, servant un objectif très différent pour un système.  L'un d'eux est /proc, également appelé procfs. C'est un système de fichiers virtuel, créé à la volée par votre système, qui stocke les fichiers liés à tous les processus en cours d'exécution sur votre instance.

Le procfs peut fournir des informations globales sur le processeur, la mémoire et le disque via divers fichiers situés directement sur /proc:  

  • cpuinfo: fournit des informations générales sur le processeur, telles que les caractéristiques techniques de votre matériel de processeur actuel;
  • meminfo: fournit des informations en temps réel sur l'utilisation actuelle de la mémoire sur votre système;
  • stat: rassemble des mesures en temps réel sur l'utilisation du processeur, ce qui est une extension de ce que cpuinfo peut déjà fournir.
  • / {pid} /io: agrège l'utilisation d'E/S en temps réel pour un processus donné sur votre système. C’est très puissant lorsque vous souhaitez surveiller certains processus de votre système et leur comportement dans le temps.
> > sudo cat /proc/cpuinfo
root@vps679545:~# sudo cat /proc/cpuinfo
processor	: 0
vendor_id	: GenuineIntel
cpu family	: 6
model		: 60
model name	: Intel Core Processor (Haswell, no TSX)

Comme vous l'avez deviné, Linux expose déjà un ensemble de métriques intégrées pour que vous ayez une idée de ce qui se passe sur votre système.  Mais inspecter directement les fichiers n’est pas très pratique. C’est pourquoi nous allons faire un tour des différents outils interactifs que chaque administrateur système peut utiliser pour contrôler rapidement les performances.

5 utilitaires de shell interactifs pour les E / S de disque  

Dans la pratique, un administrateur système inspecte rarement les fichiers sur le système de fichiers proc, il utilise un ensemble d'utilitaires shell conçus à cet effet.

Voici une liste des outils les plus populaires utilisés à ce jour:  

iotop  

iotop est un utilitaire de ligne de commande interactif qui fournit des informations en temps réel sur l'utilisation globale du disque par votre système. Il n'est pas inclus par défaut sur les systèmes Linux, mais il existe des ressources faciles à suivre pour le récupérer sur votre système d'exploitation: https://lintut.com/install-iotop-on-linux/  

Pour le tester et le voir en direct, vous pouvez exécuter la commande suivante:

# > sudo iotop -Po

# > sudo iotop -Po --iter 4 >> /var/log/iotop 

Vous devriez maintenant voir une vue interactive de tous les processus (-P) qui consomment des ressources d'E / S sur votre système (-o).

Les résultats sont assez explicites: ils fournissent l'utilisation de la lecture du disque, l'utilisation de l'écriture du disque, la mémoire d'échange utilisée ainsi que les E / S actuelles utilisées.

Les autres concurrents: iostat, glances, netdata, pt-diskstats

iotop n'est pas le seul outil à fournir des mesures en temps réel pour votre système. De plus, iotop nécessite des droits sudo pour pouvoir être exécuté.  Cette liste mériterait probablement un article entier (Glances a déjà été évoqué sur ce blog par le passé), mais voici quelques alternatives que vous pouvez utiliser pour surveiller l'utilisation de votre disque:  

  • iostat: indique l'utilisation du disque pour vos périphériques, en particulier vos périphériques en mode bloc;
  • glances: il s'agit d'une surveillance de système multiplateforme qui présente des métriques en temps réel pour l'ensemble de votre système via une interface utilisateur Web accessible;
  • netdata: cela avait déjà été introduit dans nos meilleures solutions de surveillance de tableaux de bord et fournissait un plugin pour accéder à l'utilisation du disque;
  • pt-diskstats: construit par Percona, pt-diskstats est un utilitaire qui récupère l'utilisation du disque et le formate de manière à pouvoir être facilement exporté et utilisé par d'autres outils externes à des fins d'analyse.

Maintenant que vous en savez un peu plus sur la manière dont vous pouvez surveiller vos disques en mode natif sur des systèmes Linux, construisons un pipeline de contrôle complet avec Prometheus et Node Exporter.

Leçon 2 - Maîtrise de Node Exporter

Outre les outils présentés ci-dessus, Prometheus peut être l’un des moyens de surveiller activement vos disques sur un système Linux. Pour rappel, Prometheus propose un ensemble d’exportateurs faciles à configurer pour surveiller une grande variété d’outils: outils internes (disques, processus), bases de données (MongoDB, MySQL) ou outils tels que Kafka ou ElasticSearch.  Dans ce cas, nous allons utiliser Node Exporter (la documentation de github est disponible ici).  Node Exporter est un exportateur conçu pour surveiller chaque métrique que vous pouvez imaginer sur un système Linux: processeur, mémoire, disques, systèmes de fichiers et même suivi du réseau, ce qui est très similaire à netstat.  

Dans notre cas, nous allons nous concentrer sur tout ce qui est lié aux disques: la surveillance du système de fichiers et du disque global, représentée par les collecteurs du système de fichiers et de diskstats.

a - Installation de Node Exporter

L’installation de Prometheus a déjà été expliquée dans notre précédent guide, allez sur ce lien pour voir comment cela se fait.  Une fois que Prometheus est complètement configuré et configuré, nous allons installer Node Exporter en tant que service sur notre instance.  Pour cette installation, j'utilise une instance Ubuntu 18.04 avec systemd.  À partir de la racine, accédez au dossier /etc/systemd/system et créez un nouveau service de Node Exporter.

Accédez à la page officielle des téléchargements Prometheus et obtenez le lien de téléchargement du binaire Linux.

Créez un utilisateur Prometheus, les répertoires requis et définissez Prometheus en tant que propriétaire de ces répertoires.

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Téléchargez la source en utilisant curl, décompressez-le et renommez le dossier extrait en fichiers prometheus.

curl -LO https://github.com/prometheus/prometheus/releases/download/v2.10.0/prometheus-2.10.0.linux-amd64.tar.gz
tar -xvf prometheus-2.10.0.linux-amd64.tar.gz
mv prometheus-2.10.0.linux-amd64 prometheus-files

Copiez le binaire prometheus et promtool du dossier de fichiers prometheus vers / usr/local/bin et changez le propriétaire en utilisateur prometheus.

sudo cp prometheus-files/prometheus /usr/local/bin/
sudo cp prometheus-files/promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

Déplacez les répertoires consoles et console_libraries des fichiers prometheus vers le dossier /etc/prometheus et changez le propriétaire en utilisateur prometheus.

sudo cp -r prometheus-files/consoles /etc/prometheus
sudo cp -r prometheus-files/console_libraries /etc/prometheus
sudo chown -R prometheus:prometheus /etc/prometheus/consoles
sudo chown -R prometheus:prometheus /etc/prometheus/console_libraries

Configuration de Prometheus  

Toutes les configurations prometheus doivent être présentes dans le fichier /etc/prometheus/prometheus.yml.  

Étape 1: Créez le fichier prometheus.yml.

sudo vi /etc/prometheus/prometheus.yml

Copiez le contenu suivant dans le fichier prometheus.yml.

global:
  scrape_interval: 10s

scrape_configs:
  - job_name: 'prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['localhost:9090']

Changez la propriété du fichier en utilisateur prometheus.

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml

Configuration du fichier de service Prometheus  

Étape 1: Créez un fichier de service Prometheus.

sudo vi /etc/systemd/system/prometheus.service

Copiez le contenu suivant dans le fichier.

[Unit]
    Description=Prometheus
    Wants=network-online.target
    After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
    --config.file /etc/prometheus/prometheus.yml \
    --storage.tsdb.path /var/lib/prometheus/ \
    --web.console.templates=/etc/prometheus/consoles \
    --web.console.libraries=/etc/prometheus/console_libraries

[Install]
WantedBy=multi-user.target

Rechargez le service systemd pour enregistrer le service prometheus et démarrez le service prometheus.

sudo systemctl daemon-reload
sudo systemctl start prometheus

Vérifiez l'état du service Prometheus à l'aide de la commande suivante.

sudo systemctl status prometheus

L'état devrait afficher l'état actif comme indiqué ci-dessous.

Accéder à l'interface utilisateur Web Prometheus  

Vous pourrez maintenant accéder à l'interface utilisateur Prometheus sur le port 9090 du serveur Prometheus.

http://<prometheus-ip>:9090/graph

Vous devriez pouvoir voir l'interface utilisateur suivante, comme indiqué ci-dessous.

Nous venons de configurer Prometheus. Vous devez enregistrer la cible dans le fichier prometheus.yml pour obtenir les métriques des systèmes sources.

b - Installation de Pushgateway

Pour installer Pushgateway, exécutez une simple commande wget pour obtenir les derniers fichiers binaires disponibles.

wget https://github.com/prometheus/pushgateway/releases/download/v0.8.0/pushgateway-0.8.0.linux-amd64.tar.gz

Maintenant que vous avez l'archive, extrayez-la et exécutez le fichier exécutable disponible dans le dossier pushgateway.

> tar xvzf pushgateway-0.8.0.linux-amd64.tar.gz
> cd pushgateway-0.8.0.linux-amd64/   
> ./pushgateway & 

En conséquence, votre Pushgateway devrait commencer en tant que processus d'arrière-plan.

root@vps679545:~/pushgateway-0.8.0.linux-amd64# INFO[0000] Starting pushgateway (version=0.8.0, branch=HEAD, revision=d90bf3239c5ca08d72ccc9e2e2ff3a62b99a122e)  source="main.go:65"
INFO[0000] Build context (go=go1.11.8, user=root@00855c3ed64f, date=20190413-11:29:19)  source="main.go:66"
INFO[0000] Listening on :9091.                           source="main.go:108"

À partir de là, Pushgateway écoute les métriques entrantes sur le port 9091.

c- Node exporter Installation

Téléchargez le dernier package Node Exporter. Vous devriez consulter la section Téléchargements de Prometheus pour obtenir la dernière version et mettre à jour cette commande pour obtenir ce paquet.

cd /tmp
curl -LO https://github.com/prometheus/node_exporter/releases/download/v0.18.1/node_exporter-0.18.1.linux-amd64.tar.gz

Unpack :

tar -xvf node_exporter-0.18.1.linux-amd64.tar.gz

Déplacez le binaire de Node Exporter vers /usr/ local/bin

sudo mv node_exporter-0.16.0.linux-amd64/node_exporter /usr/local/bin/

Créer un service de Node Exporter personnalisé  

Étape 1: Créez un utilisateur node_exporter pour exécuter le service Node Exporter

sudo useradd -rs /bin/false node_exporter

Étape 2: Créez un fichier de service node_exporter sous systemd.

sudo vi /etc/systemd/system/node_exporter.service

Étape 3: Ajoutez le contenu du fichier de service suivant au fichier de service et enregistrez-le.

[Unit]
Description=Node Exporter
After=network.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

Étape 4: Rechargez le démon système et démarrez le service Node Exporter.

sudo systemctl daemon-reload
sudo systemctl start node_exporter

Étape 5: vérifiez le statut de Node Exporter pour vous assurer qu'il est en cours d'exécution à l'état actif.

sudo systemctl status node_exporter
● prometheus.service - Prometheus
   Loaded: loaded (/etc/systemd/system/prometheus.service; disabled; vendor preset: enabled)
   Active: active (running) since jeu. 2019-06-27 16:00:57 CEST; 1 weeks 6 days ago
 Main PID: 4221 (prometheus)
    Tasks: 9
   Memory: 467.7M
      CPU: 1h 1min 13.490s
   CGroup: /system.slice/prometheus.service
           └─4221 /usr/local/bin/prometheus --config.file /etc/prometheus/prometheus.yml --storage.tsdb.path /var/lib/prometheus/ --web.console.templates=/etc/prometheus/console

juil. 10 09:00:01 vps679545 prometheus[4221]: level=info ts=2019-07-10T07:00:01.384Z caller=compact.go:499 component=tsdb msg="write block" mint=1562731200000 maxt=1562738400000
juil. 10 09:00:01 vps679545 prometheus[4221]: level=info ts=2019-07-10T07:00:01.439Z caller=head.go:544 component=tsdb msg="head GC completed" duration=10.537319ms
juil. 10 11:00:01 vps679545 prometheus[4221]: level=info ts=2019-07-10T09:00:01.299Z caller=compact.go:499 component=tsdb msg="write block" mint=1562738400000 maxt=1562745600000
juil. 10 11:00:01 vps679545 prometheus[4221]: level=info ts=2019-07-10T09:00:01.339Z caller=head.go:544 component=tsdb msg="head GC completed" duration=3.381498ms
juil. 10 11:00:01 vps679545 prometheus[4221]: level=info ts=2019-07-10T09:00:01.566Z caller=compact.go:444 component=tsdb msg="compact blocks" count=3 mint=1562716800000 maxt=15
juil. 10 13:00:01 vps679545 prometheus[4221]: level=info ts=2019-07-10T11:00:01.342Z caller=compact.go:499 component=tsdb msg="write block" mint=1562745600000 maxt=1562752800000
juil. 10 13:00:01 vps679545 prometheus[4221]: level=info ts=2019-07-10T11:00:01.382Z caller=head.go:544 component=tsdb msg="head GC completed" duration=3.673772ms
juil. 10 15:00:01 vps679545 prometheus[4221]: level=info ts=2019-07-10T13:00:01.421Z caller=compact.go:499 component=tsdb msg="write block" mint=1562752800000 maxt=1562760000000
juil. 10 15:00:01 vps679545 prometheus[4221]: level=info ts=2019-07-10T13:00:01.471Z caller=head.go:544 component=tsdb msg="head GC completed" duration=5.300895ms
juil. 10 15:01:05 vps679545 prometheus[4221]: level=info ts=2019-07-10T13:01:05.355Z caller=head.go:608 component=tsdb msg="WAL checkpoint complete" first=20 last=21 duration=1m

Étape 6: Activez le service Node exporter au démarrage du système.

sudo systemctl enable node_exporter

À présent, Node Exporter envoi des métriques sur le port 9100.  Vous pouvez voir toutes les métriques du serveur en visitant l'URL de votre serveur sur /metrics comme indiqué ci-dessous.

URL : http://<server-IP>:9100/metrics

Configurer le serveur en tant que cible sur le serveur Prometheus  

Maintenant que l'exportateur de noeud est opérationnel sur le serveur, nous devons ajouter à ce serveur une cible sur la configuration du serveur Prometheus.

Remarque: cette configuration doit être effectuée sur le serveur Prometheus.

Étape 1: connectez-vous au serveur Prometheus et ouvrez le fichier prometheus.yml.

sudo vi /etc/prometheus/prometheus.yml

Étape 2: Dans la section scrape config, ajoutez la cible de l'exportateur de noeud, comme indiqué ci-dessous. Changez 10.142.0.3 avec votre IP de serveur sur lequel vous avez l'exportateur de nœud de configuration. Le nom du travail peut être le nom d’hôte ou l’IP de votre serveur à des fins d’identification.

- job_name: 'node_exporter_metrics'
    scrape_interval: 5s
    static_configs:
      - targets: ['10.142.0.3:9100']

Étape 3: redémarrez le service prometheus pour que les modifications de configuration aient lieu.

sudo systemctl restart prometheus

Maintenant, si vous vérifiez la cible dans l'interface utilisateur Web de Prometheus (http://<prometheus-IP>: 9090/target), vous pourrez voir l'état comme indiqué ci-dessous.

En outre, vous pouvez utiliser le navigateur d’expression Prometheus pour rechercher des métriques relatives aux nœuds. Vous trouverez ci-dessous les quelques mesures de nœud clés que vous pouvez utiliser pour trouver ses statistiques.

node_memory_MemFree_bytes
node_cpu_seconds_total
node_filesystem_avail_bytes
rate(node_cpu_seconds_total{mode="system"}[1m]) 
rate(node_network_receive_bytes_total[1m])

Commencez à explorer vos données  

Maintenant que votre serveur Prometheus est connecté à Node Exporter, vous pourrez explorer les données directement à partir de l’interface utilisateur Web de Prometheus.  Nous allons nous concentrer ici sur les mesures liées à l'utilisation du disque, juste pour nous assurer que tout est configuré correctement.  Dans le champ d'expression, tapez la requête PromQL suivante:  

> irate (node_disk_read_bytes_total {device = "vda"} [5s]) / 1024/1024 

Explication rapide ; cette requête fournit un taux d'opérations de lecture de disque sur une période de 5 secondes pour mon disque vda en mégaoctets par seconde.

Si vous pouvez voir les données dans le graphique, cela signifie que tout est correctement configuré.

Construction d'un dashboard complet d'I/O de disque  

Maintenant que notre Prometheus stocke des données relatives à notre système, il est temps de créer un tableau de bord complet pour la surveillance de l'utilisation du disque.  

Notre tableau de bord final est composé de quatre composants différents:  

  • Suivi global des systèmes de fichiers: étant donné tous les systèmes de fichiers montés sur une partition donnée, nous disposerons d’un suivi complet de tout l’espace disponible sur nos systèmes de fichiers;
  • Latence d'écriture et de lecture de nos disques: étant donné que nous avons accès aux heures de lecture et d'écriture et au nombre total d'opérations de lecture et d'écriture réellement effectuées, nous pouvons calculer des latences pour les deux métriques;
  • Vérification du nombre d'inodes disponibles sur notre système;
  • Le taux de charge global des E / S en temps réel

a - Suivi du système de fichiers  

Notre premier panel sera chargé de surveiller les systèmes de fichiers et plus précisément l'espace total restant sur différents systèmes de fichiers.  L'exportateur de noeud exporte deux métriques pour que nous puissions récupérer ces statistiques:

node_filesystem_avail_bytes et node_filesystem_size_bytes.  

L’un divisé par l’autre nous indiquera l’utilisation globale du système de fichiers par périphérique ou par point de montage, selon vos préférences.  Comme toujours, voici le déroulé :

La formule :

(1 - node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100

b - Latences en lecture et en écriture  

Une autre métrique intéressante à surveiller est la latence de lecture et d’écriture sur nos disques.  L'exportateur de nœud exporte plusieurs métriques pour que nous puissions le calculer.  Du côté de la lecture, nous avons:

node_disk_read_time_seconds_total node_disk_reads_completed_total

En écriture, nous avons:  node_disk_write_time_seconds_total / node_disk_writes_completed_total

Si nous calculons des taux pour les deux métriques et les divisons l'un par l'autre, nous pouvons calculer le temps de latence ou le temps nécessaire à votre disque pour effectuer de telles opérations.  Voyons voir :

c - Nombre d'inodes sur notre système  

Maintenant que nous connaissons les latences de lecture et d'écriture sur le système, vous voudrez peut-être connaître le nombre d'inodes encore disponibles sur votre système.  Heureusement, ceci est aussi quelque chose exposé par l'exportateur de nœud:  node_filesystem_files_free node_filesystem_files

En suivant la même logique, l’un divisé par l’autre nous donne le nombre d’inodes disponibles sur notre instance.

d - Charge globale d'I/O sur votre instance  

Nous souhaitons être en mesure de connaître la charge d’entrée/sortie globale de votre système. Node Exporter expose la métrique suivante:  node_disk_io_now

Le calcul du taux pour cette métrique donnera la charge globale d'E/S.  Le dernier aide-mémoire est le suivant:

Ce qui donne un dashboard final :

Conclusion

Dans ce didacticiel, vous avez appris que vous pouvez facilement surveiller les E/S de disque sur vos instances avec Prometheus et Grafana.  La surveillance de telles métriques est essentielle pour chaque administrateur système qui souhaite obtenir des indices concrets sur les goulets d'étranglement des serveurs.  

Vous pouvez maintenant savoir s'ils proviennent de latences de lecture, d'écriture ou d'un système de fichiers qui manque d'espace.  Avec Disk I/O, nous venons de donner une idée de ce que Node Exporter peut faire. Il existe en réalité beaucoup plus d’options et vous devriez les explorer.  Si vous avez créé un tableau de bord très cool avec les outils présentés ci-dessus, assurez-vous de nous le montrer, il est toujours apprécié de voir à quel point vous pouvez être créatif!  J'espère que vous avez appris quelque chose de nouveau aujourd'hui.  Jusque-là, amusez-vous, comme toujours.