Zabbix, Nagios, Prometheus – Solutions de Monitoring OpenSource

Surveiller une infrastructure informatique est crucial pour garantir la disponibilité, les performances, et la sécurité de vos systèmes, que vous gériez un homelab avec quelques Raspberry Pi ou une infrastructure professionnelle avec des centaines de serveurs. Parmi les outils open-source les plus populaires, Zabbix, Nagios, et Prometheus se distinguent, chacun avec ses forces et ses spécificités. Dans cet article, nous allons explorer ces trois solutions en détail, comparer leurs fonctionnalités, et vous guider pour choisir celle qui convient le mieux à vos besoins. Préparez-vous à plonger dans le monde du monitoring !

De quelles solutions parlons-nous ?

– Zabbix : est un outil open-source de surveillance d’infrastructure, créé en 2001 par Alexei Vladishev, un développeur letton. Initialement conçu comme une solution interne pour surveiller des réseaux, il est devenu un projet open-source sous licence GNU Affero General Public License v3. Basé à Riga, Zabbix LLC maintient le projet et propose des services professionnels (support, formation). Zabbix est une solution complète qui intègre la collecte de données, le stockage (via une base relationnelle comme MySQL), la visualisation (dashboards natifs), et les alertes. Il est capable de surveiller des millions de métriques sur des centaines de milliers de dispositifs, ce qui en fait un choix populaire pour les environnements complexes.

– Nagios : anciennement NetSaint, a été créé en 1999 par Ethan Galstad, un administrateur système américain. Rebaptisé Nagios en 2002 (acronyme récursif pour « Nagios Ain’t Gonna Insist On Sainthood »), il est distribué sous licence GNU General Public License v2. Nagios Enterprises, basé aux États-Unis, maintient le projet et commercialise des versions payantes comme Nagios XI. Conçu à l’origine pour Linux et les systèmes Unix, Nagios est une solution de monitoring modulaire qui repose sur un système de plugins pour surveiller une vaste gamme de systèmes et services. Avec une communauté de millions d’utilisateurs et plus de 3 000 plugins disponibles, il est l’un des outils les plus anciens et les plus utilisés dans le domaine.

– Prometheus : est un outil open-source de monitoring et d’alerte, créé en 2012 par SoundCloud, une plateforme de streaming musical. Inspiré par le système de monitoring interne de Google (Borgmon), Prometheus a été conçu pour répondre aux besoins des environnements cloud-native et DevOps. Sous licence Apache 2.0, il est aujourd’hui maintenu par la Cloud Native Computing Foundation (CNCF), aux côtés de projets comme Kubernetes. Prometheus se concentre sur la collecte et le stockage de métriques sous forme de séries temporelles, avec une approche modulaire qui le rend idéal pour les infrastructures dynamiques (conteneurs, microservices). Il est souvent couplé à Grafana pour la visualisation.

Quels sont leurs usages ?

Zabbix :

• Collecte de métriques : Zabbix surveille des serveurs (CPU, mémoire, disque), des réseaux (latence, bande passante), des applications (bases de données, API), et même des appareils IoT (température, capteurs).
• Alertes : Il vous permet de définir des seuils complexes (ex. : alerte si le disque est plein à 90 % pendant 10 minutes) et d’envoyer des notifications via email, SMS, Telegram, ou scripts personnalisés.
• Visualisation : Zabbix propose des dashboards natifs avec des graphiques (CPU, réseau, etc.), des cartes réseau, et des vues personnalisées.
• Automatisation : Vous pouvez configurer des actions automatiques (ex. : redémarrer un service ou exécuter un script en cas de panne).
• Inventaire : Zabbix collecte des informations sur les équipements (numéro de série, localisation), utiles pour la gestion d’actifs.
• Scalabilité : Il est adapté aux grandes infrastructures grâce à son architecture de proxy (Zabbix Proxy) pour répartir la charge.

Nagios :

