Grafana : Tout savoir sur cette solution d’analyse de données

Avez-vous entendu parler de Grafana, la solution open source permettant d’effectuer des analyses et de surveiller nos systèmes en ligne ? Récemment, ses développeurs ont décidé d’abandonner la licence Apache 2.0 pour AGPLv3, une information marquante que vous connaissez sûrement.

Mais, savez-vous autre chose sur cette plateforme de visualisation de données ? Nous vous proposons cet article qui contient des réponses à toutes les questions que vous vous posez à ce sujet.

Qu’est-ce que Grafana et à quoi sert-il ?

Grafana est un outil open source d’analyse et de visualisation qui permet d’observer des systèmes grâce à des tableaux de bord personnalisables. Le projet, passé sous licence AGPLv3, offre une plateforme modulaire pour interroger, corréler et partager des données issues de multiples environnements. (Formation Data Analyst)

Grafana se connecte à toutes les sources de données possibles, communément appelées bases de données telles que Prometheus, ElasticSearch, MySQL, PostgreSQL, Graphite, Influx DB et OpenTSDB. L’outil vous aide à étudier, analyser et surveiller les données sur une période de temps (analyse de séries chronologiques) et à suivre le comportement des utilisateurs et des applications en production ou en pré‑prod.

L’un des grands avantages de Grafana est qu’il peut être déployé sur site, ou consommé en services managés avec Grafana Cloud et enrichi par Grafana Enterprise. La plateforme s’appuie sur un vaste écosystème de plugins et, dans le cloud, propose des fonctionnalités modernes d’assistance et d’optimisation qui facilitent la création de tableaux de bord et la réduction des données à faible valeur.

• Vue unifiée : visualiser métriques, logs et traces au même endroit, sans déplacer les données.
• Corrélation et diagnostic rapides : passer d’un indicateur à ses logs ou traces pour trouver la cause d’un incident.
• Alerting centralisé : créer des règles et notifier vos équipes sur Slack, PagerDuty ou d’autres canaux.
• Ouverture et extensibilité : centaines d’intégrations et plugins pour connecter vos outils existants.
• Déploiement flexible : OSS autohébergé, Cloud managé, ou Enterprise selon vos contraintes.

Positionnement dans l’observabilité (métriques, logs, traces)

L’observabilité moderne repose sur un triptyque complémentaire : métriques pour quantifier l’état, logs pour décrire les événements, traces pour suivre les appels distribués. Grafana agit comme une couche de visualisation et de corrélation par‑dessus vos stockages existants : Prometheus, Graphite ou InfluxDB pour les métriques, Loki ou Elasticsearch pour les logs, Tempo ou Jaeger pour les traces.

Signal	Ce que c’est	Rôle de Grafana
Métriques	Mesures numériques agrégées dans le temps (CPU, latence, taux d’erreur)	Interroger des TSDB (ex. Prometheus), visualiser, définir des alertes et corréler avec logs/traces
Logs	Événements textuels détaillés produits par applis et systèmes	Explorer et rechercher dans des backends de logs (ex. Loki, Elasticsearch), lier aux métriques
Traces	Parcours d’une requête à travers des services distribués	Visualiser des traces (ex. Tempo, Jaeger), relier une trace à ses métriques et logs

Architecture et composants clés

Grafana se compose d’un serveur applicatif avec interface web et API, d’un modèle de plugins et d’un mécanisme de connexion à des datasources externes. Les données d’observabilité restent dans vos systèmes ; Grafana les interroge à la volée et stocke seulement sa configuration interne.

• Serveur Grafana : UI de tableaux de bord, éditeur de requêtes, gestion des utilisateurs et des alertes.
• Sources de données : Prometheus, Elasticsearch, MySQL, PostgreSQL, Graphite, InfluxDB, OpenTSDB, etc.
• Plugins : extensions pour nouvelles sources, types de panneaux, notificateurs d’alertes.
• Grafana Agent : collecteur léger pour métriques, logs et traces qui envoie vers vos backends (ex. Prometheus, Loki, Tempo) ou vers Grafana Cloud.

Cas d’usage typiques

• Monitoring d’infrastructure : hôtes, conteneurs, Kubernetes, réseaux, bases de données.
• Suivi applicatif : APM, latences par service, corrélation métriques‑logs‑traces.
• KPI métier : taux de conversion, panier moyen, SLA/SLI/SLO partagés avec les équipes.
• IoT/temps réel : télémétrie d’équipements, alertes et vues géographiques.

Exemple : une hausse du temps de réponse est détectée sur un tableau de bord. En un clic, l’équipe passe aux logs du service impacté, puis ouvre la trace correspondante pour localiser le microservice en cause et rétablir rapidement le niveau de service.

Comparaisons rapides : Grafana vs Prometheus vs Kibana

Outil	Rôle principal	Stockage	Ingestion	Visualisation / Alerting
Grafana	Hub de visualisation et de corrélation multi‑sources	Ne stocke pas les télémétries, interroge des backends externes	Via collecteurs externes, Grafana Agent en option	Tableaux de bord riches, alerting multi‑sources
Prometheus	Collecte et stockage de métriques avec moteur de requêtes	TSDB intégrée ou remote write	Scraping HTTP d’exporters	Graphiques de base, alertes via Alertmanager, souvent visualisé dans Grafana
Kibana	Exploration et visualisation de données dans Elasticsearch, surtout logs	Données indexées dans Elasticsearch	Logstash/Beats ou Elastic Agent	Recherche, tableaux de bord et alertes de la suite Elastic

Que sont les tableaux de bord de Grafana ?

Un tableau de bord Grafana est une vue composée et réutilisable qui rassemble plusieurs panneaux sur une même grille pour raconter une histoire de vos données. Vous partez d’une ou plusieurs sources de données, vous assemblez des visualisations pertinentes, puis vous enregistrez cette vue pour la partager, la dupliquer et la faire évoluer.

Les tableaux de bord tirent des données d’une data source connectée telle que Graphite, Prometheus, Influx DB, ElasticSearch, MySQL, PostgreSQL, etc. Ce ne sont là que quelques-unes des nombreuses sources de données que Grafana prend en charge par défaut.

Ils proposent une large palette de visualisations (séries temporelles, statistiques, jauges, tableaux, cartes, heatmaps) pour explorer tendances, pics et anomalies sur des périodes choisies.

Chaque tableau de bord regroupe des panneaux configurés indépendamment, avec leurs requêtes, transformations, styles et interactions. Vous pouvez ensuite en faire des modèles, les décliner par environnement ou équipe, et garder une cohérence d’analyse.

Types de panels et visualisations

Voici les visualisations phares et quand les utiliser.

Visualisation	Quand l’utiliser
Time series	Suivre une métrique dans le temps, analyser tendances, saisonnalités, SLO, latence, taux d’erreur.
Stat	Mettre en avant une valeur clé (dernier point, min, max, moyenne, delta) pour un KPI.
Gauge	Visualiser un niveau par rapport à un seuil ou une capacité (CPU, saturation, taux d’utilisation).
Table	Explorer des séries et labels sous forme tabulaire, trier, filtrer, créer des Top N.
Bar gauge	Comparer rapidement des valeurs entre entités (instances, services) sur une même échelle.
Pie	Montrer une répartition par catégorie, parts relatives d’un total.
Heatmap	Analyser des distributions et densités, histogrammes dans le temps, latences par buckets.
Geomap (Geo)	Projeter des métriques sur une carte par région, site, IP géolocalisée.
Canvas	Composer des schémas et états personnalisés (flux, architectures) avec valeurs dynamiques.

