Installer Grafana, Prometheus et Blackbox Exporter avec Docker Compose sur Ubuntu

Introduction

Dans le paysage dynamique du monde numérique, la surveillance proactive des sites web est cruciale pour assurer une disponibilité continue et une performance optimale. Dans ce tutoriel, nous explorerons l'implémentation d'un serveur de supervision robuste en combinant des outils puissants tels que Grafana, Prometheus et Black Box Exporter, le tout orchestré à l'aide de Docker Compose.

Pourquoi cette solution ?

Grafana offre une interface intuitive et des tableaux de bord personnalisables, tandis que Prometheus excelle dans la collecte et le stockage des métriques. En intégrant Black Box Exporter, on peut étendre la capacité de supervision à des vérifications actives sur des sites web, garantissant une visibilité totale de l'état de services en temps réel.

Préparation et configuration du serveur

Il faut tout d'abord posséder un serveur sous Ubuntu, une instance cloud, un VPS, un serveur dédié, puis enregistrer une entrée A avec l'IP de ce serveur dans la zone DNS, afin de lui attribuer un domaine ou un sous domaine souhaité.

Ensuite, il convient de se connecter avec les identifiants fournis, et de procéder à une mise à jour complète du système avant de commencer l'installation :

apt-get update && apt-get upgrade -y

Une fois la mise à jour finie, il est possible qu'un redémarrage soit nécessaire, le faire avec la commande reboot.

Après, il faut installer l'ensemble des éléments qui vont nous être utiles :

apt-get install -y apt-transport-https ca-certificates curl software-properties-common nano nginx fail2ban software-properties-common lsb-release certbot

Installation de Docker et Docker Compose

Il faut installer ensuite Docker, depuis le dépôt officiel :

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

$ 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

apt-get update && apt-get install docker-ce -y

Vérifier la version de Docker installée avec :

docker version

Vérifier le bon fonctionnement de Docker avec :

systemctl status docker

Une petite pastille verte doit apparaitre.

Ensuite, il va falloir installer Docker Compose :

apt-get install -y docker-compose

Préparation des volumes et des fichiers de configuration

Il faut créer des dossiers manuellement dans le répertoire home de l’utilisateur connecté (root ou ubuntu, selon les cas).

Il faut donc saisir les commandes suivantes :

mkdir user/monitoring/prometheus user/monitoring/blackbox_exporter user/monitoring/grafana

touch user/monitoring/prometheus/prometheus.yml user/monitoring/blackbox_exporter/blackbox.yml user/monitoring/grafana/grafana.ini

Une fois les fichiers de configuration créés, il va falloir les renseigner avezc la commande nano:

• Pour le fichier blackbox.yml :

modules:
  http_2xx:
    prober: http
    timeout: 5s
    http:
      valid_status_codes: [200]
      preferred_ip_protocol: "ip4"
      method: GET
      fail_if_body_matches_regexp:
       - "<boolean>false</boolean>"
       - "<boolean>DOWN</boolean>"

• Pour le fichier prometheus.yml :

global:
  scrape_interval:     10s
  evaluation_interval: 10s

scrape_configs:
  - job_name: 'serveurs'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
        - https://url1.fr
        - https://url2.fr
        - https://url3.fr
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: localhost:9115

• Pour le fichier grafana.ini, se servir de cet exemple ici.

Il faudra en modifier certaines valeurs relatives à l'installation, comme :

• dans la partie [server] le http_port = 3200
• le root_url par le nom de domaine précédemment enregistré
• le static_root_path = public
• le enable_gzip = true
• dans la partie [database] type = sqlite3
• path = /var/lib/grafana/grafana.db
• cache_mode = private
• dans la partie [users] allow_sign_up = false pour éviter la visite d'intrus, à désactiver ensuite si besoin
• dans la partie [auth.anonymous], on passe le enable anonymous access à enabled = false
• hide_version = true

Lancement du fichier Docker Compose

