COMMENT CONFIGURER ET DEPLOYER UNE SOLUTION COMPLETE DE MONITORING AVEC PROMETHEUS, GRAFANA ET ALERTMANAGER

Bonjour,
Heureux de vous revoir à nouveau,

Aujourd’hui, je vais vous montrer comment mettre en place une solution de monitoring à l’aide de Prometheus, Grafana et Alertmanager. Mais tout d’abord, 

Qu’est-ce que c’est que Prometheus ? 

Prometheus, est un logiciel libre qui permet de collecter des métriques dans les infrastructures informatiques afin d’effectuer de la supervision, mais également de la gestion d’alerte sur seuil. Prometheus permet entre autres, la surveillance des réseaux, des microservices et des bases de données. À Prometheus, on peut coupler certains modules complémentaires comme : *Grafana, qui est un outil open-source permettant d’afficher les métriques collectées par Prometheus sous forme de graphes et **Alertmanager, qui quant à lui est un composant qui sert à envoyer des alertes en se basant sur des conditions prédéfinies au sein de Prometheus.

C’est très important d’effectuer un monitoring de son système informatique 👮. En effet, le monitoring a pour objectif principal d’aider les administrateurs réseaux pour la gestion quotidienne de leurs infrastructures, notamment par : une anticipation des pannes, une information précise sur l’état du réseau et des services (applications, microservices, …), préservation et augmentation du niveau de sécurité, ainsi qu’une assurance de la continuité de service.

Maintenant que vous en savez un peu plus sur Prometheus, nous allons nous intéresser au scénario suivant ; nous souhaitons monitorer au sein de notre infrastructure réseau trois types de serveur principaux : un serveur de base de données, un serveur sous système d’exploitation Windows et un serveur hébergeant plusieurs services sur système GNU/Linux. La solution à mettre en place doit être capable de remonter les informations qui nous intéressent telles que l’état du système (espace disque utilisé, quantité de RAM disponible,…), l’état des services (applications, services, microservices,…), et autres éléments essentiels, concernant les serveurs à surveiller. De plus, la solution doit être capable d’afficher sous forme de graphes les différents résultats et enfin, des notifications doivent être générées et transférées dans le but d’alerter ou avertir l’administrateur d’un évènement en particulier ou d’un ensemble d’évènements donnés.

Pour mener à bien notre mission 😎, nous allons avoir recours à trois éléments principaux : Prometheus, Grafana et AlertManager que nous devons installer selon un ordre bien déterminé.

L’installation peut se faire en environnement classique (entendez par là sous forme de services) ou alors sous forme de conteneurs via la technologie Docker. Nous allons procéder suivant les deux méthodologies : services ou conteneurs, et nous allons débuter avec cette dernière.

(Ps: Toutes les commandes que nous allons utiliser relatives aux deux méthodes sont présentes dans ce fichier.)

Nous allons commencer par mettre en place et configurer Prometheus sur un autre serveur (différent des trois serveurs que nous souhaitons examiner). Pour ce faire, nous nous rendons sur le serveur en question,

(Ps: Rien ne nous oblige à ne pas configurer Prometheus sur l’un des trois serveurs à monitorer, c’est juste par souci de séparation « de rôles à jouer ou fourniture de services », que nous avons procédé de cette manière.)

Comme nous souhaitons déployer notre solution de monitoring via la technologie Docker, nous devons premièrement installer Docker sur chacun des serveurs sur lesquels on aura besoin de récupérer des métriques ou informations nécessaires pour mener à bien notre surveillance réseau. Ainsi, nous allons procéder de cette manière pour installer Docker :

Nous commençons par une mise à jour des paquets du système,

Ensuite, nous entrons tour-à-tour les commandes « sudo apt-get install ca-certificates curl gnupg lsb-release » pour installer les prérequis nécessaires qui vont nous permettre par la suite la mise en place des paquets sécurisés via « apt » ;

Suivi de la commande « curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg » qui permet d’ajouter la clé GPG du dépôt officiel de Docker à notre système. Nous poursuivons avec la commande  « echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null » pour insérer le référentiel Docker aux sources APT.  

Enfin, nous mettons à jour la base de données des paquets de notre système en y insérant les paquets Docker récemment ajoutés, puis nous installons Docker en entrant la commande « sudo apt-get update && sudo apt-get install docker-ce docker-ce-cli containerd.io »