Variables et templating

Les variables rendent un dashboard dynamique et réutilisable : vous filtrez par environnement, cluster, application, sans dupliquer le contenu. Elles s’affichent en en-tête comme menus déroulants et s’injectent dans requêtes, titres, liens et filtres.

Exemple simple : créez une variable env (valeurs : prod, preprod, dev) et une variable service alimentée par une requête sur votre source. Dans vos panneaux, utilisez-les dans les sélecteurs, par exemple {env= »$env », service= »$service »}. Le même tableau de bord s’adapte alors instantanément à plusieurs environnements.

Transformations, annotations et liens

• Transformations courantes : filtrer des valeurs nulles, regrouper et agréger par label (sum, avg, max), joindre ou fusionner des séries, pivoter un tableau, calculer un champ (erreurs/requêtes), renommer, trier, limiter.
• Annotations : ajouter des événements au-dessus des graphes (déploiements, incidents). Elles peuvent être saisies manuellement ou provenir d’une requête, pour contextualiser une variation.
• Liens et drilldowns : configurer des liens de panneau, de tableau de bord ou des data links pour ouvrir Explore, un autre dashboard ou une URL externe, en transmettant le temps et les variables actives.

Partage, snapshots et export

• Partager un lien direct qui respecte la plage de temps et les variables, avec option de lien court.
• Snapshots : générer un instantané statique d’un dashboard, partageable sans accès à la source, utile pour un audit ou une revue.
• Export : exporter un tableau de bord en JSON pour versionner ou réimporter, et exporter un panneau en PNG pour une documentation ou un ticket.

Provisioning, dossiers et permissions

Grafana supporte l’as-code : vous provisionnez sources de données, tableaux de bord et alertes via des fichiers de configuration. Cela facilite CI/CD, relectures et cohérence entre environnements.

• Dossiers : organisez les dashboards par domaine, équipe ou environnement pour garder une arborescence claire.
• Permissions : appliquez des droits fins au niveau dossier ou tableau de bord (viewer, editor, admin), avec gestion par équipes et, si besoin, intégration SSO.

Quelles sont les fonctionnalités offertes par Grafana ?

Grafana est une plateforme open source de tableaux de bord analytiques qui permet d’interroger, de visualiser et d’alerter sur vos données issues de nombreuses sources, sur site ou dans le cloud. Elle propose des visualisations riches, un éditeur de requêtes complet, des capacités de partage et de reporting, ainsi que des mécanismes de gouvernance robustes. Pour approfondir, consultez aussi les sections Tableaux de bord, Comment utiliser Grafana, Grafana Cloud et Grafana Enterprise.

• Visualisations et éditeur de requêtes : panneaux variés, mode Builder et Code, Explore, transformations.
• Partage, reporting et planification : liens, snapshots, exports, rapports planifiés selon l’édition.
• Permissions, RBAC et audit : rôles, équipes, dossiers, journaux d’audit pour une gouvernance maîtrisée.

Visualisations et éditeur de requêtes

Les panneaux de visualisation couvrent graphiques temporels, histogrammes, cartes de chaleur, jauges, tableaux, cartes géographiques et plus encore, afin de donner du sens à vos séries chronologiques. L’éditeur de requêtes propose deux approches complémentaires : Builder pour composer sans code et Code pour écrire la requête dans le langage natif de la source. Le mode Explore permet d’investiguer ad hoc, de comparer des plages temporelles ou de passer des métriques aux logs et traces. Les transformations servent à renommer, agréger, fusionner des jeux de données et calculer des champs dérivés. Des annotations et liens de données offrent un contexte supplémentaire et des parcours d’analyse.

