By Boris Mallach — 16 sept. 2026

Mettre en place un SIEM léger pour Ubiquiti Express 7

L'intérêt de l'observabilité réseau

Dans un réseau domestique avancé, l'observabilité permet de passer de la supposition à la certitude. Sans observabilité, un routeur est une boîte noire : la connexion est lente, mais on ne sait pas pourquoi ; des bots scannent le port 443, mais le pare-feu bloque silencieusement.

L'observabilité repose ici sur deux piliers complémentaires :

Les Logs (Événements via Vector et Loki) : Ils répondent à la question « Que s'est-il passé ? ». C'est la sécurité pure. Un événement ponctuel : une IP bloquée par le pare-feu, un administrateur qui modifie la configuration du réseau invité, un appareil qui se déconnecte du WiFi.
Les Métriques (Statistiques via Unpoller et Prometheus) : Elles répondent à la question « Quelle est la tendance ? ». C'est la performance. Le volume de données (Go) téléchargées par une machine, l'utilisation CPU du routeur, ou la température de l'équipement sur les dernières 24 heures.

Étape 1 : Préparation du serveur (Lignes de commande)

Créez l'arborescence des dossiers sur votre serveur Linux pour stocker les configurations et les données persistantes.

# 1. Création du dossier principal et des sous-dossiers
mkdir -p /opt/observability/{vector,prometheus,loki,grafana}
cd /opt/observability

# 2. Téléchargement de la base de données GeoIP (DB-IP Lite) pour Vector
wget https://download.db-ip.com/free/dbip-city-lite-2023-11.mmdb.gz
gunzip dbip-city-lite-2023-11.mmdb.gz
mv dbip-city-lite-2023-11.mmdb vector/geoip.mmdb

# 3. Attribution des droits (Loki et Grafana exigent des permissions spécifiques)
sudo chown -R 10001:10001 loki/
sudo chown -R 472:472 grafana/

Étape 2 : Fichiers de configuration

Créez le fichier de configuration pour Vector (le parseur de logs) :

nano vector/vector.yaml

sources:
  unifi:
    type: socket
    address: 0.0.0.0:1514
    mode: udp

enrichment_tables:
  geoip_table:
    type: mmdb
    path: /etc/vector/geoip.mmdb

transforms:
  process_logs:
    type: remap
    inputs:
      - unifi
    source: |-
      parsed, err = parse_regex(.message, r'(?P<cef>CEF:.*)')
      if err == null {
          cef_data, err_cef = parse_cef(parsed.cef)
          if err_cef == null {
              . = merge(., cef_data)
              ip = null
              if exists(.src) { ip = .src } else if exists(.sourceAddress) { ip = .sourceAddress }
              if ip != null {
                  geo, err_geo = get_enrichment_table_record("geoip_table", {"ip": ip})
                  if err_geo == null { .geo = geo }
              }
          }
      }

sinks:
  loki:
    type: loki
    inputs:
      - process_logs
    endpoint: http://loki:3100
    encoding:
      codec: json

Créez le fichier de configuration pour Prometheus (le collecteur de métriques) : nano prometheus/prometheus.yml

global:
  scrape_interval: 30s
scrape_configs:
  - job_name: 'unpoller'
    static_configs:
      - targets: ['unpoller:9130']

Étape 3 : Le fichier Docker Compose

Créez le fichier de déploiement à la racine du dossier /opt/observability.

nano docker-compose.yml

services:
  loki:
    image: grafana/loki:latest
    container_name: loki
    volumes:
      - ./loki:/tmp/loki
    restart: unless-stopped

  vector:
    image: timberio/vector:latest-alpine
    container_name: vector
    ports:
      - "1514:1514/udp" # Port d'écoute pour les logs du routeur
    volumes:
      - ./vector/vector.yaml:/etc/vector/vector.yaml:ro
      - ./vector/geoip.mmdb:/etc/vector/geoip.mmdb:ro
    restart: unless-stopped
    depends_on:
      - loki

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./prometheus/data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=30d'
    restart: unless-stopped

  unpoller:
    image: ghcr.io/unpoller/unpoller:latest
    container_name: unpoller
    environment:
      - UP_UNIFI_DEFAULT_URL=https://192.168.1.1 # IP du routeur UniFi
      - UP_UNIFI_DEFAULT_USER=unpoller
      - UP_UNIFI_DEFAULT_PASS=VotreMotDePasseSecret
      - UP_UNIFI_DEFAULT_SAVE_DPI=true
      - UP_INFLUXDB_DISABLE=true
      - UP_PROMETHEUS_HTTP_LISTEN=0.0.0.0:9130
    restart: unless-stopped
    depends_on:
      - prometheus

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - ./grafana:/var/lib/grafana
    restart: unless-stopped

Démarrez la stack :

docker compose up -d

Étape 4 : Configurations finales (UniFi et Grafana)

Sur le routeur UniFi :
- Allez dans les paramètres système de l'OS et créez un utilisateur administrateur local nommé unpoller avec des droits de lecture seule (Read Only).
- Allez dans les paramètres réseau (Network > Settings > System > Advanced) et activez Remote Syslog. Pointez vers l'adresse IP de votre serveur Docker sur le port 1514.
Dans Grafana (http://[IP_DU_SERVEUR]:3000) :
- Allez dans Connections > Data Sources.
- Ajoutez Loki avec l'URL http://loki:3100.
- Ajoutez Prometheus avec l'URL http://prometheus:9090.
- Importez vos tableaux de bord personnalisés pour Loki, et importez les ID 11311, 11314 et 11315 pour obtenir les statistiques d'Unpoller via Prometheus.

Pour vérifier que chaque étape s'est bien déroulée, consultez les journaux des conteneurs via Portainer ou la commande docker compose logs -f.

Conclusion : Maîtrise totale de l'infrastructure

En combinant l'analyse des logs et la collecte de métriques, ce déploiement transforme un équipement réseau en une véritable tour de contrôle. Le pare-feu de l'UniFi Express 7 n'agit plus dans l'ombre : chaque menace écartée laisse une trace visible, parsée et cartographiée en temps réel grâce à Vector et Loki.

En parallèle, l'ajout d'Unpoller et Prometheus comble le point aveugle majeur des journaux d'événements en révélant la consommation réelle de bande passante, appareil par appareil.

L'infrastructure gagne ainsi une couche d'observabilité digne des environnements professionnels, tout en restant entièrement auto-hébergée, sécurisée et centralisée sur vos écrans Grafana.

Vous n'avez plus besoin de deviner ce qui se passe sur le réseau local : vous avez désormais toutes les données en main pour diagnostiquer la moindre lenteur, isoler un équipement trop bavard, ou prouver l'efficacité de vos règles de blocage en un seul coup d'œil.