Monitoring OPNsense avec Grafana et InfluxDB : tableaux de bord temps réel

Pourquoi monitorer son firewall ?

Un firewall sans monitoring, c'est conduire les yeux bandés. Sur mon infra BOTUM, j'ai appris à la dure que les problèmes réseau les plus coûteux sont ceux qu'on ne voit pas venir : une saturation WAN silencieuse à 3h du matin, une tentative d'intrusion qui passe entre les mailles, un VLAN IoT qui génère 10x plus de trafic que la normale.

Le monitoring temps réel avec Grafana + InfluxDB m'apporte trois choses essentielles :

• Visibilité complète : voir en temps réel ce qui passe sur chaque interface, chaque VLAN, chaque tunnel VPN.
• Détection d'anomalies : identifier les comportements anormaux — spike de trafic, flood DNS, connexions vers des IPs suspectes.
• Conformité SLA : prouver la disponibilité (uptime), documenter les incidents réseau, mesurer la latence WAN.

Ce billet est le 9e et dernier de la Série Stack OPNsense. Vous avez déjà le firewall, les VLANs, le VPN, le WiFi, la protection IDS/IPS, le NAC et le DNS. Il ne manquait que les yeux.

Architecture de la stack monitoring

La stack que j'utilise est simple et éprouvée :

OPNsense (données brutes)
     ↓  plugin os-telegraf (collecte)
Telegraf (agent de métriques)
     ↓  HTTP/UDP vers port 8086
InfluxDB 2.x (base time-series)
     ↓  source de données Grafana
Grafana (visualisation + alerting)
     ↓  notifications
Email / Telegram / Slack

Chaque composant tourne dans un container Docker sur une VM Proxmox dédiée. J'alloue 2 vCPU + 2 Go RAM — largement suffisant pour une infra jusqu'à 1 Gbps de trafic agrégé.

Activer l'export InfluxDB dans OPNsense

Installer le plugin os-telegraf

# Dans OPNsense : System > Firmware > Plugins
# Chercher "telegraf" et installer : os-telegraf

# Ou via SSH dans OPNsense :
pkg install os-telegraf

Configurer Telegraf dans OPNsense

# Services > Telegraf > General
# Cocher : Enable Telegraf
# InfluxDB URL : http://PROXMOX-IP:8086
# Token : (généré dans InfluxDB)
# Bucket : opnsense
# Organization : botum

# Activer les collecteurs :
# ✓ Interfaces (trafic par interface)
# ✓ Firewall (règles, états)
# ✓ CPU / Memory / Disk
# ✓ Gateway (latence WAN)

Configuration telegraf.conf avancée

[agent]
  interval = "10s"
  flush_interval = "10s"

[[inputs.net]]
  interfaces = ["em0", "vtnet0", "igc0"]

[[inputs.cpu]]
  totalcpu = true

[[inputs.mem]]

[[inputs.system]]

[[inputs.netstat]]

[[outputs.influxdb_v2]]
  urls = ["http://192.168.1.x:8086"]
  token = "VOTRE-TOKEN-INFLUXDB"
  organization = "botum"
  bucket = "opnsense"
  timeout = "5s"

Installer InfluxDB 2.x en Docker sur Proxmox

Docker Compose — Stack monitoring complète

mkdir -p /opt/monitoring/{influxdb,grafana}
cd /opt/monitoring

cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  influxdb:
    image: influxdb:2.7
    container_name: influxdb
    restart: unless-stopped
    ports:
      - "8086:8086"
    volumes:
      - ./influxdb/data:/var/lib/influxdb2
      - ./influxdb/config:/etc/influxdb2
    environment:
      DOCKER_INFLUXDB_INIT_MODE: setup
      DOCKER_INFLUXDB_INIT_USERNAME: admin
      DOCKER_INFLUXDB_INIT_PASSWORD: BotumSecure2026!
      DOCKER_INFLUXDB_INIT_ORG: botum
      DOCKER_INFLUXDB_INIT_BUCKET: opnsense
      DOCKER_INFLUXDB_INIT_RETENTION: 90d

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - ./grafana:/var/lib/grafana
    environment:
      GF_SECURITY_ADMIN_PASSWORD: BotumSecure2026!
      GF_INSTALL_PLUGINS: grafana-clock-panel,grafana-worldmap-panel
    depends_on:
      - influxdb

EOF

docker compose up -d
echo "InfluxDB : http://PROXMOX-IP:8086"
echo "Grafana  : http://PROXMOX-IP:3000"

Générer le token InfluxDB

# Via l'interface web InfluxDB (http://IP:8086)
# Load Data > API Tokens > Generate API Token > All Access
# Copier le token (88 caractères)

# Ou via CLI :
docker exec influxdb influx auth create   --org botum   --all-access   --description "Telegraf OPNsense"

⚠️ Stockez le token dans votre gestionnaire de secrets (Vaultwarden). Il ne sera affiché qu'une seule fois.

Configurer Grafana avec InfluxDB

Ajouter la source de données InfluxDB

# Grafana → Configuration > Data Sources > Add Data Source
# Sélectionner : InfluxDB
# Query Language : Flux (pour InfluxDB 2.x)
# URL : http://influxdb:8086
# Organization : botum
# Token : VOTRE-TOKEN
# Default Bucket : opnsense
# Save & Test → "datasource is working. 1 buckets found"

Requête Flux de base — trafic WAN

