Livebox Exporter pour Prometheus

Ayant récemment changé de fournisseur d’accès internet et (jusqu’à maintenant) heureux nouvel abonné Orange avec une Livebox 5, je me suis lancé dans un petit projet pour monitorer la qualité de mon accès internet avec Prometheus et Grafana.

Pour le contexte, je suis tombé un peu par hasard sur ce projet LiveboxMonitor d’un autre développeur français (cocorico!). Un bel outil fait en Python, qui fonctionne très bien mais c’est un client lourd avec une UI conçue pour être interactive. Grâce à ce projet, j’ai pu voir que l’API de la Livebox était facilement accessible.

Mon projet Livebox Exporter est donc un exporter pour Prometheus, conçu pour tourner en permanence.

Pour la visualisation, je me suis appuyé sur un dashboard Grafana également de mon cru.

Le programme en lui-même est donc très simple puisqu’il ne fait qu’exposer un endpoint standard /metrics qui retourne des métriques au format texte de Prometheus (pour cette partie, j’ai utilisé la librairie prometheus-net). Les métriques sont collectées en appelant l’API de la Livebox 5.

Les métriques remontées me permettent de connaître le débit maximum supporté par ma ligne fibre. Si je l’interprète bien, cela veut dire qu’en souscrivant à l’abonnement adéquat, je pourrai avoir un débit descendant de 2,49 Gb/s et ascendant de 1,24 Gb/s. Je peux également voir une estimation du débit en temps réel et sous forme d’historique, et constater que ma connexion peut monter jusqu’à 400 Mb/s qui correspond effectivement à mon abonnement actuel. Avoir cet historique comme base de comparaison me sera très utile si je ressens une perte de qualité de ma connexion internet dans le futur.

Une image vaut mille mots:

Dashboard Grafana

Utilisation

Bien sûr, cela suppose que vous ayez mis en place Prometheus.

Cela suppose également d’ajouter le mot de passe de votre Livebox dans les paramètres du programme. Vous pouvez tester sans mais l’intérêt sera très réduit car très peu de métriques seront alors accessibles.

Pour le déploiement de Livebox Exporter, des binaires sont téléchargeables sur GitHub. Une image Docker est également disponible.

Les paramètres du programme sont à mettre dans le fichier appsettings.json (essentiellement l’adresse IP de la Livebox et son mot de passe).

Une fois que le programme tourne, il suffit d’adapter la configuration de Prometheus:


  - job_name: 'livebox'
    scheme: http
    metrics_path: /metrics
    static_configs:
      - targets: ["localhost:9105"]

La valeur pour job_name est libre, vous pouvez mettre ce qui vous parle. L’important est scheme: http (sauf si votre configuration permet d’utiliser des requêtes https) et targets qui doit contenir le nom d’hôte du serveur et le port sur lequel envoyer la requête. Le paramètre metrics_path est inutile si sa valeur est celle par défaut /metrics mais je le spécifie ici pour montrer comment le personnaliser si vous utilisez un reverse proxy. Dans mon cas par exemple, j’ai dû utiliser metrics_path: /livebox/metrics en lien avec ma configuration nginx.

Déploiement sur Kubernetes

Dans mon cas, je déploie ce type d’applications sur un mini pc qui me sert de serveur applicatif avec un cluster mono-noeud K3s.

Je fournis ici les grandes lignes pour déployer sur Kubernetes mais votre setup peut varier du mien et vous devrez probablement adapter ces instructions. Dans mon cas, j’ai installé Prometheus sur le même serveur, mais pas dans K3s car cela m’a paru bien compliqué. Prometheus étant sur le même serveur que K3s, il peut collecter les métriques via une URL en localhost. J’utilise également un reverse proxy nginx, aussi dans un pod de K3s. Prometheus va donc collecter les métriques en passant par le serveur virtuel de nginx.

Contrairement à beaucoup d’applications serveur, ce programme supporte nativement un reverse proxy pour peu que les entêtes conventionnelles X-Forwarded-* soient incluses dans les requêtes. J’utilise le terme « nativement » car il n’y a pas de paramètre de configuration particulier pour régler cela dans le programme, tel qu’un préfixe.

Pour commencer, le mot de passe sous forme de secret et le déploiement:


apiVersion: v1
kind: Secret
metadata:
  name: livebox-exporter-secret
type: Opaque
stringData:
  admin-password: "YOUR PASSWORD"
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: livebox-exporter-deployment
  labels:
    app: livebox-exporter
spec:
  replicas: 1
  selector:
    matchLabels:
      app: livebox-exporter
  template:
    metadata:
      labels:
        app: livebox-exporter
    spec:
      volumes:
      - name: secret-volume
        secret:
          secretName: livebox-exporter-secret
      containers:
      - name: livebox-exporter
        image: eric1901/livebox-exporter
        volumeMounts:
        - name: secret-volume
          readOnly: true
          mountPath: "/var/secret/"
        env:
        - name: urls
          value: "http://*:9105"
        - name: Livebox__Host
          value: "192.168.1.1"
        - name: Livebox__PasswordFile
          value: "/var/secret/admin-password"

Pour exposer le endpoint directement à l’extérieur du cluster Kubernetes, utilisez un service de type NodePort:


apiVersion: v1
kind: Service
metadata:
  name: livebox-exporter-service
  labels:
    app: livebox-exporter
spec:
  type: NodePort
  selector:
    app: livebox-exporter
  ports:
  - name: http
    port: 9105
    protocol: TCP
    targetPort: 9105
    nodePort: 30080

Le endpoint sera accessible à Prometheus via l’URL http://IP-noeud-kubernetes:30080/metrics.

A contrario, si vous souhaitez comme moi passer par un reverse proxy qui est également dans un pod de Kubernetes, définissez un service de type ClusterIP:


apiVersion: v1
kind: Service
metadata:
  name: livebox-exporter-service
  labels:
    app: livebox-exporter
spec:
  type: ClusterIP
  selector:
    app: livebox-exporter
  ports:
  - name: http
    port: 9105
    protocol: TCP
    targetPort: 9105

Puis adaptez la configuration de votre reverse proxy pour qu’il redirige les requêtes vers http://livebox-exporter-service:9105. Par exemple ma configuration pour nginx est la suivante:


server {
    listen 80;
    server_name NOM-DE-VOTRE-SERVEUR;

    location /livebox {
        proxy_pass http://livebox-exporter-service:9105;
        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 X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Prefix /livebox;
    }
}

Mon reverse proxy nginx est exposé à l’extérieur de Kubernetes via un service de type NodePort sur le port 30080 qui redirige vers le port 80 du pod. Nginx va rediriger toute requête qui commence par le préfixe d’URL /livebox. Dans cette configuration particulière, l’URL à configurer dans Prometheus qui s’exécute sur le même serveur est: http://localhost:30080/livebox/metrics.