Nous vérifions que Docker est bel et bien installé à travers la commande « docker --version » et actuellement, il n’y a aucun conteneur de démarré évidemment 👌.

À présent, nous pouvons passer à l’installation de Prometheus ; pour ce faire, nous éditons le fichier {prometheus.yml} qui est le fichier de configuration de Prometheus,  

En y insérant les lignes suivantes :

global:
   scrape_interval: 5s
   external_labels:
      monitor: 'node'
scrape_configs:
   - job_name: 'prometheus'
     static_configs:
        - targets: ['@IP_Serveur:9090'] ## Prometheus

(Ps : ce fichier sera modifié au fur et à mesure que des collecteurs de métriques devront être ajoutés au sein de notre système d’information.)

Ensuite, nous créons également le fichier {alerts.yml} (qui nous sera utile pour la suite) avant de lancer la commande « docker run -d --name prometheus -p 9090:9090 -v $PWD/prometheus.yml:/etc/prometheus/prometheus.yml -v $PWD/alerts.yml:/etc/prometheus/rules/alerts.yml -v prometheus_data:/prometheus prom/prometheus » pour télécharger et lancer une instance ou conteneur basé sur l’image de Prometheus qui va fonctionner sur le port 9090 et disposer de trois volumes : dont un dédié au stockage et les deux autres volumes attachés (ou reliés) respectivement aux fichiers {prometheus.yml} et {alerts.yml}.

Nous pouvons obtenir des informations (état, adresse IP, activité, …) sur notre conteneur nouvellement créé à partir des commandes « docker ps » et « docker logs prometheus » ou encore « docker inspect prometheus » :

 

Une fois Prometheus installé, nous pouvons nous rendre sur son interface web depuis un navigateur internet, en renseignant l’adresse IP de notre serveur suivi du numéro de port sur lequel tourne le service Prometheus.

Maintenant, nous pouvons passer à l’installation du second élément primordial à la mise sur pied de notre solution de monitoring : Grafana.

Pour ce faire, comme nous souhaitons l’installer via la technologie docker, il nous suffit d’entrer la commande : « docker run -d --name=grafana -p 3000:3000 grafana/grafana » et c’est tout ! 😱

Puis, nous nous rendons comme nous l’avons fait précédemment avec Prometheus, sur l’interface web de Grafana, en précisant cette fois-ci comme numéro de port 3000 :

Ensuite, il nous faut renseigner les identifiants (login et password) de connexion pour accéder à Grafana.

(Ps: par défaut les identifiants de Grafana sont : admin pour le nom d’utilisateur et admin également comme mot de passe.)

Une fois, dans l’interface de configuration de Grafana, nous pouvons pour des soucis de sécurité configurer trois types de comptes différents et ne disposant pas des mêmes droits d’accès (c’est le but évidemment 😅) : le compte administrateur qui a une visibilité totale et peut effectuer toutes les opérations possibles (ou disponibles) sur Grafana, le compte éditeur qui est limité dans le sens où il ne dispose pas des autorisations nécessaires pour créer des nouveaux comptes utilisateurs et le compte observateur qui est totalement restreint et ne peut comme son nom l’indique que se contenter d’observer les dashboards😜. Donc pour configurer nos différents comptes utilisateurs, nous nous rendons au niveau de l’onglet |Server Admin| et nous sélectionnons l’option |Users|

Puis, cliquez sur le bouton |New user| et après avoir renseigné les informations nécessaires concernant le compte valider sa création en cliquant sur le bouton |Create user|

Une fois le compte créé, dans le but de restreindre ses autorisations ou non, il faut le sélectionner pour modifier son type.

Et valider toutes les modifications apportées en cliquant sur |Save|.

Maintenant, nous allons installer nos premiers collecteurs de métriques : Node Exporter et Docker Exporter, qui ont pour but respectivement de renvoyer toutes les métriques internes à savoir le CPU, la quantité de RAM utilisée, l’espace disque disponible,… Ainsi que les informations relatives aux microservices ou conteneurs (état d’activité, capacité d’occupation en terme de mémoire RAM ou disque, …) des serveurs sur lesquels ils sont installés.

Pour ce faire, nous nous rendons sur le serveur prévu à cet effet,