• Surveillance des hôtes et services : Nagios vérifie la disponibilité des hôtes (ping), des services réseau (HTTP, SSH, FTP), et des ressources système (CPU, mémoire).
• Alertes proactives : Il vous notifie lors d’un problème (ex. : serveur hors ligne) et lors de sa résolution, via email, SMS, ou scripts.
• Extensibilité : Grâce à ses plugins, Nagios peut surveiller des applications spécifiques (ex. : MySQL, Apache), des services cloud (AWS, Azure), ou des appareils physiques (imprimantes, routeurs).
• Détection des problèmes : Il identifie les pannes ou dégradations avant qu’elles n’impactent les utilisateurs, grâce à des checks réguliers.
• Historique et rapports : Nagios conserve un historique des événements et génère des rapports (disponibilité, temps de réponse).
• Personnalisation : Les plugins et scripts vous permettent de répondre à des besoins spécifiques (ex. : vérifier la température d’un Raspberry Pi).

Prometheus :

• Collecte de métriques : Prometheus récupère des métriques via un modèle de scraping HTTP (ex. : Node Exporter pour les systèmes Linux, Blackbox Exporter pour les sites web).
• Stockage : Il utilise une base de données de séries temporelles (TSDB) pour stocker les données, optimisée pour les analyses temporelles.
• Alertes : Avec Alertmanager, Prometheus vous envoie des notifications (email, Slack, Telegram) en cas de problème (ex. : CPU > 80 %).
• Requêtes avancées : Son langage PromQL vous permet des analyses complexes (ex. : taux d’erreurs HTTP sur 24h).
• Cloud-native : Prometheus est conçu pour les environnements dynamiques comme Kubernetes, avec une découverte automatique des services.
• Visualisation : Bien qu’il propose une interface de base, il est généralement associé à Grafana pour des dashboards plus riches.

Matériel requis

Voici les besoins pour une petite installation (50 hôtes, 500 métriques) :

Zabbix :

• Processeur : 2 cœurs (ex. : Raspberry Pi 4 pour un usage léger, mais un serveur dédié est préférable pour plus de 100 hôtes).
• Mémoire : 2 Go minimum (4 Go recommandé pour des performances fluides, car la base de données est gourmande).
• Stockage : 10 Go pour la base de données (MySQL/PostgreSQL), plus si vous conservez un historique long (ex. : 1 an).
• Réseau : Ports 10050 (agent), 10051 (serveur), 80/443 (web). Une connexion stable est essentielle pour les rapports en temps réel.

Nagios :

• Processeur : 1 cœur (Raspberry Pi 4 suffisant pour une petite installation).
• Mémoire : 1 Go minimum (2 Go recommandé pour gérer plusieurs plugins simultanément).
• Stockage : 5 Go pour les fichiers de configuration, logs, et données. Les plugins peuvent augmenter les besoins.
• Réseau : Ports 80/443 (interface web), 5666 (NRPE pour les agents). Une latence réseau faible est préférable pour des checks fréquents.

Prometheus :

• Processeur : 1 cœur (Raspberry Pi 4 possible pour un usage léger).
• Mémoire : 1 Go minimum (2 Go recommandé si vous scrape beaucoup de cibles).
• Stockage : 5 Go pour les séries temporelles (TSDB). Prometheus compresse les données, mais un historique long augmente les besoins.
• Réseau : Ports 9090 (serveur), 9100 (Node Exporter). Une connexion stable est nécessaire pour le scraping.

Pour les grandes installations (ex. : 1000 hôtes) :

Zabbix peut nécessiter 8 Go de RAM et 4 cœurs, avec une base de données optimisée (ex. : MySQL sur un serveur séparé).

Nagios reste léger mais peut ralentir si vous avez beaucoup de plugins ; envisagez des addons comme mod_gearman pour distribuer les checks.

Prometheus est performant mais nécessite une planification (ex. : utiliser Thanos pour un stockage à long terme).

Installation

– Zabbix (sur Debian)

Ajouter le dépôt Zabbix :

wget https://repo.zabbix.com/zabbix/6.4/ubuntu/pool/main/z/zabbix-release/zabbix-release_6.4-1+Ubuntu22.04_all.deb
sudo dpkg -i zabbix-release_6.4-1+Ubuntu22.04_all.deb
sudo apt update

Installer les composants :

sudo apt install zabbix-server-mysql zabbix-frontend-php zabbix-apache-conf zabbix-agent

Configurer la base de données (MariaDB) :

sudo apt install mariadb-server
sudo systemctl start mariadb
sudo mysql -uroot -p
create database zabbix character set utf8mb4 collate utf8mb4_bin;
create user ‘zabbix’@’localhost’ identified by ‘votre_mot_de_passe’;
grant all privileges on zabbix.* to ‘zabbix’@’localhost’;
flush privileges;
exit;
zcat /usr/share/zabbix-sql-scripts/mysql/server.sql.gz | mysql -uzabbix -p zabbix