Il convient donc de créer le fichier docker-compose.yml qui va nous permettre de lancer la configuration complète :

nano docker-compose.yml

Puis coller le texte suivant :

version: '3'


services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    user: root
    volumes:
      - /home/ubuntu/monitoring/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - /home/ubuntu/monitoring/prometheus/prom/:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/usr/share/prometheus/console_libraries'
      - '--web.console.templates=/usr/share/prometheus/consoles'
      - '--web.enable-admin-api'
      - '--storage.tsdb.retention.time=60d'
    ports:
      - 9090:9090
    network_mode: "host"
    restart: always

  blackbox:
    image: prom/blackbox-exporter:latest
    container_name: blackbox_exporter
    volumes:
    - /home/ubuntu/monitoring/blackbox_exporter/blackbox.yml:/etc/blackbox_exporter/config.yml
    ports:
      - 9115:9115
    network_mode: "host"
    restart: always

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - /home/ubuntu/monitoring/grafana/lib/grafana/:/var/lib/grafana
      - /home/ubuntu/monitoring/grafana/grafana.ini:/etc/grafana/grafana.ini
    ports:
      - 3200:3200
    network_mode: "host"
    restart: always

Il faudra ensuite lancer la commande

docker compose up -d

Vérifier l'état des conteneurs avec :

docker compose ps

Il convient de vérifier les logs si besoin ou de modifier sa configuration selon les besoins.

Créez le proxy inverse Nginx

Si vous préférez utiliser un nom de domaine plutôt que de taper http://localhost:3200pour accéder à Grafana, vous devez configurer un reverse proxy. Nous pouvons utiliser Nginx à cet effet que nous avons précédemment installé.

Créez ensuite un fichier de configuration pour Grafana :

nano /etc/nginx/conf.d/grafana.conf

Y coller cette configuration :

server {
      listen 80;
      server_name grafana.exemple.fr;
      
      location / {
          proxy_pass http://127.0.0.1:3200;
          proxy_set_header Host $host;
          proxy_set_header X-Real-IP $remote_addr;
          proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
          proxy_set_header Upgrade $http_upgrade;
          proxy_set_header Connection "upgrade";

      }
}

Enregistrez et fermez ce fichier.

Rechargez Nginx pour que la modification prenne effet :

systemctl reload nginx

Activer le HTTPS

Pour chiffrer le trafic HTTP lorsque vous visitez le serveur Plex de l'extérieur, nous pouvons activer HTTPS en installant un certificat TLS gratuit émis par Let's Encrypt.

Exécutez ensuite la commande suivante pour obtenir et installer le certificat TLS :

certbot --nginx --agree-tos --redirect --hsts --staple-ocsp --email votre@email.fr -d grafana.exemple.fr

Le certificat doit maintenant être obtenu et installé automatiquement, vous pouvez accéder à l'interface Web Grafana via HTTPS.

Sécuriser le serveur

Une fois tout ça mis en place, il convient de le sécuriser avec Fail2Ban et UFW.

Pour UFW, voici la configuration à appliquer :

ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw enable

Il y aura un avertissement qui indique que la commande peut perturber les connexions SSH existantes. Une règle de pare-feu qui autorise les connexions SSH est présente, donc continuer.

Répondre à l’invite avec y et appuyez sur ENTER.

On s'attaque ensuite à Fail2ban :

nano /etc/fail2ban/jail.local

Ajouter le bloc suivant pour protéger le port SSH :

[sshd]
enabled = true
port = ssh
filter = sshd
maxretry = 3
findtime = 5m
bantime  = 30m

Puis redémarrer le service :

service fail2ban restart

Conclusion

Suivre ce tutoriel pas à pas pour élever l'infrastructure de supervision à un niveau supérieur, assurant ainsi une expérience utilisateur fluide et une réactivité optimale face aux incidents potentiels.

Maîtriser les tenants et aboutissants de la surveillance des sites web avec cette solution complète basée sur les technologies leaders du secteur.