Et nous entrons la commande « docker run -d --name="node_exporter" -p 9100:9100 -v "/:/host:ro,rslave" quay.io/prometheus/node-exporter:latest –path.rootfs=/host » pour ce qui concerne Node Exporter,

Une fois Node Exporter installé sur notre serveur à monitorer, nous allons modifier le fichier de configuration de Prometheus dans le but de lui indiquer la présence du collecteur de métrique Node Exporter sur l’un des nœuds de notre infrastructure possédant l’adresse réseau 192.168.100.144 suivi du numéro de port sur lequel le collecteur tourne :

- job_name: 'node-exporter'
  static_configs:
    - targets: ['@IP_Serveur:9100'] ## Node_Exporter
[client]
user=utilisateur
password=password

Puis, nous allons pour Docker Exporter exécuter la commande « docker run --name docker_exporter --detach --restart always --volume "/var/run/docker.sock":"/var/run/docker.sock" --publish 9417:9417 prometheusnet/docker_exporter » ;

De même, pour signaler la présence du collecteur Docker Exporter sur l’un de nos serveurs à surveiller, nous allons apporter de nouvelles modifications au fichier {prometheus.yml}.

Et pour que toutes les modifications effectuées prennent effet, nous devons redémarrer le conteneur Prometheus grâce à la commande « docker restart prometheus » :

Si nous nous rendons à nouveau au niveau de l’interface web de Prometheus, dans l’onglet |Status| et nous sélectionnons l’option |Targets| ,

Nous nous apercevons que Prometheus nous fait état de trois « Endpoints » : Prometheus lui-même, Node Exporter et Docker Exporter. Les informations affichées sont : leur état UP ‘en fond vert’  (donc tout va bien 👍), l’adresse IP suivi du numéro de port de chacun, et la période depuis laquelle chaque collecteur de métriques est en fonctionnement.

Par la suite, pour qu’on obtienne sous forme de (jolis 😍) graphes les différentes métriques issues de Prometheus au niveau de Grafana, nous devons au préalable paramétrer une source de données ou Data Source au sein même de Grafana. Pour ce faire, nous nous rendons au niveau de l’onglet |Configuration| et nous sélectionnons l’option |Data sources|,

Nous cliquons sur le bouton |Add data source| .

Ensuite, nous choisissons le type de source de données que l’on souhaite ajouté, dans notre cas, il s’agit d’une source de données de type Prometheus ;

Puis nous renseignons les informations propres à la Data source qu’on veut créer :

Et enfin, après avoir cliqué sur le bouton |Save & test| si tout est parfaitement paramétré, nous devons avoir le message ‘‘Data source is working’’.

À présent, nous pouvons définir des tableaux de bord (Dashboards) qui sont en réalité des graphes qui résultent des métriques transférer par les collecteurs de métriques tels que Node Exporter ou docker Exporter vers Prometheus qui lui-même envoie une copie à Grafana qui interprète les résultats et génère à partir de la source de données (Prometheus configurer précédemment) des informations sous forme de graphes.

Au niveau du menu vertical, on clique sur l’onglet |+| et nous sélectionnons l’option |Import| ,

Il est très important de noter que les Dashboards que nous allons créer sont générés à partir d’un élément appelé Dashboard ID (identifiant du tableau de bord) qui est un élément unique propre à chaque modèle de Dashboard. Chaque identifiant est soigneusement répertorié sur le site web officiel de Grafana il suffit de faire une recherche dessus pour trouver le ou les Dashboards ID qui vont nous intéresser.

Une fois qu’on a repéré l’identifiant du Dashboard que l’on souhaite créer, nous le renseignons dans la zone prévue à cet effet et nous cliquons sur le bouton |Load| :

Ensuite, nous renseignons les informations relatives à notre futur Dashboard telles que son nom, son répertoire d’emplacement, son identifiant unique (au cas où l’on disposerait de plusieurs versions relatives au même modèle de Dashboard) et la source de données. Une fois toutes ces informations enregistrées, nous cliquons sur le bouton |Import| pour valider la création du Dashboard.