from(bucket: "opnsense")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "net")
  |> filter(fn: (r) => r.interface == "em0")
  |> filter(fn: (r) => r._field == "bytes_recv" or r._field == "bytes_sent")
  |> derivative(unit: 1s, nonNegative: true)
  |> map(fn: (r) => ({ r with _value: r._value * 8.0 }))
  |> aggregateWindow(every: 30s, fn: mean, createEmpty: false)

Importer les dashboards OPNsense

La communauté Grafana propose d'excellents dashboards préconçus pour OPNsense :

• OPNsense Overview (ID: 13713) — Trafic WAN, CPU, mémoire, états firewall, gateways
• OPNsense Interfaces (ID: 14966) — Débit par interface, erreurs, paquets/sec
• OPNsense Firewall Rules (ID: 15413) — Hits par règle, connexions bloquées, géolocalisation IPs
• VLAN Traffic (personnalisé) — Trafic par VLAN, top clients, anomalies
• OPNsense VPN WireGuard (personnalisé) — Pairs connectés, trafic par tunnel, latence

# Import via Grafana UI :
# Dashboards > Import > Dashboard ID
# Dashboard ID 13713 → OPNsense Overview
# Data Source = InfluxDB (opnsense)

# Variables du dashboard :
# Bucket : opnsense
# Interfaces WAN : em0, vtnet0
# Interfaces LAN/VLAN : vtnet1, vtnet2, vtnet3...

Alerting Grafana : bande passante et connexions suspectes

Configurer un contact point Telegram

# Grafana → Alerting > Contact Points > Add Contact Point
# Type : Telegram
# Bot Token : votre token Telegram Bot
# Chat ID   : votre Chat ID
# Test → message Telegram reçu ✓

Alerte — saturation bande passante WAN

# Flux query :
from(bucket: "opnsense")
  |> range(start: -5m)
  |> filter(fn: (r) => r._measurement == "net" and r.interface == "em0")
  |> filter(fn: (r) => r._field == "bytes_sent" or r._field == "bytes_recv")
  |> derivative(unit: 1s, nonNegative: true)
  |> map(fn: (r) => ({ r with _value: r._value * 8.0 }))
  |> sum()

# Condition : avg() > 900000000 (900 Mbps) pendant 2 minutes
# Alerte → Telegram : "Saturation WAN détectée"

Alerte — connexions suspectes (spike)

from(bucket: "opnsense")
  |> range(start: -10m)
  |> filter(fn: (r) => r._measurement == "pf_state")
  |> filter(fn: (r) => r._field == "count")
  |> derivative(unit: 1m, nonNegative: true)
  |> mean()

# Condition : mean() > 5000 connexions/min
# Calibrer sur 1 semaine de trafic normal avant de fixer les seuils

Intégrer Suricata et AdGuard Home dans Grafana

Logs Suricata via Loki

# Ajouter dans docker-compose.yml :
  loki:
    image: grafana/loki:latest
    container_name: loki
    restart: unless-stopped
    ports:
      - "3100:3100"

  promtail:
    image: grafana/promtail:latest
    container_name: promtail
    volumes:
      - /var/log:/var/log:ro
      - ./promtail-config.yml:/etc/promtail/config.yml

# OPNsense : activer Suricata EVE JSON logs
# Intrusion Detection > Administration > Log to syslog : ON

# promtail-config.yml :
scrape_configs:
  - job_name: suricata
    static_configs:
      - targets: [localhost]
        labels:
          job: suricata
          __path__: /var/log/suricata/*.json

Métriques AdGuard Home via API REST

# Intégration Telegraf → InfluxDB :
[[inputs.http]]
  urls = ["http://192.168.1.x:3000/control/stats"]
  method = "GET"
  username = "admin"
  password = "VOTRE-MOT-DE-PASSE"
  data_format = "json"
  name_suffix = "_adguard"

# Requête Grafana :
from(bucket: "opnsense")
  |> range(start: -24h)
  |> filter(fn: (r) => r._measurement == "http_adguard")
  |> filter(fn: (r) => r._field == "dns_queries" or r._field == "blocked_filters")

Conclusion : récapitulatif de la série complète

Nous voici au bout de 9 billets qui construisent une infrastructure réseau enterprise complète à partir d'OPNsense sur Proxmox. Voici ce que vous avez maintenant :

• Billet 1 — OPNsense sur Proxmox : VM firewall haute performance, interfaces virtuelles
• Billet 2 — VLANs Zero-Trust : Segmentation LAN, IoT, DMZ, Guest — isolation complète
• Billet 3 — WireGuard VPN + SD-WAN LTE : VPN site-à-site, remote workers, failover 4G
• Billet 4 — WiFi + UniFi AP : Gestion APs, VLAN sans fil, portail captif
• Billet 5 — CrowdSec + Fail2ban : Protection collaborative, blocklists dynamiques
• Billet 6 — NAC FreeRADIUS 802.1X : Auth réseau, certificats, politique d'accès
• Billet 7 — Suricata IDS/IPS + DPI : Détection d'intrusion, prévention en ligne
• Billet 8 — AdGuard Home + DoH : Filtrage DNS, blocklists, DNS over HTTPS
• Billet 9 — Grafana + InfluxDB (vous êtes ici) : Monitoring temps réel, dashboards, alerting

Cette stack vous donne une infrastructure réseau que la plupart des PME à $50k/an de budget réseau ne possèdent pas — pour moins de $500 en matériel et $0 en licences logicielles.

Les prochaines étapes : la Série OpenClaw — automatisation de l'infra, agents intelligents, self-healing network. Restez connectés.

🔗 Hub de la série : OPNsense Stack Sécurité Enterprise sur Proxmox