Configurer le serveur :

sudo nano /etc/zabbix/zabbix_server.conf
DBName=zabbix
DBUser=zabbix
DBPassword=votre_mot_de_passe

Démarrer les services :

sudo systemctl enable –now zabbix-server zabbix-agent apache2

Accéder à l’interface :

• Rendez-vous sur http://<IP_DU_SERVEUR>/zabbix.
• Identifiants : Admin/zabbix.
• Changez le mot de passe immédiatement.

Conseil : Si vous utilisez un pare-feu (ex. : UFW), ouvrez les ports : sudo ufw allow 10050,10051,80,443.

– Nagios (sur Debian)

Installer les dépendances :

sudo apt update
sudo apt install -y apache2 libapache2-mod-php php gcc make wget build-essential

Télécharger Nagios Core :

wget https://assets.nagios.com/downloads/nagioscore/releases/nagios-4.5.0.tar.gz
tar xzf nagios-4.5.0.tar.gz
cd nagios-4.5.0

Compiler et installer :

./configure –with-httpd-conf=/etc/apache2/sites-available
make all
sudo make install
sudo make install-init
sudo make install-config
sudo make install-commandmode

Installer les plugins Nagios :

cd ~
wget https://nagios-plugins.org/download/nagios-plugins-2.4.0.tar.gz
tar xzf nagios-plugins-2.4.0.tar.gz
cd nagios-plugins-2.4.0
./configure
make
sudo make install

Configurer l’interface web :

sudo make install-webconf
sudo a2enmod rewrite cgi
sudo systemctl restart apache2
sudo htpasswd -c /usr/local/nagios/etc/htpasswd.users nagiosadmin

Saisissez un mot de passe pour nagiosadmin.

Démarrer Nagios :

sudo systemctl enable nagios
sudo systemctl start nagios

Accéder à l’interface :

Rendez-vous sur http://<IP_DU_SERVEUR>/nagios. Identifiants : nagiosadmin/<mot_de_passe>.

Conseil : Ouvrez le port 80 : sudo ufw allow 80.

– Prometheus (sur Debian)

Télécharger Prometheus :

wget https://github.com/prometheus/prometheus/releases/latest/download/prometheus-<VERSION>.linux-amd64.tar.gz
tar xzf prometheus-<VERSION>.linux-amd64.tar.gz
cd prometheus-<VERSION>.linux-amd64

Remplacez <VERSION> par la dernière version (vérifiez sur GitHub).

Créer un fichier de configuration :

Éditez prometheus.yml :

global:
scrape_interval: 15s
scrape_configs:
– job_name: ‘server’
static_configs:
– targets: [‘localhost:9100’]

Installer Node Exporter (pour surveiller un hôte) :

wget https://github.com/prometheus/node_exporter/releases/latest/download/node_exporter-<VERSION>.linux-amd64.tar.gz
tar xzf node_exporter-<VERSION>.linux-amd64.tar.gz
sudo cp node_exporter-<VERSION>.linux-amd64/node_exporter /usr/local/bin/
sudo useradd –no-create-home –shell /usr/sbin/nologin node_exporter
sudo tee /etc/systemd/system/node_exporter.service > /dev/null <<EOF
[Unit]
Description=Node Exporter
After=network.target
[Service]
User=node_exporter
ExecStart=/usr/local/bin/node_exporter
Restart=always
[Install]
WantedBy=default.target
EOF
sudo systemctl enable –now node_exporter

Lancer Prometheus :

./prometheus –config.file=prometheus.yml

Pour une utilisation permanente, créez un service systemd similaire à Node Exporter.

Accéder à l’interface :

Rendez-vous sur http://<IP_DU_SERVEUR>:9090.

Conseil : Ouvrez le port 9090 : sudo ufw allow 9090.

Utilisation & accès

– Zabbix

Ajouter un hôte :

Rendez-vous dans Configuration > Hôtes > Créer un hôte.

Nom : « RaspberryPi_Salon », IP : 192.168.1.42, Groupe : « Raspberry Pis ».

Interface : 192.168.1.42:10050 (agent Zabbix).

Installer l’agent sur l’hôte :

Sur le Raspberry Pi :