Après avoir valider la création du Dashboard, nous sommes immédiatement redirigés vers celui-ci et nous nous rendons compte que les différentes métriques internes (CPU, quantité de la RAM utilisée, espace du disque dur disponible, trafic du réseau entrant et sortant,...) sont affichées visuellement sous forme de graphe, normal, puisque c’est le collecteur de métrique Node Exporter qui en est la cause, l’identifiant renseigné est propre au collecteur de métrique de type Node Exporter. 

N’est-ce pas joli à regarder ? 😄

(Ps: au cas où il y aurait un pare-feu d’installer et que les métriques ne remontent pas au niveau des graphes, faudra penser à allouer le port défini pour l’exportateur de métrique via la commande « ufw allow 9100 ».)

Nous procédons de la même manière pour créer le Dashboard qui va renvoyer les données transférées depuis le collecteur de métrique concernant les différents microservices ou les applications conteneurisées installées au sein de nos postes à monitorer en renseignant cette fois-ci les informations propres à Docker Exporter.

Et comme précédemment avec Node Exporter, après avoir terminé, nous sommes directement redirigés vers le Dashboard relatif au collecteur de métriques de type Docker Exporter qui nous affiche les informations telles que l’état du conteneur : démarré (en couleur verte fréquemment) ou éteint (en rouge la plupart du temps), leur pourcentage de CPU utilisé, le trafic réseau entrant et sortant, leur quantité de RAM ou encore la capacité d’espace disque utilisée.

(Ps: ce Dashboard est également capable de remonter les informations des pods ou microservices déployés avec Kubernetes… en résumé, toutes les applications conteneurisées au sein du système d’information seront affichées dessus.)

Pour le moment, nous constatons uniquement la présence de deux services du nom de docker_exporter et node_exporter normal se sont les deux seuls de ce genre installés pour l’instant sur notre serveur prévu à cet effet. Mais si on ajoute quelques applications conteneurisées en plus comme : Python, MySQL, Nginx,

Et que nous nous rendons à nouveau sur notre Dashboard, nous remarquons cette fois-ci la présence des trois conteneurs nouvellement ajoutés.

(Ps: MySQL et Python ont été stoppés d’où leur couleur rouge.)

À présent, nous allons passer à l’installation de notre dernier collecteur de métriques (mais pas l’un des moindres 😉) : MySQL Exporter. Pour ce faire, nous allons procéder comme suit : nous nous rendons dans un premier temps sur le serveur de base de données dont on souhaite obtenir les informations ; 

Ensuite, nous allons créer un nouvel utilisateur avec pour nom : utilisateur (je sais, on ne fait pas plus difficile comme nom 😏) qui va nous être utile pour la suite de la procédure et on va lui attribuer tous les droits sur les bases de données de notre SGBD MySQL :

Puis, nous installons notre collecteur de métriques MySQL Exporter grâce à la commande « docker run -d --name mysql-exporter -p 9104:9104 -e DATA_SOURCE_NAME="utilisateur:password@(192.168.100.222:3306)/" prom/mysqld-exporter-linux-amd64:v0.13.0 » en lui précisant comme variables le nom d’utilisateur suivi de son mot de passe, ainsi que l’adresse IP et le numéro de port où est localisée la base de données.

Nous accédons à notre conteneur précédemment créé via la commande « docker exec -u root -it mysql-exporter /bin/sh » et nous continuons à l’intérieur même du conteneur MySQL Exporter avec la création du fichier ‘‘caché’’ {.my.cnf} qui va contenir les lignes suivantes :

Avant de redémarrer entièrement le conteneur grâce à la commande « sudo docker restart mysql-exporter » pour que toutes les modifications soient prises en compte.

Et enfin, comme nous l’avons déjà fait plus haut avec Node Exporter et Docker Exporter, nous ajoutons de nouvelles informations relatives au collecteur de métrique MySQL Exporter au fichier de configuration de Prometheus.

Si nous nous rendons à nouveau sur l’interface web de Prometheus, nous remarquons la présence d’un nouvel Endpoint du nom de mysql_exporter,

Passons à la création du Dashboard qui sera associé à notre tout nouveau collecteur de métriques de type MySQL Exporter ;

Une fois après avoir validé la création du Dashboard en cliquant sur le bouton |Import|, concernant le collecteur de métriques MySQL Exporter, il peut arriver qu’on soit redirigé vers un tableau de bord qui ne dispose d’aucune donnée (No Data),

