Performance et scalabilité Grafana
Base Postgres, cache Redis, requêtes bornées, rendu d'images et haute dispo : les réglages qui font tenir Grafana sous charge, et les pièges qui coûtent cher.
Grafana tient sans broncher un laboratoire de dix tableaux de bord. Il tombe à genoux le jour où trente personnes ouvrent le même dashboard « vue direction » à 9 h, avec un rafraîchissement à trente secondes. Sur mon instance de supervision, le passage de trois à vingt-huit utilisateurs n'a pas doublé la charge : il l'a multipliée par onze, et le CPU du conteneur n'était même pas le premier facteur.
Ce guide suit l'ordre réel des goulots : stockage d'abord, connexions ensuite, requêtes puis rendu, et enfin la haute disponibilité. Chaque section part d'une mesure, pas d'une intuition.
Le vrai goulot n'est pas le CPU
Grafana est un serveur Go qui rend du JSON et du HTML. Une instance à 2 vCPU encaisse très bien 200 requêtes par seconde sur des dashboards simples. Ce qui la tue, c'est le temps d'attente : base SQLite verrouillée, requêtes Prometheus lentes, rendu d'images PNG lancé toutes les minutes.
Première mesure à poser avant tout réglage : exposer /metrics de Grafana dans Prometheus, puis regarder trois séries. grafana_http_request_duration_seconds donne la latence par route, grafana_datasource_request_duration_seconds sépare le temps passé dans Grafana du temps passé dans la datasource, grafana_database_conn_* montre la pression sur la base.
scrape_configs:
- job_name: grafana
metrics_path: /metrics
static_configs:
- targets: ["grafana:3000"]Exemple concret : sur un dashboard à douze panneaux qui répondait en 4,2 s, grafana_datasource_request_duration_seconds pesait 3,9 s. Grafana n'était pas lent, Prometheus mettait quatre secondes à évaluer des requêtes sur trente jours. Aucun réglage Grafana n'aurait corrigé ça.
Mon avis tranché : avant d'ajouter de la RAM à Grafana, regarde le temps datasource. Dans neuf cas sur dix, la machine à agrandir est celle qui stocke les métriques, ou la requête à réécrire.
Sortir de SQLite et maîtriser les connexions
Par défaut, Grafana stocke utilisateurs, dashboards et alertes dans une base SQLite embarquée. Un seul écrivain à la fois, un fichier par instance : c'est parfait en local et inutilisable dès qu'il y a plusieurs instances ou beaucoup d'annotations concurrentes.
Selon la documentation officielle sur la haute disponibilité, il faut une base partagée MySQL ou Postgres. Le basculement se fait dans grafana.ini ou par variables d'environnement.
[database]
type = postgres
host = postgres:5432
name = grafana
user = grafana
password = $__file{/run/secrets/grafana_db}
ssl_mode = require
max_open_conns = 25
max_idle_conns = 10
conn_max_lifetime = 14400Le piège n'est pas le type de base, c'est le nombre de connexions. Chaque panneau qui interroge la base (recherche de dashboards, sessions, préférences) prend une connexion. Avec vingt instances et max_open_conns laissé à 0, tu ouvres des centaines de connexions jusqu'à saturer Postgres.
Règle de dimensionnement que j'applique : max_open_conns entre 15 et 30 par instance, et le total des instances multiplié par cette valeur doit rester sous max_connections de Postgres moins 30 % de marge. Sur un Postgres à 100 connexions, trois instances Grafana à 25 suffisent largement.
Pense aussi à la maintenance : les tables dashboard_version et annotation gonflent vite. versions_to_keep vaut 20 par défaut, ce qui est raisonnable, mais un VACUUM ou un autovacuum correctement réglé sur ces tables évite des requêtes de recherche qui passent de 60 ms à 2 s.
Redis comme second étage
Grafana met en cache les sessions, les requêtes de recherche de dashboards et certaines réponses de datasources. Par défaut, ce cache est en mémoire, donc propre à chaque instance : avec trois instances derrière un load balancer, tu triples le travail.
[cache]
type = redis
connstr = addr=redis:6379,db=0,pool_size=100
[caching]
enabled = trueLe gain est immédiat sur les déploiements multi-instances : la recherche de dashboards cesse d'interroger Postgres à chaque frappe dans la barre de recherche. Sur une instance unique, le cache mémoire fait déjà le travail et Redis ajoute un saut réseau — je ne le mets que quand il y a au moins deux instances.
Attention à un détail qui coûte cher en production : si Redis tombe, Grafana reste debout mais perd les sessions. Les utilisateurs connectés via OAuth sont renvoyés au fournisseur d'identité. Ce n'est pas une panne, c'est une vague de reconnexions à absorber — prévois la capacité côté IdP.
Les requêtes qui tuent un dashboard
Un dashboard mal écrit coûte plus cher que dix utilisateurs supplémentaires. Les trois causes que je rencontre, dans l'ordre : une requête sur trente jours sans agrégation, un rate() sur une métrique à forte cardinalité, des variables de template qui déclenchent une requête par valeur.
Exemple concret : une variable instance alimentée par label_values(up) sur un parc de 400 machines. À chaque ouverture du dashboard, Grafana interroge Prometheus, récupère 400 valeurs, puis rejoue chaque panneau pour la valeur sélectionnée. Passer la variable en label_values(up{job="api"}) ramène la liste à douze entrées et divise la latence par quatre.
Côté requête, la règle est simple : rate(...[5m]) puis max_over_time ou avg_over_time plutôt qu'un pas brut. Une courbe sur trente jours n'a pas besoin d'un point toutes les quinze secondes.
# lent sur 30 jours : 2 592 000 points bruts par série
rate(http_requests_total[15s])
# même information, 8 640 points
max_over_time(rate(http_requests_total[5m])[30d:5m])Les bonnes pratiques de dashboards de Grafana insistent sur un point que les équipes oublient : limiter le nombre de séries par panneau. Au-delà de cinquante séries, le navigateur devient le goulot avant le serveur. Un topk(10, ...) rend le panneau lisible et le rendu trois fois plus rapide.
Rendu d'images et alerting : les deux processes qui surprennent
Le rendu d'images (rapports PDF, alertes avec graphique, snapshots) lance un Chromium headless. Par défaut, cinq rendus simultanés, et chaque rendu peut consommer 300 Mo de RAM. C'est de très loin le poste le plus coûteux d'une instance Grafana.
[rendering]
server_url = http://renderer:8081/render
callback_url = http://grafana:3000/
concurrent_render_limit = 2Mon conseil : garde le renderer dans un conteneur séparé, avec sa propre limite mémoire, et descends concurrent_render_limit à 2. Un rapport quotidien de vingt graphiques n'a aucune raison de monopoliser la RAM dont l'interface a besoin à 9 h.
L'alerting unifié a sa propre limite, documentée dans la page haute disponibilité : toutes les instances évaluent toutes les règles, et seule la notification est dédupliquée. Pas de répartition de charge. Concrètement, avec trois instances, tu triple le coût d'évaluation de chaque règle.
Sur deux cents règles qui interrogent Prometheus toutes les minutes, ça fait six cents requêtes par minute au lieu de deux cents. La parade est côté stockage : des règles d'enregistrement Prometheus calculées une fois, que les alertes se contentent de comparer.
groups:
- name: slo
interval: 1m
rules:
- record: job:http_error_ratio:5m
expr: sum by (job) (rate(http_requests_total{code=~"5.."}[5m]))
/ sum by (job) (rate(http_requests_total[5m]))Passer à plusieurs instances sans casser l'alerting
L'architecture recommandée est active-active : deux instances ou plus, un reverse proxy qui répartit, une base partagée. Les sessions vivant en base, le load balancer n'a pas besoin d'affinité de session.
C'est exactement le rôle d'un reverse proxy bien réglé. Si tu héberges Grafana derrière Traefik, les timeouts d'EntryPoint et l'ordre des middlewares comptent autant que la configuration de Grafana elle-même — j'ai détaillé ces réglages dans Performance et scalabilité Traefik.
Deux points cassent une HA naïvement montée. Le premier : root_url doit être l'URL publique du cluster, pas l'URL de chaque nœud, sinon les liens d'alerte et les redirections OAuth pointent vers une instance précise. Le second : le hachage du secret de session doit être identique partout, sinon un utilisateur rebondit d'une instance à l'autre en perdant sa session.
[server]
domain = grafana.example.com
root_url = https://grafana.example.com/
[auth]
signout_redirect_url = https://sso.example.com/logout
cookie_samesite = lax
[unified_alerting]
ha_listen_address = 0.0.0.0:9094
ha_peers = grafana-1:9094,grafana-2:9094,grafana-3:9094Grafana Live, qui pousse les mises à jour en WebSocket, reste limité en HA. Si tu ne t'en sers pas, désactive-le : chaque connexion ouverte immobilise une goroutine et un buffer, et un dashboard en « live » sur cent postes coûte plus que tout le reste.
Quoi surveiller dans Grafana
Un Grafana qui se dégrade prévient toujours. Les quatre signaux qui comptent, avec un seuil de départ.
| Signal | Seuil d'alerte | Ce que ça annonce |
|---|---|---|
Latence p95 /api/ds/query | > 2 s | Requêtes trop larges ou datasource saturée |
| Connexions Postgres actives | > 80 % de max_open_conns | Fuite de connexions, pool sous-dimensionné |
| Rendus en file | > 30 s d'attente | Renderer sous-dimensionné ou limite trop haute |
| Durée d'évaluation des règles | > 50 % de l'intervalle | Alerting qui va manquer son créneau |
Le quatrième signal est le plus sous-estimé. Une règle qui prend 40 secondes dans un intervalle d'une minute finit par se chevaucher avec elle-même, et les alertes deviennent erratiques sans qu'aucune erreur n'apparaisse.
Pour la partie collecte et rétention, la question du stockage se pose vite : Prometheus local sur disque tient quelques semaines, au-delà il faut une solution distribuée. J'ai comparé les options open source dans les projets open source de supervision.
Plan de montée en charge par paliers
Voici l'ordre dans lequel j'applique les changements, du moins cher au plus cher. Chaque palier se mesure avant de passer au suivant.
| Palier | Charge visée | Action |
|---|---|---|
| 1 | Jusqu'à 10 utilisateurs | SQLite, cache mémoire, renderer désactivé |
| 2 | 10 à 50 utilisateurs | Postgres, concurrent_render_limit=2, requêtes réécrites |
| 3 | 50 à 200 utilisateurs | Deux instances, Redis, load balancer sans affinité |
| 4 | Au-delà | Trois instances et plus, alerting HA, stockage métriques distribué |
Exemple concret : une équipe bloquée au palier 2 avec 90 utilisateurs avait un p95 à 6 s. Le passage au palier 3 (deux instances, Redis, pool Postgres à 25) a ramené le p95 à 800 ms sans toucher aux dashboards. Le coût réel : un conteneur de plus et un Redis.
Les pièges qui coûtent cher
- Monter les ressources avant de mesurer. Doubler la RAM d'une instance dont le goulot est Prometheus ne change rien, sauf la facture.
- Laisser
max_open_connsà 0. Grafana ouvre alors autant de connexions que nécessaire et sature Postgres en silence. - Activer le renderer sur l'instance principale. Un rapport PDF peut faire grimper la RAM de 1 Go en quelques secondes.
- Oublier
root_urlen HA. Les liens d'alerte pointent vers un nœud précis et cassent au premier redéploiement. - Confondre latence Grafana et latence datasource. Le premier réflexe doit être de lire
grafana_datasource_request_duration_seconds. - Multiplier les variables de template dépendantes. Chaque variable ajoute une requête par panneau à chaque changement de valeur.
Un dernier réglage gratuit, souvent oublié : le rafraîchissement automatique. Un dashboard réglé sur 5 s pour trente utilisateurs produit 360 requêtes par minute. Passer à 30 s divise la charge par six et personne ne voit la différence sur une courbe de trafic.
Questions fréquentes
Grafana peut-il tourner sans base externe en production ?
Oui, tant qu'il n'y a qu'une instance et peu d'écritures. Dès qu'il faut deux nœuds ou plus, MySQL ou Postgres devient obligatoire, car SQLite ne se partage pas entre processus.
Faut-il Redis dès deux instances ?
Ce n'est pas obligatoire, mais sans Redis chaque instance recalcule ses caches. Sur un usage intensif de la recherche de dashboards, la différence se voit tout de suite sur la latence de Postgres.
Combien de dashboards un Grafana peut-il servir ?
Le nombre de dashboards stockés n'a presque aucun impact. Ce qui compte, c'est le nombre de panneaux affichés simultanément et le coût des requêtes qu'ils déclenchent.
Le cache de requêtes suffit-il à absorber la charge ?
Le cache de requêtes est une fonctionnalité Grafana Enterprise. En open source, la bonne réponse reste la règle d'enregistrement côté Prometheus ou Mimir : calculer une fois, lire souvent.