• Bonnes pratiques de requêtage :
  • Commencer simple, filtrer tôt et limiter les séries retournées pour préserver les performances.
  • Standardiser les labels et les noms de métriques pour faciliter les regroupements et comparaisons.
  • Utiliser des variables et des plages dynamiques afin de rendre les tableaux de bord réutilisables.
  • Centraliser les transformations fréquentes pour éviter la duplication de logique.
  • Valider chaque étape en Explore avant d’intégrer au tableau de bord.

  Partage, reporting et planification

  Grafana facilite la diffusion des insights auprès des équipes. Vous pouvez partager des liens directs vers un tableau de bord ou un panneau, créer des snapshots pour figer un état à un instant T, ou exporter en CSV/JSON/PNG selon le contexte. Les alertes se déclenchent lorsqu’un seuil est atteint et notifient vos canaux d’équipe, par exemple Slack ou d’autres outils de communication. En éditions Cloud et Enterprise, des fonctionnalités de reporting planifié permettent d’envoyer des rapports périodiques par e‑mail, avec rendu d’images ou PDF, et d’automatiser la distribution aux parties prenantes.

  • Partage : liens, snapshots publics ou signés, intégration embarquée si nécessaire.
  • Exports : CSV/JSON pour l’analyse, images pour les présentations.
  • Reporting : rapports programmés selon l’édition, mise en forme cohérente avec le tableau de bord.
  • Alerting : règles visuelles, regroupements et envois vers Slack et autres outils d’astreinte.

  Permissions, RBAC et audit

  La plateforme propose un RBAC clair avec des rôles au niveau de l’organisation, des équipes pour regrouper les utilisateurs, et des permissions fines sur les dossiers et tableaux de bord. En environnements avancés, les journaux d’audit et l’intégration SSO/OAuth/SAML simplifient la conformité et le contrôle d’accès. L’objectif est de partager largement les données tout en prévenant les modifications non souhaitées.

  • Bonnes pratiques de gouvernance :
    • Appliquer le moindre privilège et séparer Viewer, Editor et Admin selon les besoins.
    • Structurer par dossiers thématiques et gérer les droits au niveau dossier pour simplifier l’administration.
    • Gérer l’accès par équipes plutôt qu’utilisateur individuel.
    • Activer et revoir régulièrement les logs d’audit en contexte Enterprise.
    • Standardiser les conventions de nommage et la revue des tableaux de bord avant publication.
    Découvrir le métier de Data Analyst

    Comment utiliser Grafana ?

    

    Comme toutes les plateformes de visualisation de données, Grafana s’articule autour de deux fonctions essentielles qui aident les entreprises à répondre à des questions sur les utilisateurs et les événements :

    1. Connecter une source de données (Prometheus, Elasticsearch, MySQL, PostgreSQL…).
    2. Créer un dashboard et y ajouter des panels pertinents.
    3. Définir des variables pour filtrer dynamiquement.
    4. Mettre en place une alerte simple pour valider la chaîne de supervision.
    5. Partager ou exporter le dashboard pour collaborer.
    6. Appliquer les bonnes pratiques pour faciliter l’exploitation au quotidien.

    Ajouter une source de données

    1. Ouvrez Grafana puis allez dans Paramètres > Data sources > Add data source.
    2. Choisissez votre moteur, par exemple Prometheus ou Elasticsearch.
    3. Renseignez l’URL de la source (exemples : http://prometheus:9090, https://mon-es:9200) et l’authentification si nécessaire (token, basic auth, en-têtes).
    4. Optionnel en déploiement Docker ou Kubernetes : stockez les secrets et paramètres sensibles sous forme de variables d’environnement ou de secrets de la plateforme, et référencez-les dans votre procédure de provisioning.
    5. Cliquez sur Save & test pour vérifier la connectivité et la latence de réponse.

    Astuce pratique : commencez par une seule source de données, validez vos champs et séries, puis ajoutez d’autres connecteurs à mesure que votre besoin s’élargit.

    Créer un premier dashboard et des panels

    1. Allez dans Dashboards > New > New dashboard.
    2. Ajoutez un panel : New panel, sélectionnez la data source et écrivez la requête.
    3. Choisissez une visualisation adaptée (Time series, Stat, Bar chart, Heatmap, Table…).
    4. Réglez l’axe de temps, les unités, les seuils de couleur, le titre du panel.
    5. Répétez pour 3 à 5 panels clés afin d’obtenir une vue d’ensemble utile.
    6. Enregistrez le dashboard dans un dossier partagé.

    Exemple : avec Prometheus, un panel Time series sur rate(http_requests_total[5m]) pour visualiser le débit de requêtes, plus un panel Stat pour le taux d’erreurs sum(rate(http_requests_total{code=~"5.."}[5m])).

    Créer des variables pour filtrer

    1. Dans votre dashboard > Settings > Variables > Add variable.
    2. Variable Query : interrogez la source pour lister des valeurs. Exemple Prometheus : label_values(job) ou label_values(http_requests_total, job).
    3. Variable Custom : renseignez des valeurs fixes, par exemple prod,preprod,staging.
    4. Variable orientée labels : construite via une requête qui retourne les valeurs d’un label (service, env, cluster) pour alimenter un menu déroulant.
    5. Activez Multi-value si vous souhaitez filtrer sur plusieurs éléments à la fois.

    Exemple d’utilisation dans une requête : sum by (job) (rate(http_requests_total{env="$env", job=~"$job"}[5m])). Les variables $env et $job sont alors pilotées par vos menus en haut du dashboard.

    Mettre en place une alerte simple

    1. Allez dans Alerting > Contact points et créez un canal de notification (Email, Slack, Webhook).
    2. Dans votre panel critique, cliquez sur Alert > Create alert rule.
    3. Définissez la condition, par exemple : moyenne du débit d’erreurs > 1 pendant 5 minutes.
    4. Choisissez la fréquence d’évaluation et le dossier d’alertes, puis associez le contact point via la notification policy.
    5. Testez l’envoi pour valider de bout en bout.

    Cas concret : alerte si sum(rate(http_requests_total{code=~"5.."}[5m])) > 0.5 pendant 5 minutes, notification vers Slack et Email.

    Partager et exporter un dashboard

    • Lien interne : Share > Link, conservez la plage de temps et les variables.
    • Snapshot : capture statique partageable sans accès à la source de données.
    • Lien public si l’option est autorisée par l’administrateur.
    • Export JSON du dashboard pour versionner et réimporter.
    • PNG d’un panel si le rendu d’images est activé sur l’instance.

    Pratique : exportez le JSON dans votre dépôt Git afin de tracer l’historique des évolutions du tableau de bord.

    Bonnes pratiques d’exploitation

    • Nommage clair : préfixes d’équipe, environnement et service.
    • Dossiers par domaine applicatif, avec droits adaptés.
    • Panneaux réutilisables via Library panels.
    • Tagging des dashboards pour faciliter la recherche.
    • Variables : privilégiez des labels discriminants et des valeurs par défaut utiles.
    • Performance : limitez le nombre de séries affichées, ajoutez de l’agrégation côté requête.
    • Revue régulière des alertes et seuils à chaque release importante.

    En suivant ce parcours, vous obtenez rapidement un premier tableau de bord exploitable, extensible à d’autres équipes et environnements.

    Se former à la Data et à l'IA

    Comment installer Grafana ?

    Avant de lancer l’installation, cadrez votre contexte pour choisir la bonne méthode :

    • Poste local ou serveur unique : paquets système Linux, installeur Windows, ou binaire autonome.
    • Conteneur sur machine unique : image Docker ou Docker Compose.
    • Cluster Kubernetes : chart Helm ou opérateur pour gérer Grafana en mode déclaratif.

    Contexte	Méthode	Points forts	À surveiller
    Linux (Debian/Ubuntu)	Depot APT officiel	Mises à jour via apt, service systemd	Clé GPG et dépôt à ajouter
    Linux (RHEL/Fedora)	Dépôt RPM officiel	Mises à jour via dnf/yum, service systemd	Fichier .repo à créer
    Windows	MSI ou binaire	Installation guidée, service possible	Port 3000, droits réseau
    Conteneur	Docker / Compose	Démarrage rapide, portabilité	Volumes persistants, variables secrètes
    Kubernetes	Helm / Opérateur	Déploiement IaC, MAJ contrôlées	Valeurs Helm, stockage persistant, RBAC

    Options d’installation (packages OS, Docker, Kubernetes/Helm)

    Packages OS (Debian/Ubuntu, RHEL/Fedora, Windows)

    1. Debian/Ubuntu (APT) :

       sudo apt-get install -y apt-transport-https wget gnupg
       sudo mkdir -p /etc/apt/keyrings
       sudo wget -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
       echo "deb [signed-by=/etc/apt/keyrings/grafana.asc] https://apt.grafana.com stable main" | \
         sudo tee /etc/apt/sources.list.d/grafana.list
       sudo apt-get update
       sudo apt-get install grafana   # ou grafana-enterprise
       

       Installe ensuite le service grafana-server et permet les mises à jour via APT. ([grafana.com](https://grafana.com/docs/grafana/latest/installation/debian/))

    2. RHEL/Fedora (RPM) :

       wget -q -O gpg.key https://rpm.grafana.com/gpg.key
       sudo rpm --import gpg.key
       sudo tee /etc/yum.repos.d/grafana.repo <<'EOF'
       [grafana]
       name=grafana
       baseurl=https://rpm.grafana.com
       repo_gpgcheck=1
       enabled=1
       gpgcheck=1
       gpgkey=https://rpm.grafana.com/gpg.key
       sslverify=1
       sslcacert=/etc/pki/tls/certs/ca-bundle.crt
       EOF
       sudo dnf install grafana   # ou grafana-enterprise
       

       Le dépôt officiel rpm.grafana.com fournit les paquets et mises à jour. ([grafana.com](https://grafana.com/docs/grafana/latest/installation/rpm/))

    3. Windows :
       1. Téléchargez l’installateur MSI depuis la page Download, lancez-le puis ouvrez http://localhost:3000.
       2. Alternativement, décompressez le ZIP et démarrez grafana-server.exe, ou installez en service avec NSSM si besoin.

       Détails et précisions sur le changement de port et le fichier custom.ini dans la documentation Windows. ([grafana.com](https://grafana.com/docs/grafana/tutorials/iis/index.md/installation/windows/))

       Docker et Docker Compose

       1. Image unique (édition recommandée Enterprise gratuite) :

          docker run -d -p 3000:3000 --name=grafana \
            -v grafana-data:/var/lib/grafana \
            -e GF_SECURITY_ADMIN_PASSWORD='MotDePasseFort' \
            grafana/grafana-enterprise
          

          Depuis Grafana 12.4, utilisez grafana/grafana (OSS) ou grafana/grafana-enterprise, le dépôt grafana/grafana-oss n’est plus mis à jour. ([grafana.com](https://grafana.com/docs/grafana/latest/setup-grafana/installation/docker/?plcmt=products-nav))

       2. Compose minimal :

          services:
            grafana:
              image: grafana/grafana-enterprise
              container_name: grafana
              restart: unless-stopped
              ports: ["3000:3000"]
              volumes:
                - grafana-data:/var/lib/grafana
          volumes:
            grafana-data: {}
          

          Montez un volume pour persister la base SQLite et la configuration. ([grafana.com](https://grafana.com/docs/grafana/latest/setup-grafana/installation/docker/?plcmt=products-nav))

       Le dépôt Docker Hub officiel publie aussi l’image OSS si vous préférez rester 100 % open source. ([hub.docker.com](https://hub.docker.com/r/grafana/grafana/))

       Kubernetes : Helm et opérateurs

       1. Helm (chart communautaire officiel) :

          helm repo add grafana-community https://grafana-community.github.io/helm-charts
          helm repo update
          kubectl create namespace monitoring
          helm install my-grafana grafana-community/grafana -n monitoring
          # Récupérer le mot de passe admin :
          kubectl get secret -n monitoring my-grafana -o jsonpath="{.data.admin-password}" | base64 --decode; echo
          

          Le chart fournit les notes d’accès et peut activer un PVC pour la persistance via values.yaml. ([grafana.com](https://grafana.com/docs/grafana/latest/installation/helm/))

       2. Opérateur Grafana :

          # Installation en cluster-scoped via Kustomize
          kubectl apply -f \
            https://github.com/grafana/grafana-operator/releases/latest/download/kustomize-cluster_scoped.yaml
          

          L’opérateur gère Grafana, datasources et dashboards via des CRD, et s’installe aussi via Helm. ([grafana.com](https://grafana.com/docs/grafana/latest/as-code/infrastructure-as-code/grafana-operator/?utm_source=openai))

       Formation Data Analyst certifiante

       Configuration initiale et provisioning

       • Fichier de configuration : sur Linux, éditez /etc/grafana/grafana.ini ; sur Windows, dupliquez conf/sample.ini en conf/custom.ini. Paramètres clés : [server] (http_port, root_url, protocol), [database] (sqlite3, mysql, postgres), [security]. ([grafana.com](https://grafana.com/docs/grafana/latest/administration/configuration/?utm_source=openai))
       • Variables d’environnement : toute clé grafana.ini peut être surchargée en GF_SECTION_KEY. Pour les secrets, utilisez les variantes GF_SECTION_KEY__FILE avec Docker ou Kubernetes Secrets. Exemple : GF_SECURITY_ADMIN_PASSWORD__FILE=/run/secrets/admin_password. ([grafana.com](https://grafana.com/docs/grafana/latest/setup-grafana/configure-docker/?utm_source=openai))
       • Provisioning as code : déposez des YAML dans /etc/grafana/provisioning/ (datasources/, dashboards/). Les datasources (Prometheus, Elasticsearch, MySQL, PostgreSQL, InfluxDB, etc.) et les dashboards JSON sont chargés au démarrage et versionnables. ([grafana.com](https://grafana.com/docs/grafana/latest/administration/provisioning/?utm_source=openai))

       Sécurité et authentification

       Au premier accès (http://hôte:3000), connectez-vous avec admin/admin puis changez immédiatement le mot de passe. Activez ensuite l’authentification d’entreprise selon votre SSO (LDAP, OAuth2/OIDC, SAML en Enterprise/Cloud). Sécurisez l’UI en HTTPS et appliquez une politique TLS moderne. ([grafana.com](https://grafana.com/docs/grafana/latest/setup-grafana/sign-in-to-grafana/?utm_source=openai))

       • Activer HTTPS : dans [server], définissez protocol=https, cert_file et cert_key, et fixez min_tls_version sur TLS1.2 ou TLS1.3. ([grafana.com](https://grafana.com/docs/grafana/latest/setup-grafana/set-up-https/?utm_source=openai))
       • Comptes et mots de passe : changez l’admin par défaut, désactivez l’inscription anonyme si inutile, stockez les secrets via variables ou fichiers montés. ([grafana.com](https://grafana.com/docs/grafana/latest/setup-grafana/sign-in-to-grafana/?utm_source=openai))
       • SSO et répertoires : configurez LDAP, OAuth2/OIDC (Azure AD, Google, GitHub, GitLab, Okta), SAML selon votre édition et votre IdP. ([grafana.com](https://grafana.com/docs/grafana/latest/setup-grafana/configure-security/configure-authentication/?utm_source=openai))
       • Durcissement : masquez la version, limitez l’iframe embedding, forcez HTTPS, révisez les rôles et permissions. ([grafana.com](https://grafana.com/docs/grafana/latest/setup-grafana/configure-security/configure-security-hardening/?utm_source=openai))

       Sauvegarde, migration et mises à jour

       1. Sauvegarder régulièrement :
          • Base de données : par défaut, SQLite dans /var/lib/grafana/grafana.db (copie à froid). Pour MySQL/PostgreSQL, réalisez des dumps cohérents. ([grafana.com](https://grafana.com/docs/grafana/latest/administration/back-up-grafana/?plcmt=products-nav&utm_source=openai))
          • Configs : grafana.ini/custom.ini, dossiers provisioning/ et éventuels volumes Docker ou PVC. ([grafana.com](https://grafana.com/docs/grafana/latest/administration/back-up-grafana/?plcmt=products-nav&utm_source=openai))
          • Dashboards : exportez en JSON pour portabilité ou automatisation CI/CD. ([grafana.com](https://grafana.com/docs/grafana/latest/dashboards/export-import/?utm_source=openai))
       2. Tester les mises à jour :
          • Lisez le guide d’upgrade de votre version majeure, puis mettez à jour Grafana via votre gestionnaire de paquets, image Docker ou chart Helm. Après upgrade, mettez à jour tous les plugins : grafana cli plugins update-all. ([grafana.com](https://grafana.com/docs/grafana/latest/upgrade-guide/upgrade-v13.0/))
          • Sur Docker : arrêtez le conteneur, mettez l’image à jour et relancez en réutilisant le volume de données. ([grafana.com](https://grafana.com/docs/grafana/latest/upgrade-guide/upgrade-v13.0/))
       Se former au Machine Learning

       Conséquences et risques : une mise à niveau majeure peut introduire des changements incompatibles ou des migrations de stockage. Vérifiez la compatibilité des plugins et sauvegardez la base avant toute opération : en cas de problème, la restauration préalable est indispensable. ([grafana.com](https://grafana.com/docs/grafana/latest/upgrade-guide/upgrade-v13.0/))

       Quelles sources de données et intégrations supporte Grafana ?

       Grafana se connecte à toutes les sources de données possibles, communément appelées bases de données telles que Prometheus, ElasticSearch, MySQL, PostgreSQL, Graphite, Influx DB ou OpenTSDB. Vous pouvez ajouter des connecteurs natifs ou des plugins, puis interroger, visualiser et corréler métriques, logs et traces au sein d’un même espace d’observabilité.

       Connexion type : Configuration > Data sources > choisir l’intégration > renseigner l’URL/instance, l’authentification, puis Save & test. Les tableaux ci‑dessous résument les grandes familles d’intégrations.

       Catégorie	Exemples	Comment les connecter
       Métriques	Prometheus, Mimir, InfluxDB, Graphite	URL HTTP de l’API, schéma d’authentification (token, basic), espaces/projets selon le moteur, vérification via Save & test.
       Logs	Loki, Elasticsearch, OpenSearch	Point d’entrée de la stack de logs, index ou labels, authentification adaptée (token, basic, API key).
       Traces	Tempo, Jaeger, Zipkin	Instance de traçage, format OTLP/Jaeger/Zipkin, mappage des champs de corrélation (traceID, service, span).
       SQL et data apps	MySQL, PostgreSQL, BigQuery, Snowflake	Chaîne de connexion, utilisateur dédié en lecture, sélection du mode séries temporelles, macros de temps Grafana.
       Clouds et managés	AWS CloudWatch, Azure Monitor, Google Cloud Monitoring	Connecteur natif, authentification cloud (SigV4, Azure AD, compte de service), choix région/projet, limites d’API.

       Metrics : Prometheus, Mimir, InfluxDB, Graphite

       Source	Scénarios	Authentification	Particularités de requêtes
       Prometheus	Monitoring Kubernetes, services applicatifs, alerting par règles.	Aucune, basic ou bearer token selon l’instance; TLS conseillé.	PromQL, sélection par labels, rate(), histogram_quantile(), exemplaires pour corréler vers les traces.
       Mimir	Stockage longue durée, multi‑tenant, agrégation centralisée de métriques Prometheus.	Basic ou bearer token, entête tenant/organisation.	PromQL compatible, même ergonomie Grafana que Prometheus.
       InfluxDB	Séries temporelles IoT, infra et applicatives.	InfluxDB 2.x par token (org, bucket), 1.x par utilisateur/mot de passe.	Flux (2.x) ou InfluxQL (1.x), fonctions d’aggregateWindow/downsampling, gestion de _time et _value.
       Graphite	Métriques système héritées, rollups.	Souvent sans auth côté render API, sinon basic/TLS en frontal.	Fonctions Graphite, jokers hiérarchiques, importance des règles de rétention/agrégation.

       • Bonnes pratiques : limiter la cardinalité des labels, activer le cache des requêtes, agréger côté serveur quand c’est possible.

       Logs : Loki, Elasticsearch, OpenSearch

       • Loki : requêtes LogQL combinant sélecteurs de labels et filtres de contenu. Exemples de labels utiles : {app="api", env="prod"}, puis filtres |= "error", != "health". Pipelines | json pour parser et agréger (count_over_time()).
       • Elasticsearch / OpenSearch : requêtes en syntaxe Lucene ou DSL JSON. Utiliser le champ temps (souvent @timestamp), des filtres termes/plages et des agrégations. Exemple simple : status:[500 TO 599] AND "error" avec un filtre d’intervalle temporel côté tableau de bord.
       • Conseils communs : normaliser les labels/champs (service, env, traceID), limiter les jokers coûteux, préférer des filtres précis et des sauvegardes de requêtes réutilisables.

       Exemple rapide de diagnostic : vous partez d’un panneau métrique montrant une hausse de 5xx, vous ouvrez Explore, appliquez les mêmes labels dans Loki ({app="api", env="prod"}) et filtrez |= "stacktrace" pour isoler la cause.

       Traces : Tempo, Jaeger, Zipkin

       Grafana permet de naviguer des métriques vers les traces et inversement. Avec Tempo comme backend, les exemplaires depuis Prometheus affichent des liens directs vers les traces. Les intégrations Jaeger et Zipkin exposent services, opérations, spans, cartes de services et caractéristiques comme la latence p95, les taux d’erreur ainsi que les attributs de spans. Les corrélations reposent sur des identifiants partagés (traceID, spanID) et des labels communs (service, pod, région), ce qui permet de recouper métriques, logs et traces dans une même enquête.

       Cas concret : un pic de latence API est observé sur un panneau Prometheus. Depuis ce panneau, vous ouvrez une trace Tempo associée par exemplaire. Le waterfall révèle un appel SQL lent dans un service en aval. En un clic, vous passez aux logs de ce service, filtrés par le même traceID, pour inspecter la requête et la corriger.

       SQL et data apps : MySQL, PostgreSQL, BigQuery, Snowflake

       Ces connecteurs servent autant à la visualisation de séries temporelles via SQL qu’à des vues agrégées métier. Les requêtes s’appuient sur les macros Grafana pour le temps ($__timeFilter(), $__timeGroup()) et des champs horodatés normalisés.

       • Limitations fréquentes : coût unitaire des requêtes analytiques (BigQuery, Snowflake), latence de résultats, contraintes de quotas.
       • Optimisations recommandées :
         • Créer des vues matérialisées/agrégations par pas de temps (1 min, 5 min) pour les tableaux de bord.
         • Indexer/partitionner par date et par clés de filtrage usuelles (projet, service, région).
         • Sélectionner uniquement les colonnes nécessaires, définir des bornes de temps explicites avec $__timeFrom/$__timeTo.
         • Paramétrer des variables de tableau de bord pour réutiliser les filtres et limiter le balayage.
         • Activer le cache des résultats côté Grafana et côté moteur quand disponible.
         Se former à la Data et à l'IA

         Clouds et services managés : AWS, Azure, GCP

         • AWS CloudWatch : authentification Signature v4 via clés IAM, rôles ou profils; choix région/compte; métriques parfois décalées de quelques minutes et limites d’API à respecter.
         • Azure Monitor : authentification via Azure AD (application, secret ou identité managée); sélection abonnement/groupe de ressources; temps d’ingestion variable selon le type de signal.
         • Google Cloud Monitoring : compte de service JSON avec rôles minimums; sélection projet et filtres de métriques; alignement et fenêtrage à configurer pour des pas de temps stables.

         Comparaison rapide : les trois connecteurs sont natifs et couvrent métriques, journaux et parfois traces. Ils imposent des quotas et une latence d’ingestion non nuls, ce qui encourage l’agrégation côté source et des fenêtres d’observation adaptées dans Grafana afin de garantir des tableaux de bord réactifs.

         Comment fonctionne l’alerting dans Grafana ?

         Grafana propose un alerting unifié : un seul moteur pour créer, évaluer et router toutes vos alertes, quelles que soient les sources de données (métriques, logs, traces). Les règles sont centralisées, les notifications passent par des contact points et des politiques de routage, et le bruit est réduit grâce aux silences et aux fenêtres de mise en sourdine. Des alertes sont mises en place et déclenchées lorsqu’un scénario anticipé se produit, ces événements peuvent être notifiés sur Slack ou toute autre plateforme de communication utilisée par l’équipe de surveillance.

         • Un seul endroit pour gérer règles, canaux de notification et politiques.
         • Évaluations côté serveur à intervalle régulier, indépendantes des tableaux de bord.
         • Étiquettes et annotations pour contextualiser, regrouper et router les alertes.
         • Silences et fenêtres de maintenance pour couper le bruit au bon moment.
         • Historique d’état, prévisualisation et journaux d’évaluation pour diagnostiquer rapidement.

         Règles d’alerte et évaluations

         • Conditions : une règle évalue le résultat d’une ou plusieurs requêtes (seuil, absence de données, comparaison, réduction sur une fenêtre mobile) et passe par les états OK, Pending puis Firing après une durée for définie.
         • Groupes d’évaluation : regroupez les règles qui partagent le même rythme d’exécution pour optimiser les performances et garantir une cohérence d’évaluation.
         • Intervalles : chaque règle ou groupe possède un intervalle d’évaluation (par exemple toutes les 1 minute). Les comportements no data et error sont configurables.
         • Contexte : ajoutez des labels (service, environnement, gravité) et des annotations (résumé, liens de runbook) pour faciliter le tri et l’escalade.

         Exemple : “CPU > 80 % pendant 5 minutes” sur vos nœuds. La règle s’exécute toutes les 60 secondes dans un groupe infra. Elle ajoute les labels service=api, env=prod, severity=high et une annotation vers le runbook. Si l’évaluation échoue, l’état error est explicite et n’envoie pas de faux positifs.

         Canaux de notification

         • Email : simple, efficace pour les résumés et les équipes asynchrones.
         • Slack : envoi vers un canal dédié, avec regroupement et fichiers joints si besoin.
         • Microsoft Teams : cartes adaptatives et mentions d’équipes.
         • PagerDuty : prise en charge des astreintes et de l’escalade en temps réel.
         • Webhook : intégration personnalisée vers vos systèmes internes ou ITSM.

         Bonnes pratiques de routage : configurez des contact points par équipe, puis utilisez des politiques de notification pour router selon des labels clés (par exemple env, service, severity). Groupez par service pour éviter le spam, fixez un délai d’agrégation initial, puis une répétition espacée. Prévoyez une politique de repli si un canal est indisponible.

         Silences, mutes et politiques

         Les silences désactivent temporairement les notifications qui correspondent à un ensemble de labels, utile lors d’un incident suivi ou d’un déploiement. Les fenêtres de mise en sourdine (mutes) définissent des périodes récurrentes, par exemple les créneaux de maintenance. Les politiques sont hiérarchiques : un réglage au niveau racine peut s’appliquer à toute l’organisation, puis être affiné par dossier, équipe ou service.

         En pratique : créez un silence ciblé service=checkout, env=prod avec expiration automatique à la fin de l’intervention. Définissez une fenêtre de maintenance le dimanche 02 h, 03 h. Documentez chaque silence et limitez sa durée pour éviter d’occulter des alertes critiques.

         Tests et dépannage des alertes

         1. Vérifier la période : alignez la fenêtre d’analyse de la règle avec l’horizon de vos tableaux de bord et la durée for.
         2. Tester la source de données : dans Connexions → Sources de données, exécutez Save & Test et validez les identifiants.
         3. Prévisualiser la règle : utilisez l’aperçu/évaluation pour inspecter les séries et les réductions appliquées.
         4. Consulter les journaux d’évaluation : ouvrez l’historique d’état et les logs d’exécution pour identifier les erreurs ou absences de données.
         5. Tester les canaux : envoyez un message de test depuis le contact point et vérifiez les limitations éventuelles côté Slack/Teams.
         6. Contrôler le routage : examinez les politiques, les regroupements et les silences actifs qui pourraient bloquer l’envoi.
         7. Paramétrer no data/error : adaptez le comportement no data ou error pour éviter les faux positifs.
         8. Réduire le flapping : augmentez la durée for ou appliquez un lissage/agrégation plus robuste.

         Si une alerte ne part pas : vérifiez d’abord que la règle passe bien à l’état Firing, que la source de données renvoie des points sur l’intervalle évalué, et qu’aucun silence ou mute n’est actif. Ensuite, testez le contact point, inspectez les journaux d’évaluation et ajustez la fenêtre d’agrégation ou la durée for pour stabiliser le signal.

         Découvrir le métier de Data Analyst

         Plugins Grafana : quoi, pourquoi, comment ?

         Grafana s’appuie sur un vaste écosystème de plugins pour se connecter à de nouvelles sources de données, enrichir les visualisations et packager des intégrations clés en main. Étant un logiciel libre, il vous permet également d’écrire des plugins à partir de zéro pour l’intégration avec plusieurs sources de données différentes, et il dispose d’un support natif pour de nombreuses bases, beaucoup d’autres étant facilitées par des plugins dédiés. Utilisés correctement, ces modules accélèrent vos projets tout en restant sûrs et gouvernables.

         • Vérifier la provenance de chaque plugin, son éditeur et sa réputation communautaire.
         • Privilégier les plugins signés et officiels, limiter strictement le chargement des plugins non signés.
         • Contrôler les permissions, les appels sortants et la gestion des secrets liés aux sources de données.
         • Tester sur un environnement de pré‑production, puis déployer par étapes.
         • Suivre la compatibilité entre versions du plugin et version de Grafana, lire les notes de version.
         • Documenter et automatiser l’installation via provisioning pour garantir la répétabilité.

         Types de plugins (datasource, panel, app)

         Les plugins se répartissent en trois catégories complémentaires, chacune couvrant un besoin précis.

         Type	Rôle	Cas d’usage typiques
         Datasource	Connecter Grafana à une API, une base de données ou une plateforme d’observabilité.	Prometheus, Elasticsearch, MySQL, Azure Monitor, Zabbix comme source de métriques.
         Panel	Proposer une nouvelle visualisation ou interaction dans un panneau.	Pie Chart, diagrammes spécialisés, cartes avancées, heatmaps enrichies.
         App	Regrouper datasources, panels, pages, dashboards et parfois un backend, en une solution prête à l’emploi.	Pack Kubernetes, monitoring d’un produit tiers, vues d’administration et onboarding.

         Installer depuis la Marketplace

         1. Ouvrir la Marketplace des plugins depuis l’interface Grafana et rechercher le plugin souhaité.
         2. Consulter la fiche : éditeur, statut de signature, compatibilité, changelog, nombre d’installations.
         3. Cliquer sur Installer, puis redémarrer le service Grafana si cela est demandé.
         4. Configurer le plugin : ajouter la source de données ou insérer le panneau dans un tableau de bord.
         5. Mettre à jour régulièrement via l’interface ou la commande d’administration appropriée, après validation en pré‑prod.

         Sécurité et signature : par défaut, Grafana ne charge que les plugins signés. Les plugins non signés doivent être explicitement autorisés au cas par cas dans la configuration serveur, ce qui doit rester exceptionnel. Vérifiez toujours le badge de signature et préférez les éditeurs reconnus. Lors des mises à jour, contrôlez la compatibilité, l’impact des changements et conservez un plan de retour arrière.

         Plugins populaires (ex. Zabbix, Pie Chart, Azure Monitor)

         • Zabbix Datasource : interroge Zabbix pour visualiser rapidement les métriques d’hôtes, déclencheurs et inventaires, avec variables de templates et annotations.
         • Pie Chart Panel : apporte un panneau de diagrammes circulaires simple à configurer pour répartitions, parts de trafic ou répartition d’erreurs.
         • Azure Monitor : connecteur officiel pour métriques, logs et traces Azure afin d’unifier vos ressources cloud dans les dashboards Grafana.
         • AWS CloudWatch : collecte les métriques AWS pour analyser coûts, capacités et performances.
         • Datadog Datasource : requête l’API Datadog pour croiser ses indicateurs avec d’autres sources.

         Commencez par les connecteurs officiels et maintenus activement, puis ajoutez des panels ciblés selon les besoins métier. Évitez la prolifération : peu de plugins, bien gérés, valent mieux qu’un catalogue difficile à maintenir.

         Gouvernance, sécurité et maintenance

         • Validation : processus d’homologation des plugins avec revues techniques et sécurité, incluant un scan du code pour les plugins communautaires.
         • Versioning : pinner les versions et documenter l’ID de plugin, la version et les paramètres dans un dépôt de configuration.
         • Compatibilité : vérifier la matrice versions Grafana/plugins avant toute montée de version, tester les dashboards critiques.
         • Provisioning : gérer datasources, dashboards et plugins comme du code pour des déploiements reproductibles.
         • Moindre privilège : restreindre l’installation et la configuration aux rôles administrateurs, cloisonner les secrets.
         • Surveillance : instrumenter Grafana lui‑même et alerter sur les erreurs de plugins, les temps de réponse et les échecs de mise à jour.
         • Plan de secours : sauvegardes régulières, procédure de rollback, et environnement de pré‑production systématique.

         Une gouvernance claire, combinée à des mises à jour maîtrisées et à des tests automatisés, garantit la sécurité et la durabilité de votre écosystème de plugins, que vous soyez sur site, en Cloud ou en Enterprise.

         Se former à la Data et à l'IA

         Loki, Tempo et Mimir : de quoi parle-t-on ?

         Au‑delà de ses tableaux de bord, Grafana Labs propose trois briques open source qui couvrent l’observabilité de bout en bout : Loki pour les journaux applicatifs, Tempo pour les traces distribuées et Mimir pour les métriques. Elles s’intègrent à Grafana, s’adossent à des standards ouverts comme Prometheus et OpenTelemetry, et permettent de corréler en quelques clics métriques, logs et traces dans un même espace d’investigation.

         Donnée	Brique Grafana Labs
         Logs	Loki  : agrégation de journaux, indexation par labels, requêtes en LogQL.
         Traces	Tempo  : backend de traçage distribué, ingestion OpenTelemetry / Jaeger / Zipkin, navigation et recherche.
         Métriques	Mimir  : stockage de métriques compatible Prometheus, haute évolutivité et rétention long terme.

         Loki (logs)

         LogQL est le langage de requête de Loki. Il s’appuie sur des labels qui décrivent les flux de logs, puis scanne de façon sélective le contenu compressé pour filtrer, parser et agréger. L’idée : indexer peu, mais bien, en choisissant des labels stables et utiles pour délimiter rapidement le périmètre de recherche, puis appliquer des opérateurs LogQL pour extraire les informations de la ligne de log.

         Contraste avec les moteurs full‑text : contrairement à des solutions qui indexent chaque champ de chaque événement, Loki n’indexe que les métadonnées. Avantages : coûts d’ingestion et de stockage réduits, rétention plus longue, montée en charge simplifiée. En contrepartie, des recherches totalement libres sur le contenu non balisé peuvent être moins instantanées, ce qui exige une discipline de labellisation minimale à l’ingestion (par exemple service, environnement, cluster, namespace). Cette approche convient très bien aux logs applicatifs et Kubernetes, y compris pour la corrélation avec des métriques et des traces.

         Tempo (traces)

         Collecte : Tempo reçoit des spans depuis les SDK OpenTelemetry ou via des passerelles compatibles Jaeger et Zipkin. Stockage : il privilégie un stockage bloc peu coûteux, souvent objet, afin de conserver de gros volumes de traces. Navigation : l’exploration se fait par identifiant de trace, par attributs et via une recherche dédiée, puis par visualisation de la chronologie et de la carte de services, avec la possibilité de pivoter vers les logs associés.

         Cas concret : un pic de latence est visible sur un tableau de bord. Depuis la métrique de latence de l’API, vous basculez vers les traces d’un endpoint précis, isolez les spans lents dans un service amont, puis ouvrez les logs de l’instance fautive pour confirmer une régénération de connexion base de données. En quelques minutes, la cause racine est établie et l’incident résolu.

         Mimir (métriques)

         Mimir offre un stockage de métriques horizontablement scalable et multi‑tenant, pleinement compatible Prometheus pour l’ingestion (remote_write) et les requêtes (PromQL). On conserve les bénéfices de Prometheus en local pour le scrape proche des workloads, tout en centralisant l’historique, l’high availability et la rétention sur Mimir.

         Comparaison : un Prometheus seul est simple et efficace, mais limité par la rétention locale et la haute disponibilité. Mimir ajoute la vue globale cross‑cluster, la résilience et la rétention long terme sans changer vos tableaux de bord ni vos règles d’alerte basées sur PromQL.

         Quand les utiliser avec Grafana

         • Budget serré, logs d’applications : commencer avec Loki, des labels sobres et une rétention adaptée, puis n’activer Tempo que pour les services critiques.
         • Microservices et Kubernetes à grande échelle : trio complet Mimir + Tempo + Loki pour corréler pics de latence, traces inter‑services et journaux de pods dans Grafana Explore.
         • Besoin de rétention métriques long terme : conserver Prometheus en bordure pour le scrape, envoyer en remote_write vers Mimir, unifier les alertes et l’historique.
         • Migration depuis une pile full‑text : déplacer les logs applicatifs vers Loki pour réduire les coûts tout en gardant, si besoin, un index full‑text pour des cas d’audit spécifiques.
         • Traçage en priorité : instrumenter en OpenTelemetry, stocker dans Tempo avec échantillonnage raisonné, puis n’ajouter Loki que sur les services sensibles pour enrichir le diagnostic.

         En pratique, on adopte souvent Mimir pour consolider les métriques et les alertes, puis on ajoute Tempo et Loki selon les besoins de diagnostic. L’ensemble reste cohérent dans Grafana, avec des pivots rapides entre signaux et des coûts maîtrisés grâce aux choix d’indexation et de stockage de ces briques.

         Qu’est-ce que Grafana Cloud ?

         Grafana Cloud est une plateforme d’observabilité managée en mode SaaS qui regroupe tableaux de bord, métriques, logs et traces, avec hébergement, mises à jour et montée en charge pris en charge par l’éditeur. Elle s’adresse aux équipes qui veulent se concentrer sur le produit plutôt que sur l’exploitation d’une pile open source, tout en conservant des standards ouverts pour l’ingestion et la portabilité des données. ([grafana.com](https://grafana.com/docs/learning-hub/is-grafana-cloud-right-for-me/00-introduction/03-oss-compared-to-cloud/?utm_source=openai))

         Cas d’usage fréquents : démarrer rapidement l’observabilité d’un nouveau service, standardiser la télémétrie sur plusieurs équipes ou environnements, absorber des pics de charge sans gérer l’infrastructure, ou encore disposer d’engagements de disponibilité formalisés. ([grafana.com](https://grafana.com/docs/learning-hub/is-grafana-cloud-right-for-me/00-introduction/03-oss-compared-to-cloud/?utm_source=openai))

         Services gérés (métriques, logs, traces)

         • Métriques : service géré compatible Prometheus, basé sur Grafana Mimir, avec optimisation d’usage et séries actives mesurées. ([grafana.com](https://grafana.com/docs/learning-hub/is-grafana-cloud-right-for-me/00-introduction/03-oss-compared-to-cloud/?utm_source=openai))
         • Logs : agrégation et requêtes avec Grafana Loki, ingestion filtrable et contrôle de la rétention. ([grafana.com](https://grafana.com/docs/learning-hub/is-grafana-cloud-right-for-me/00-introduction/03-oss-compared-to-cloud/?utm_source=openai))
         • Traces : traçage distribué avec Grafana Tempo, ingestion native OTLP/OpenTelemetry. ([grafana.com](https://grafana.com/docs/learning-hub/is-grafana-cloud-right-for-me/00-introduction/03-oss-compared-to-cloud/?utm_source=openai))
         • Intégrations clés : ingestion OTLP hébergée, compatibilité Prometheus, connectivité privée en option, RBAC centralisé. ([grafana.com](https://grafana.com/docs/learning-hub/is-grafana-cloud-right-for-me/00-introduction/03-oss-compared-to-cloud/?utm_source=openai))

         Responsabilités partagées

         Domaines	Grafana Cloud (éditeur)	Vous (client)
         Hébergement, mises à jour, scalabilité	Opérés et garantis par le service managé	Sans action, seulement la configuration fonctionnelle
         Backends d’observabilité	Mimir, Loki, Tempo gérés	Choix des sources et schémas de données
         Fiabilité de la plateforme	SLA de disponibilité	Conception des SLO applicatifs
         Collecte et ingestion	OTLP hébergé, Fleet Management, outils d’optimisation	Instrumentation, déploiement des collecteurs
         Sécurité et accès	Fonctions RBAC et contrôle central	Gestion des rôles, secrets, politiques d’accès

         Référence : comparatif OSS vs Cloud et garanties de service. ([grafana.com](https://grafana.com/docs/learning-hub/is-grafana-cloud-right-for-me/00-introduction/03-oss-compared-to-cloud/?utm_source=openai))

         Fonctionnalités clés et limites

         Fonctionnalités	Limites typiques
         Rétention des données (plan Free)	14 jours pour métriques, logs, traces, profils, tests k6
         Quotas inclus (plan Free)	10 000 séries actives de métriques par mois, 50 Go/mois pour logs et traces, 3 utilisateurs actifs pour la visualisation et IRM, 100 k tests API et 10 k tests navigateur en synthetics, 500 heures VU en k6, 3 utilisateurs IA actifs
         Rétention (plan Pro)	Jusqu’à 13 mois pour les métriques, 30 jours pour logs, traces, profils et k6
         Intégrations et standards	OpenTelemetry/OTLP et Prometheus pris en charge nativement
         SLO et fiabilité	Définition d’objectifs de service dans le produit ; SLA de 99,5 % côté plateforme

         Sources : page tarifs/plans et documentation SLO/SLA. ([grafana.com](https://grafana.com/pricing/))

         Tarification et quand choisir Cloud

         Grandes lignes : un palier Free toujours gratuit pour évaluer et pour de petits périmètres, un palier Pro à partir de 19 $/mois plus usage, et une offre Enterprise à partir d’un engagement annuel de 25 000 $. La tarification est majoritairement à l’usage par signal : séries de métriques, Go ingérés pour logs/traces, utilisateurs actifs, tests synthetics, heures VU k6. ([grafana.com](https://grafana.com/pricing/))

         • Choisir Cloud si : vous cherchez un démarrage rapide sans gérer l’infra, un SLA formalisé, des intégrations OTel/Prometheus prêtes à l’emploi, et une facturation à l’usage prévisible. ([grafana.com](https://grafana.com/docs/learning-hub/is-grafana-cloud-right-for-me/00-introduction/03-oss-compared-to-cloud/?utm_source=openai))
         • Préférer le self‑hosted si : contraintes fortes de résidence des données, besoin d’un contrôle total de l’infrastructure, ou optimisation extrême de coûts sur des volumes très spécifiques.
         Formation Data Analyst certifiante

         Qu’est-ce que Grafana Enterprise ?

         Grafana Enterprise est l’édition payante de Grafana conçue pour les environnements exigeants, avec de fortes contraintes de sécurité, de gouvernance et de disponibilité. Autogérée et bâtie sur la base open source, elle ajoute des fonctions avancées pour industrialiser l’observabilité à l’échelle des équipes et des systèmes critiques.

         Le service Enterprise comprend toutes les fonctionnalités de Grafana Cloud plus des plugins premium, des sources de données et un support premium. En contexte autogéré, souvent appelé Enterprise Stack, l’édition Enterprise apporte surtout des capacités renforcées de contrôle des accès, d’intégration au SSO de l’entreprise, de reporting et d’audit, ainsi qu’un accompagnement contractuel.

         Fonctions avancées (RBAC, reporting, plugins commerciaux, support)

         • RBAC granulaire : permissions fines sur dossiers, tableaux de bord et sources de données, gestion par équipes et environnements.
         • Reporting programmé : export et envoi périodique de tableaux de bord en PDF/CSV, branding d’entreprise, diffusion contrôlée.
         • Plugins commerciaux : connecteurs et intégrations validés pour élargir les sources de données et accélérer les cas d’usage métier.
         • Haute disponibilité et gouvernance : bonnes pratiques d’architecture, espaces multi‑équipes, supervision et quotas.
         • Support et SLA : assistance prioritaire, conseils d’implémentation et corrections guidées pour les plateformes en production.

         En contraste : Grafana OSS couvre la visualisation, l’exploration et l’alerting avec des plugins open source. L’édition Enterprise ajoute ce qu’il faut pour opérer à grande échelle avec conformité et engagements de support.

         Intégrations SSO/AD et conformité

         • SSO d’entreprise : prise en charge de SAML 2.0 et OpenID Connect, intégration avec les fournisseurs usuels.
         • LDAP/Active Directory : connexion au référentiel d’identités et mappage automatique des groupes vers les rôles Grafana.
         • Journaux d’audit : traçabilité des authentifications, changements de permissions et modifications de configuration.
         • Contrôles d’accès et rétention : politiques d’accès par périmètre, séparation des environnements et gestion du cycle de vie des données.

         Dans la pratique, ces intégrations facilitent les exigences de conformité et d’audit interne : authentification centralisée, preuves d’accès, limitation du partage ad hoc et meilleure maîtrise de la diffusion des rapports.

         Critères de choix et coûts

         Voici des repères concrets pour décider entre Grafana OSS, Grafana Cloud et Grafana Enterprise selon votre équipe et votre volumétrie.

         Aspect	Grafana OSS	Grafana Cloud	Grafana Enterprise
         Hébergement	Autogéré, à votre charge	SaaS géré	Autogéré en entreprise
         Fonctionnalités	Noyau Grafana, plugins open source	Grafana + services managés de métriques, logs, traces	Fonctions avancées : RBAC, reporting, plugins commerciaux
         Sécurité et conformité	De base, selon votre configuration	SSO et sécurité gérés par le fournisseur	SSO SAML/OIDC, LDAP/AD, audit, contrôle fin des accès
         Coûts	Logiciel gratuit, coûts d’infra et d’exploitation	Facturation à l’usage : volumes de métriques, logs, traces, utilisateurs	Licence annuelle et support, coûts d’infra maîtrisés en interne
         Opérations	Maintenance et mises à jour par vos équipes	Mises à jour et SLA opérés par le fournisseur	Accompagnement et SLA, bonnes pratiques d’architecture
         Quand choisir	Pilotes, petites équipes, besoins standards	Déploiement rapide, équipes réduites, forte variabilité de charge	Exigences de sécurité, multi‑équipes, régulation ou intégrations entreprise

         • Équipe et maturité : peu d’opérations et besoin d’aller vite ? Cloud. Équipe plateforme outillée ? Enterprise ou OSS.
         • Volumétrie : volumes très élevés et prévisibles ? Autogéré possible. Volumes fluctuants ? Cloud pour l’élasticité.
         • Sécurité et SSO : SSO, audit et séparation stricte des accès attendus par la DSI ? Enterprise.
         • Contraintes réglementaires : résidence des données et audits fréquents ? Enterprise autogéré.
         • Coûts : comparez licence + infra + exploitation en Enterprise avec la facturation à l’usage du Cloud. Un palier gratuit du Cloud peut servir d’évaluation avant montée en charge.
         Découvrir les formations de Liora