Ceci peut être dû au fait qu’un pare-feu empêche le rapatriement des données depuis le port sollicité, ou alors que le service MySQL n’autorise pas la diffusion sur certains ports ou adresses IP spécifiques. Une solution consiste à modifier le fichier de configuration de MySQL pour autoriser la diffusion sur toutes les adresses en modifiant les variables bind-address et mysqlx-bind-address dans le fichier de configuration de MySQL. 

Puis redémarrer le service en question,

Et si l’on retourne sur le Dashboard de MySQL Exporter, nous nous rendons compte que les données s’affichent dorénavant sauf celle concernant [Buffer Pool Size of Total RAM], ça peut être due tout simplement au fait que notre base de données n’effectue pas ce genre d’opération en ce moment précis ou alors n’en est pas capable ;

Néanmoins Grafana nous donne la possibilité de pouvoir modifier des tableaux de bord à notre convenance. Donc si nous voulons omettre toutes ou certaines données non-affichables (celles marquées en No Data) ou même existantes, mais qui ne nous intéresses pas tellement, nous pouvons le faire facilement, ainsi, nous pouvons nous retrouver finalement avec ce visuel.

Jusqu’à présent les serveurs sur lesquels on a eu à effectuer des opérations tournent sous système d’exploitation GNU/Linux, supposons qu’au sein des serveurs que nous désirons surveiller se trouve un serveur avec un O.S Microsoft Windows, pas d’inquiétude il existe également un collecteur de métriques spécialement dédié pour ce genre de situation 😎.

Nous commençons par nous rendre sur le poste en question,

Puis, nous allons télécharger et installer le logiciel Windows Exporter depuis cette adresse.

Comme tout logiciel Windows la procédure d’installation est pratiquement la même (suivant > suivant … > terminé 😅) plus sérieusement, nous allons d’abord cliquer sur le bouton  |Enregistrer le fichier| ,

Une fois le téléchargement terminé, nous effectuons un clic droit sur l’élément (le logiciel) en question et on sélectionne |Installer| parmi les options proposées :

Ensuite, tour à tour, nous cliquons sur |Exécuter| suivi de |Oui| pour autoriser l’installation du logiciel sur notre système.

Pour vérifier que le logiciel est bel et bien installé, nous nous rendons au niveau des Services (bouton Windows + R + Services) et nous devons apercevoir windows_exporter parmi les éléments de la liste.

Si le logiciel fonctionne correctement, nous devons être capables d’avoir le visuel suivant lorsque nous nous rendons dans un navigateur internet et que nous renseignons l’adresse IP du serveur (ou localhost à la place si c’est directement sur la machine elle-même) suivi du numéro de port 9182 qui représente le numéro de port sur lequel tourne Windows Exporter par défaut :

Et comme d’habitude à chaque fois qu’un nouveau collecteur de métriques est ajouté au sein de notre infrastructure réseau, nous devons pour que ce dernier soit pris en compte par Prometheus, renseigner sa présence (ou son existence) au niveau du fichier de configuration {prometheus.yml}, vous vous en souvenez j’espère 😄.

Ainsi que nous l’avons déjà fait auparavant avec Node Exporter, Docker Exporter et MySQL Exporter (vous devez déjà avoir l’habitude à force 😅), nous allons également créer un Dashboard pour visualiser sous forme de graphes les différentes métriques de Windows Exporter, l’identifiant du tableau de bord utilisé sera cette fois-ci 6593 :

Au final, nous obtenons le Dashboard ci-dessous qui nous renvoi les informations des métriques internes (la période d’activité, le pourcentage de CPU sollicité, la quantité de mémoire RAM utilisée, l’espace disque alloué,...) de notre serveur fonctionnant sous un système d’exploitation Windows.

Ce qui est également assez ‘‘cool’’ avec Grafana 😎, c’est qu’il nous donne la possibilité de pouvoir importer et créer plusieurs Dashboards relatifs au même collecteur de métriques, mais avec des identifiants différents, pour pouvoir avoir aussi une variété de présentation de graphes exploitant les mêmes métriques ; donc à la place de l’identifiant 6593 précédemment utilisé, nous pouvons à la place utiliser l’identifiant 12422 ou tout autre identifiant relatif au collecteur de métrique de type Windows Exporter et qui nous semble le plus significatif ou parlant en terme de quantité d’informations retournées.  