sudo apt install zabbix-agent
sudo nano /etc/zabbix/zabbix_agentd.conf
Server=192.168.1.10 # IP du serveur Zabbix
sudo systemctl enable –now zabbix-agent

Appliquer un template :

Allez dans l’onglet Templates de l’hôte, liez « Linux by Zabbix agent ».

Cela active la surveillance de CPU, mémoire, disque, etc.

Consulter les données :

Rendez-vous dans Monitoring > Dernières données pour voir les métriques.

Dans Monitoring > Tableaux de bord, consultez les graphiques.

Configurer une alerte :

Allez dans Configuration > Actions > Déclencheurs.

Exemple : Si CPU > 80 % pendant 5 minutes, envoie un email.

Configurez un média dans Administration > Paramètres généraux > Médias.

– Nagios

Définir un hôte et un service :

Éditez /usr/local/nagios/etc/objects/hosts.cfg :

define host {
use linux-server
host_name raspberrypi
alias Raspberry Pi Salon
address 192.168.1.xx
}

Éditez /usr/local/nagios/etc/objects/services.cfg :

define service {
use generic-service
host_name raspberrypi
service_description HTTP
check_command check_http
}

Installer NRPE sur l’hôte :

Sur le Raspberry Pi :

sudo apt install nagios-nrpe-server
sudo nano /etc/nagios/nrpe.cfg
allowed_hosts=192.168.1.10 # IP du serveur Nagios
sudo systemctl restart nagios-nrpe-server

Ajoutez un service CPU :

define service {
use generic-service
host_name raspberrypi
service_description CPU Load
check_command check_nrpe!check_load
}

Vérifier et redémarrer :

sudo /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg
sudo systemctl restart nagios

Consulter l’état :

Rendez-vous sur http://<IP_DU_SERVEUR>/nagios pour voir l’état des hôtes et services.

Configurer une alerte :

Éditez /usr/local/nagios/etc/objects/contacts.cfg :

define contact {
contact_name admin
alias Admin
email admin@votreSiteWeb.fr
service_notification_commands notify-service-by-email
}

– Prometheus

Installer Node Exporter sur l’hôte :

Sur le Raspberry Pi (déjà fait dans l’installation).

Ajouter l’hôte dans Prometheus :

Éditez prometheus.yml :

– job_name: ‘raspberrypi’
static_configs:
– targets: [‘192.168.1.42:9100’]
labels:
alias: ‘salon’

Consulter les métriques :

Rendez-vous sur http://<IP_DU_SERVEUR>:9090 > Status > Targets pour vérifier que l’hôte est actif.

Utilisez PromQL pour interroger (ex. : node_cpu_seconds_total).

Configurer une alerte :

Installez Alertmanager :

wget https://github.com/prometheus/alertmanager/releases/latest/download/alertmanager-<VERSION>.linux-amd64.tar.gz
tar xzf alertmanager-<VERSION>.linux-amd64.tar.gz
cd alertmanager-<VERSION>.linux-amd64

Configurez alertmanager.yml :

route:
receiver: ‘telegram’
receivers:
– name: ‘telegram’
telegram_configs:
– bot_token: ‘<VOTRE_TOKEN>’
chat_id: ‘<VOTRE_CHAT_ID>’
message: ‘Alerte : {{ .CommonAnnotations.summary }}’

Créez une règle d’alerte dans rules.yml :

groups:
– name: example
rules:
– alert: HighCPUUsage
expr: 100 – (avg by(instance) (rate(node_cpu_seconds_total{mode= »idle »}[5m])) * 100) > 80
for: 5m
labels:
severity: critical
annotations:
summary: « CPU usage high on {{ $labels.instance }} »

Chargez les règles dans prometheus.yml :

rule_files:
– « rules.yml »

Redémarrez Prometheus et Alertmanager.

Configurations d’exemple

Surveiller un Raspberry Pi

– Zabbix :

• Hôte : « RaspberryPi_Salon », IP : 192.168.1.42.
• Template : « Linux by Zabbix agent ».
• Item personnalisé : Température (system.run[cat /sys/class/thermal/thermal_zone0/temp]).
• Déclencheur : Si température > 70°C, envoie une alerte Telegram.

– Nagios :

• Hôte : « raspberrypi », IP : 192.168.1.42.
• Service : « CPU Load » via NRPE (check_load).
• Service : « Temperature » via un plugin personnalisé (check_temp).
• Alerte : Si charge > 5.0 ou température > 70°C, envoie un email.

