Système de surveillance Prometheus

À mesure que les systèmes et les applications gagnent en complexité, la surveillance devient essentielle pour garantir des performances, une fiabilité et une évolutivité optimales. Prometheus, une boîte à outils de surveillance et d’alerte open-source, est devenue l’une des solutions les plus populaires pour la gestion et la visualisation des mesures de divers systèmes. Développé à l’origine par SoundCloud, Prometheus est aujourd’hui un projet de la Cloud Native Computing Foundation (CNCF) et est largement adopté par l’ensemble des secteurs d’activité.

Dans cet article, nous allons explorer les principales caractéristiques de Prometheus, son fonctionnement et les étapes nécessaires à sa mise en place pour la surveillance de votre infrastructure et de vos applications.

Qu’est-ce que Prometheus ?

Prometheus est un puissant système de surveillance conçu pour collecter, stocker et interroger des données temporelles, c’est-à-dire des mesures ou des événements suivis dans le temps. Les données collectées par Prometheus peuvent être visualisées, analysées et utilisées pour déclencher des alertes, aidant ainsi les équipes à rester au fait de l’état de santé et des performances de leur infrastructure.

Prometheus est connu pour plusieurs caractéristiques clés :

• Modèle de données chronologiques : Prometheus stocke les données sous forme de séries temporelles, ce qui signifie que les mesures sont enregistrées sur des intervalles de temps.
• Surveillance basée sur l’extraction : Au lieu que les systèmes surveillés envoient des métriques au serveur, Prometheus utilise un modèle basé sur l’extraction pour récupérer les métriques à partir des points d’extrémité.
• Langage de requête puissant (PromQL) : Prometheus fournit un langage de requête puissant, PromQL, qui permet aux utilisateurs de filtrer et d’agréger les métriques en temps réel.
• Alertes : Prometheus s’intègre à Alertmanager pour définir des règles et envoyer des notifications lorsque des conditions spécifiques sont remplies.
• Découverte de services : Prometheus peut découvrir et gratter automatiquement des métriques à partir d’environnements changeant dynamiquement, comme Kubernetes.

Fonctionnement de Prometheus

Prometheus suit une architecture simple mais robuste conçue pour surveiller les données de séries temporelles. Voici comment il fonctionne :

1. Collecte de métriques (scraping) : Prometheus récupère périodiquement des métriques à partir de points d’extrémité HTTP (appelés exportateurs) exposés par des applications ou des systèmes.
2. Stockage des données chronologiques : Une fois les données collectées, Prometheus les stocke dans une base de données chronologique, où chaque point de données est associé à un horodatage et à un ensemble d’étiquettes.
3. Interrogation avec PromQL : Les utilisateurs peuvent interroger les mesures stockées à l’aide du langage de requête de Prometheus, PromQL, pour générer des graphiques, des tableaux de bord ou des alertes.
4. Alertes : Sur la base de conditions prédéfinies, Prometheus peut déclencher des alertes à l’aide de l’Alertmanager, qui peut envoyer des notifications par e-mail, Slack, PagerDuty ou d’autres services.

Prometheus prend en charge un modèle basé sur l’extraction où il récupère périodiquement des métriques à partir de points d’extrémité qui exposent des métriques dans un format que Prometheus peut comprendre. Cela le rend idéal pour la surveillance des systèmes distribués et des microservices où les environnements évolutifs et dynamiques sont courants.

Composants de Prometheus

Prometheus est constitué de plusieurs composants de base, chacun servant un objectif différent :

1. Prometheus Server : Le composant central responsable de la collecte, du stockage et de l’interrogation des métriques. Il scrape les points d’extrémité cibles et stocke les mesures dans une base de données chronologique.
2. Exportateurs : Il s’agit d’applications ou de services qui exposent les mesures dans un format compatible avec Prometheus. Les exportateurs les plus courants sont les suivants
   • Node Exporter : collecte des mesures au niveau du matériel et du système d’exploitation.
   • Blackbox Exporter : pour sonder les points d’extrémité via HTTP, DNS, TCP, etc.
   • Exportateurs spécifiques aux applications : De nombreuses bases de données (telles que PostgreSQL, MySQL) et de nombreux services disposent de leurs propres exportateurs.
3. Alertmanager : Prometheus utilise l’Alertmanager pour gérer les alertes. Il peut acheminer les alertes vers différents destinataires tels que Slack, les courriels ou les SMS, et gérer les règles de mise en sourdine et d’inhibition.
4. PromQL (Prometheus Query Language) : Un langage de requête puissant utilisé pour récupérer et manipuler des données de séries temporelles.
5. Pushgateway : Composant utilisé pour les tâches éphémères ou de courte durée qui ne peuvent pas exposer les métriques via un scrape direct (par exemple, les tâches par lots). Le Pushgateway permet à ces travaux de pousser leurs métriques vers Prometheus.
6. Grafana : Bien qu’il ne fasse pas partie de Prometheus lui-même, Grafana est un outil open-source populaire utilisé pour visualiser les données Prometheus et créer des tableaux de bord interactifs.

Configuration pas à pas de Prometheus

Voici comment configurer Prometheus sur un serveur Linux et commencer à surveiller les métriques du système :

Étape 1 : Installer Prometheus

1. Téléchargez Prometheus : Visitez la page de téléchargement de Prometheus pour obtenir la dernière version de Prometheus. Exécutez les commandes suivantes pour télécharger et extraire Prometheus :
   wget https://github.com/prometheus/prometheus/releases/download/v2.32.1/prometheus-2.32.1.linux-amd64.tar.gz tar -xvf prometheus-2.32.1.linux-amd64.tar.gz cd prometheus-2.32.1.linux-amd64