Jusqu’ici, nous disposons d’une solution de monitoring qui fonctionne à l’aide de plusieurs éléments : nous avons dans un premier temps les collecteurs de métriques (Node Exporter, Docker Exporter, MySQL Exporter et Windows Exporter) qui collectent les données et les transmettent à Prometheus ; ensuite, Prometheus stocke les différentes métriques les analyse et les traite avant à son tour de transférer les informations qui en découlent au niveau de Grafana, qui va quant à lui interpréter les informations reçues et afficher les résultats obtenus sous forme de graphes. Bref ce n’est pas mal déjà, on pourrait même s’arrêter là😇, mais une solution complète de monitoring digne de ce nom doit pouvoir être capable au moins de notifier via des alertes de types émail ou SMS au cas où surviendrait un imprévu, dans le but que l’on prenne les dispositions adéquates et nécessaires pour y remédier rapidement. Raison pour laquelle à Prometheus et Grafana nous allons coupler en plus un troisième élément à savoir : AlertManager, qui aura pour rôle principal de générer des alertes et les transférer sous forme de notification émail à chaque fois qu’une ou plusieurs conditions précises sont préalablement remplies.

Pour ce faire, nous allons commencer par créer un fichier nommé {alertmanager.yml} et y insérer les lignes ci-après :

global:
   resolve_timeout: 2m
   smtp_require_tls: false
   http_config:
      tls_config:
         insecure_skip_verify: true
route:           # regles de declenchement
   group_by: ['alertname']
   group_wait: 10s          # temps d'attente avant notification du group
   group_interval: 1m     # delai par rapport aux alertes du meme groupe
   repeat_interval: 5s      # attente avant repetition
   receiver: 'email-me'
receivers:
- name: 'email-me'
  email_configs:
  - to: "jack.grafana@gmail.com"
    from: "jack.grafana@gmail.com"
    smarthost: "smtp.gmail.com:465"
    auth_username: "jack.grafana@gmail.com"
    auth_identity: "jack.grafana@gmail.com"
    auth_password: "P@$$w0rd12345"

Ensuite, nous allons exécuter cette commande « docker run --name alertmanager -d -p 9093:9093 -v $PWD/alertmanager.yml:/etc/alertmanager/alertmanager.yml prom/alertmanager-linux-amd64:v0.20.0 » pour installer AlertManager sur notre serveur de monitoring ;

Puis, nous allons modifier le fichier de configuration de Prometheus pour lui renseigner à travers les lignes suivantes, les informations relatives à AlertManager telles que l’emplacement ou le chemin des fichiers qui lui sont nécessaires :

rule_files:

- /etc/prometheus/rules/alerts.yml

Ainsi que l’adresse IP de l’hôte qui héberge AlertManager et également le numéro de port sur lequel tourne le conteneur en question :

alerting:
alertmanagers:
- static_configs:
   - targets:
      - 192.168.100.136:9093

Enfin, nous modifions aussi le fichier {alerts.yml} pour indiquer les différents paramètres qui doivent être scrutés au point où la moindre correspondance avec une ou plusieurs conditions décrites génère automatiquement une alerte qui sera transférée sous forme de mail grâce à AlertManager vers une ou plusieurs adresses de messagerie internet définies au préalable à cet effet.

(Ps: vous trouverez les lignes à renseigner dans le fichier {alerts.yml} ici.)

Nous pouvons nous assurer que le fichier {alerts.yml} est correctement édité à l’aide de ces commandes : « docker exec -u root -ti prometheus /bin/sh » et « promtool check rules /etc/prometheus/rules/alerts.yml ».

Après avoir redémarré les conteneurs Alertmanager et Prometheus pour valider les différentes modifications apportées, maintenant, pour vérifier que tout fonctionne parfaitement, nous nous rendons sur l’interface web de Prometheus au niveau de l’onglet |Alerts| ;

Nous retrouvons toutes les alertes définies précédemment plus haut dans le fichier {alerts.yml}, il faut noter également que les alertes en question peuvent prendre trois états différents :

*Inactive → pour signifier que tout fonctionne correctement le seuil de la condition n’a pas été atteint ou débordé ;

**Pending → pour signifier que la condition est en cours de vérification ou dans un état intermédiaire ou alors inconnu pour le moment ;