– Prometheus :

• Hôte : Node Exporter sur 192.168.1.42:9100.
• Métrique : node_hwmon_temp_celsius pour la température.
• Alerte : Si CPU > 80 % ou température > 70°C, envoie une notification Telegram.

Surveiller un site web

– Zabbix :

• Hôte : « MonSite », URL : monsite.com.
• Template : « HTTP service ».
• Item : web.page.get[monsite.com].
• Déclencheur : Si code HTTP ≠ 200, envoie une notification email.

– Nagios :

• Service : « HTTP » avec check_http.
• Commande : check_http -H monsite.com -w 5 -c 10.
• Alerte : Si temps de réponse > 10s ou site inaccessible, notifie via SMS.

– Prometheus :

Utilisez Blackbox Exporter :

– job_name: ‘website’
metrics_path: /probe
params:
module: [http_2xx]
static_configs:
– targets: [‘monsite.com’]
relabel_configs:
– source_labels: [__address__]
target_label: __param_target
– source_labels: [__param_target]
target_label: instance
– target_label: __address__
replacement: 127.0.0.1:9115 # Adresse de Blackbox Exporter

Alerte : Si site inaccessible, notifie via Slack.

Surveiller une base de données MySQL

Zabbix :

• Template : « MySQL by Zabbix agent ».
• Item : mysql.status[Uptime].
• Déclencheur : Si uptime < 300s (redémarrage récent), alerte.

Nagios :

• Plugin : check_mysql (inclus dans les plugins Nagios).
• Service : check_mysql -H 192.168.1.50 -u user -p password.
• Alerte : Si connexion échoue, notifie.

Prometheus :

• Utilisez MySQL Exporter :

– job_name: ‘mysql’

static_configs:

– targets: [‘192.168.1.50:9104’]

Métrique : mysql_up.

Alerte : Si mysql_up == 0, notifie.

Intégration avec Grafana (bonus)

– Zabbix :

Installez le plugin Zabbix :

sudo grafana-cli plugins install alexanderzobnin-zabbix-app
sudo systemctl restart grafana-server

Ajoutez Zabbix comme source dans Configuration > Data Sources.

Importez un dashboard (ex. : ID 4921).

– Nagios :

Utilisez InfluxDB pour stocker les données :

Configurez NDOUtils pour exporter les métriques de Nagios vers InfluxDB.

Ajoutez InfluxDB comme source dans Grafana.

Créez des dashboards personnalisés (ex. : disponibilité des services).

– Prometheus :

Ajoutez Prometheus comme source dans Grafana :

URL : http://<IP>:9090.

Importez un dashboard (ex. : ID 1860, « Node Exporter Full »).

Personnalisez les panneaux (ex. : température CPU, charge réseau).

Cas d’usage avancés

Zabbix :

Découverte automatique (LLD) : Configurez la découverte de bas niveau (Low-Level Discovery) pour détecter automatiquement les disques ou interfaces réseau.

Proxy Zabbix : Utilisez un proxy pour surveiller des réseaux distants (ex. : un bureau à l’étranger).

Corrélation d’événements : Configurez des règles pour corréler les alertes (ex. : ignorez une alerte disque plein si le serveur est en maintenance).

Nagios :

Plugin personnalisé : Écrivez un script Bash pour surveiller un capteur IoT (ex. : humidité via un Raspberry Pi) :

#!/bin/bash

VALUE=$(i2cget -y 1 0x44 0x00)

if [ $VALUE -gt 80 ]; then

echo « CRITICAL – Humidité trop élevée : $VALUE% »

exit 2

else

echo « OK – Humidité : $VALUE% »

exit 0

fi

Surveillance distribuée : Utilisez mod_gearman pour répartir les checks sur plusieurs serveurs.

Intégration ITSM : Connectez Nagios à un outil comme ServiceNow pour créer des tickets automatiquement.

Prometheus :

Kubernetes : Configurez la découverte automatique pour surveiller les pods :

– job_name: ‘kubernetes-pods’

kubernetes_sd_configs:

– role: pod

Federation : Utilisez une architecture fédérée pour centraliser les métriques de plusieurs clusters.

Stockage à long terme : Intégrez Thanos pour conserver les données sur plusieurs années.

Comparaison : Quel outil choisir ?

Architecture :