2. Démarrez Prometheus : Exécutez la commande suivante pour démarrer Prometheus :
   ./prometheus –config.file=prometheus.yml

   Par défaut, Prometheus s’exécute sur le port 9090, et vous pouvez accéder à son interface web en naviguant vers http://localhost:9090 dans votre navigateur.

Étape 2 : Configurer Prometheus

La configuration principale de Prometheus se fait via le fichier prometheus.yml. Ce fichier indique à Prometheus quelles cibles (exportateurs) doivent être scrappées et à quelle fréquence.

Voici une configuration de base de prometheus.yml :

Vous pouvez ajouter d’autres cibles ou exportateurs si nécessaire, et Prometheus commencera automatiquement à les scraper.

Étape 3 : Installer l’exportateur Node (pour les métriques système)

Pour surveiller les paramètres système tels que l’utilisation du processeur, de la mémoire, du disque et du réseau, vous pouvez installer Node Exporter.

1. Téléchargez Node Exporter :
   wget https://github.com/prometheus/node_exporter/releases/download/v1.3.1/node_exporter-1.3.1.linux-amd64.tar.gz tar -xvf node_exporter-1.3.1.linux-amd64.tar.gz cd node_exporter-1.3.1.linux-amd64
2. Démarrer Node Exporter : Exécutez la commande suivante pour démarrer Node Exporter :
   ./node_exporter

   Par défaut, Node Exporter s’exécute sur le port 9100 et expose des mesures telles que l’utilisation de l’unité centrale, les statistiques de mémoire, les entrées/sorties de disque et les mesures de réseau.

3. Configurez Prometheus pour qu’il scrape Node Exporter : ajoutez la tâche suivante au fichier de configuration prometheus.yml :
   scrape_configs : – job_name : ‘node_exporter’ static_configs : – targets : [‘localhost:9100’]
4. Redémarrez Prometheus : Après avoir apporté des modifications au fichier de configuration, redémarrez Prometheus pour commencer à collecter des métriques à partir de Node Exporter.

Étape 4 : Visualiser les métriques avec Grafana

Pour visualiser les métriques de Prometheus, Grafana est un excellent outil. Il s’intègre parfaitement à Prometheus et vous permet de créer des tableaux de bord interactifs.

1. Installez Grafana : Sous Linux, vous pouvez installer Grafana en suivant les instructions sur le site Web de Grafana.
2. Configurez Prometheus en tant que source de données : Après avoir installé Grafana :
   • Connectez-vous à Grafana (http://localhost:3000).
   • Allez dans Configuration > Data Sources et ajoutez Prometheus en tant que source de données (http://localhost:9090).
3. Créez des tableaux de bord : Vous pouvez désormais créer vos propres tableaux de bord personnalisés ou importer des tableaux de bord préconstruits à partir de la place de marché de Grafana pour visualiser des mesures telles que l’utilisation du processeur, l’utilisation de la mémoire, les performances du disque, etc.

Étape 5 : Configurer des alertes

Prometheus vous permet de configurer des alertes basées sur des conditions spécifiques, telles qu’une utilisation élevée du CPU, un espace disque faible ou des défaillances d’application.

1. Définir les règles d’alerte : Les alertes sont définies dans un fichier rules.yml distinct. Voici un exemple de règle d’alerte qui se déclenche lorsque l’utilisation du processeur est supérieure à 80 % :
   groups : – name : example_alerts rules : – alert : HighCPUUsage expr : 100 – (avg by(instance) (rate(node_cpu_seconds_total{mode=”idle”}[5m])) * 100) > 80 for : 5m labels : severity : warning annotations : summary : “High CPU usage detected on {{ $labels.instance }}” description : “L’utilisation du processeur est supérieure à 80 % pendant plus de 5 minutes”
2. Configuration de l’Alertmanager : Installer et configurer l’Alertmanager pour qu’il envoie des notifications par email, Slack ou d’autres canaux lorsqu’une alerte est déclenchée.

Cas d’utilisation de Prometheus

Prometheus est utilisé dans un large éventail de scénarios pour surveiller différents types de systèmes, notamment :

1. Surveillance de l’infrastructure : Collecte de métriques à partir de serveurs, de bases de données et de périphériques réseau pour garantir le bon fonctionnement de votre infrastructure.
2. Surveillance des applications : Suivez les métriques de performance telles que la latence, le taux de requête, les taux d’erreur et la consommation de ressources pour les applications, en particulier dans les architectures microservices.
3. Surveillance de Kubernetes : Prometheus s’intègre nativement à Kubernetes et peut automatiquement découvrir et gratter les métriques des pods et des services dans un cluster Kubernetes.
4. Métriques personnalisées : Prometheus vous permet d’instrumenter vos propres applications afin d’exposer des métriques personnalisées, ce qui permet d’obtenir des informations approfondies sur les comportements spécifiques aux applications.

Conclusion

Prometheus est une solution de surveillance puissante et flexible qui permet de collecter, d’interroger et d’alerter en temps réel sur la base de séries de données temporelles. Que vous surveilliez les métriques au niveau du système ou les performances des applications dans une architecture microservices, Prometheus est un outil précieux pour garantir la santé et la stabilité de votre infrastructure.

En suivant les étapes décrites dans cet article, vous pouvez démarrer avec Prometheus, collecter des métriques à partir de vos systèmes et visualiser ces métriques à l’aide de Grafana. Au fil du temps, Prometheus peut vous aider à mieux comprendre les tendances en matière de performances, à détecter les anomalies et à répondre rapidement aux incidents, améliorant ainsi le temps de fonctionnement et la fiabilité du système.