***Firing → pour signifier que la condition à examiner est respectée (le seuil défini est soit atteint ou alors largement dépassé), c’est ce genre d’état-là qui va pousser AlertManager à générer des notifications.

Comme par exemple cette règle qui s’occupe de la vérification de l’espace disque de la machine physique (ceci grâce au collecteur de métriques Node Exporter si vous vous souvenez 😉), une fois qu’elle passe à l’état ‘‘Firing’’,

AlertManager la capture dans son interface web avant de générer une notification sous forme d’émail :

Qui nous parvient à l’adresse (ou aux adresses) de messagerie électronique prévue(s) à cet effet avec en précision, l’adresse IP de la machine qui a provoqué l’alerte, le type de collecteur de métriques concerné, la description de l’alerte, ... 

(Ps: Au cas où vous utiliseriez une adresse de messagerie sous Gmail, et que les messages ne sont pas transmis ou transférés, faudra vous rassurer que ce paramètre est activé.)

Notre solution de monitoring est dorénavant bien installée, paramétrée et fonctionnelle ; elle dispose de trois éléments principaux :

(1) Prometheus qui collecte les données transférées par les collecteurs de métriques et les stocke dans sa base de données ;

(2) Grafana qu’on va combiner à Prometheus, et lui, il va s’occuper d’interpréter les données envoyées par ce dernier et afficher les résultats sous forme de graphes ;

et enfin (3) AlertManager quant à lui va se charger d’examiner des règles définies au niveau de Prometheus, et générer des notifications sous forme de mails une fois les conditions respectées.

Nous allons à présent nous intéresser au cas où nous nous retrouverions au sein d’une infrastructure réseau qui ne dispose pas de technologie Docker, mais que nous souhaitons néanmoins toujours mettre en place une solution de monitoring qui respecte la structure précédente, c’est-à-dire un serveur qui va contenir : Prometheus, Grafana et AlertManager ; un second serveur qui va contenir : Node Exporter, Docker Exporter ; un serveur de base de données avec MySQL Exporter et en dernier un serveur sous Microsoft Windows qui va contenir Windows Exporter, sans toutefois qu’aucun des serveurs en question ne dispose de technologie Docker. Cela est tout à fait possible, mais nous n’aurons plus besoin cependant d’installer Docker Exporter sur l’un des serveurs puisqu’aucune des applications ou services ne sera conteneurisés.

Nous allons procéder comme suit ; déjà pour installer Prometheus, après avoir effectué la mise à jour des paquets du système, nous exécutons la commande « sudo apt-get install prometheus prometheus-node-exporter prometheus-pushgateway -y » : 

Une fois Prometheus installé nous pouvons nous assurer qu’il est bien démarré à l’aide de la commande « systemctl status prometheus » ou via la commande « service prometheus status ».

Passons à présent à l’installation de Grafana ; pour ce faire, nous exécutons tour à tour les commandes « apt-get install -y adduser libfontconfig », suivie de « wget https://dl.grafana.com/oss/release/grafana_5.4.3_amd64.deb » et « dpkg -i grafana_5.4.3_amd64.deb ».

Puis, nous vérifions que Grafana est bien installé et nous entrons les commandes « systemctl enable grafana-server » et « systemctl start grafana-server » respectivement pour activer Grafana et le démarrer, de même, provoquer son exécution directement au lancement du système.

Ensuite, installons AlertManager de cette manière : nous commençons par créer un utilisateur du nom de alertmanager, après, nous créons les répertoires /etc/alertmanager et /var/lib/alertmanager/data et nous lui attribuons les droits adéquats, avant de télécharger l’archive d’AlertManager depuis le dépôt officiel situé sur le site de github : 

Une fois l’archive téléchargée, nous la décompressons et nous copions les éléments {alertmanager} et {amtool} vers l’emplacement /usr/local/bin avant de leur attribuer les droits adéquats.

Nous poursuivons en éditant et en attribuant les droits au fichier {alertmanager.yml},

Ensuite, nous passons à la création du fichier {alertmanager.service} et nous lui renseignons les lignes ci-après ce qui va nous permettre de générer le service AlertManager :

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

[Service]
User=alertmanager
Group=alertmanager
Type=simple
WorkingDirectory=/etc/alertmanager/
ExecStart=/usr/local/bin/alertmanager --config.file=/etc/alertmanager/alertmanager.yml --web.external-url http://0.0.0.0:9093