• Zabbix : Solution tout-en-un, centralisée. Idéal pour une gestion intégrée, mais plus lourde (base relationnelle).
• Nagios : Modulaire, basée sur des plugins. Très flexible, mais nécessite plus de configuration manuelle.
• Prometheus : Modulaire, orientée cloud-native. Nécessite des outils complémentaires (Grafana, Alertmanager).

Collecte :

• Zabbix : Agents, sans agent (SNMP, JMX, HTTP). Polyvalent pour des environnements variés (serveurs, IoT).
• Nagios : Plugins et NRPE. Extensible, mais chaque nouvelle métrique nécessite un plugin ou script.
• Prometheus : Scraping HTTP (via exporters). Optimisé pour les applications modernes (Kubernetes, APIs).

Stockage :

• Zabbix : Base relationnelle (MySQL/PostgreSQL). Structurée, mais gourmande en ressources.
• Nagios : Fichiers plats ou bases externes (via addons). Léger, mais moins performant pour les gros volumes.
• Prometheus : Base de séries temporelles (TSDB). Rapide, mais limitée pour les données non-métriques.

Visualisation :

• Zabbix : Dashboards natifs corrects, avec cartes réseau et vues personnalisées.
• Nagios : Interface web basique, dépassée. Mieux avec Grafana.
• Prometheus : Interface minimale, mais Grafana offre des visualisations avancées.

Alertes :

• Zabbix : Très configurables, avec corrélation d’événements (ex. : ignorez les alertes pendant une maintenance).
• Nagios : Basiques, mais extensibles via scripts (ex. : envoyez un SMS via Twilio).
• Prometheus : Puissantes avec Alertmanager, supporte des canaux modernes (Slack, PagerDuty).

Cas d’usage :

• Zabbix : Infrastructures hétérogènes (serveurs, IoT, réseaux), besoin de gestion centralisée.
• Nagios : Petites infrastructures ou besoins spécifiques (ex. : plugin personnalisé pour un capteur IoT).
• Prometheus : Environnements DevOps, cloud-native (Kubernetes, Docker), architectures dynamiques.

Courbe d’apprentissage :

Zabbix : Modérée. L’interface est intuitive, mais la configuration des templates peut être complexe.

Nagios : Élevée. La configuration manuelle (fichiers texte) demande du temps.

Prometheus : Modérée. PromQL et la configuration YAML peuvent intimider, mais la documentation est excellente.

Bonnes pratiques

– Zabbix :

Optimisez la base de données (ex. : partitionnez les tables pour un historique long).

Utilisez des proxies pour répartir la charge dans des réseaux distants.

Sauvegardez régulièrement /etc/zabbix et la base de données.

– Nagios :

Organisez les fichiers de configuration (ex. : un dossier par type d’hôte : /usr/local/nagios/etc/servers/).

Testez les plugins avant déploiement (./check_plugin –help).

Utilisez des addons comme check_mk pour simplifier la gestion.

– Prometheus :

Configurez des labels pour identifier les cibles (ex. : alias: salon).

Limitez la fréquence de scraping (ex. : 15s) pour éviter la surcharge.

Sauvegardez prometheus.yml et utilisez un outil comme Thanos pour un stockage à long terme.

En résumé

Zabbix, Nagios, et Prometheus sont trois outils puissants pour surveiller votre infrastructure, mais ils répondent à des besoins différents. Zabbix est idéal pour une solution tout-en-un avec une gestion centralisée, parfait pour les infrastructures hétérogènes. Nagios brille par sa flexibilité et ses plugins, adapté aux petites installations ou aux besoins spécifiques. Prometheus, avec Grafana, est le choix de prédilection pour les environnements DevOps et cloud-native, grâce à sa légèreté et son intégration avec Kubernetes.

Pour choisir, posez-vous ces questions :

• Avez-vous besoin d’une solution tout-en-un ou modulaire ?
• Votre infrastructure est-elle traditionnelle ou cloud-native ?
• Êtes-vous prêt à investir du temps dans la configuration manuelle (Nagios) ou à apprendre un nouveau langage comme PromQL (Prometheus) ?

Nous vous invitons à tester les trois outils selon vos besoins : commencez par Zabbix pour une approche intégrée, Nagios pour une personnalisation poussée, ou Prometheus pour un setup moderne avec Grafana. Partagez vos configurations préférées et vos dashboards!