[Install]
WantedBy=multi-user.target

Puis, nous effectuons des modifications sur le fichier de configuration de Prometheus, également, nous créons et éditons le fichier {alerts.yml} qui contient les règles que AlertManager doit prendre en compte, 

Et enfin, nous redémarrons les services Prometheus et AlertManager pour que toutes les modifications soient prises en considération.

Maintenant, nous allons nous intéresser à l’installation des collecteurs de métriques à savoir : Node Exporter et MySQL Exporter uniquement étant donné que pour Windows Exporter c’est la même procédure que celle décrite plus haut et nous n’aurons plus besoin de Docker Exporter puisque nous sommes (dans ce scénario 🎥) en environnement dépourvu de technologie Docker (par conséquent pas d’existence de services conteneurisés).

Donc commençons par l’installation de Node Exporter : nous créons un utilisateur du nom de node_exporter, ensuite, nous récupérons l’archive de Node Exporter grâce à la commande « curl -LO https://github.com/prometheus/node_exporter/releases/download/v1.2.2/node_exporter-1.2.2.linux-amd64.tar.gz » nous continuons par décompresser l’archive nouvellement téléchargée, la copie de l’élément node_exporter et l’attribution des droits adéquats ;

Par la suite, nous créons le service Node Exporter en renseignant les lignes ci-après

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

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

[Install]
WantedBy=multi-user.target

Ensuite, nous exécutons les commandes « systemctl daemon-reload », « systemctl start node_exporter » et « systemctl enable node_exporter » pour démarrer le service Node Exporter.

Une fois que le service Node Exporter est installé, comme nous avons déjà l’habitude de le faire, il faut apporter des modifications au fichier de configuration du service Prometheus. Nous poursuivons avec l’installation du service MySQL Exporter, c’est pratiquement le même principe que précédemment : nous récupérons l’archive nécessaire à l’installation de MySQL Exporter ;

Après avoir décompressé l’archive, nous allons créer au niveau du répertoire /etc/ le fichier {.exporter.cnf} qui va nous servir de liaison entre le service MySQL Exporter et le serveur de base de données ;

Enfin, nous créons le service MySQL Exporter et nous le démarrons.

[Unit]
 Description=Prometheus MySQL Exporter
 After=network.target

 [Service]
 Type=simple
 Restart=always
 ExecStart=/bin/sh -c '/usr/local/bin/mysqld_exporter \
 --config.my-cnf /etc/.exporter.cnf \
 --collect.global_status \
 --collect.info_schema.innodb_metrics \
 --collect.auto_increment.columns \
 --collect.info_schema.processlist \
 --collect.binlog_size \
 --collect.info_schema.tablestats \
 --collect.global_variables \
 --collect.info_schema.query_response_time \
 --collect.info_schema.userstats \
 --collect.info_schema.tables \
 --collect.perf_schema.tablelocks \
 --collect.perf_schema.file_events \
 --collect.perf_schema.eventswaits \
 --collect.perf_schema.indexiowaits \
 --collect.perf_schema.tableiowaits \
 --collect.slave_status \
 --web.listen-address=0.0.0.0:9104'

 [Install]
 WantedBy=multi-user.target

À présent, vous savez comment installer et configurer une solution de monitoring complète grâce à Prometheus qui va collecter les métriques envoyées par les différents collecteurs de métriques (tels que Node Exporter, Docker Exporter, MySQL Exporter, Windows Exporter), Grafana qui a pour but d’afficher sous forme de graphes les métriques recueillies et pour finir, AlertManager dont le rôle est de générer des alertes en se basant sur des conditions prédéfinies en amont et présenter le tout sous forme de notifications qui seront transféré par exemple sous forme d’emails. Vous êtes capable de le réaliser aussi bien dans un environnement disposant de technologie Docker qu’au sein d’une infrastructure standard dépourvu de Docker. Enfin, en petit bonus rien que pour vous 😉je laisse ce ‘‘petit’’ fichier (qui résume les commandes utilisées tout au long de la procédure d’implémentation de la solution sur les deux types d’environnement) à votre disposition 😎.

Merci d’avoir suivi le tutoriel jusqu’à la fin.

À très bientôt !!!