Installer et utiliser Grafana sur Ubuntu : guide complet

Maîtrisez la configuration de Grafana pour le monitoring et la visualisation

Sommaire

Grafana est la plateforme open source leader pour le monitoring et l’observabilité, transformant les métriques, les logs et les traces en informations exploitables grâce à des visualisations spectaculaires.

grafana C’est une capture d’écran du site web Grafana.

Qu’est-ce que Grafana ?

Grafana est une application web open source multiplateforme de visualisation interactive et d’analyse. Elle fournit des graphiques, des graphes et des alertes pour le web lorsqu’elle est connectée à des sources de données prises en charge. Grafana est largement utilisée en DevOps pour surveiller l’infrastructure, les applications et les services.

Fonctionnalités clés :

  • Tableau de bord universel : Créez des tableaux de bord beaux et dynamiques avec un templating flexible
  • Plusieurs sources de données : Connectez-vous à plus de 150 sources de données, notamment Prometheus, InfluxDB, Elasticsearch, MySQL, PostgreSQL, etc.
  • Alertes : Système d’alertes unifié avec des canaux de notification (Slack, PagerDuty, e-mail, webhooks)
  • Collaboration d’équipe : Partagez des tableaux de bord, créez des équipes et gérez les permissions des utilisateurs
  • Écosystème de plugins : Étendez les fonctionnalités avec des panneaux, des sources de données et des applications
  • Cloud natif : Idéal pour Kubernetes, Docker et les environnements cloud

Pourquoi utiliser Grafana sur Ubuntu ?

Les versions Ubuntu LTS offrent une base stable et sécurisée pour héberger Grafana. Si vous démarrez de zéro ou si vous avez besoin de configurer un nouvel environnement Ubuntu pour votre infrastructure de monitoring, consultez notre guide complet sur comment installer Ubuntu 24.04 avec des outils utiles pour préparer votre système.

Les avantages incluent :

  • Un support à long terme et des mises à jour de sécurité
  • Une communauté importante et une documentation extensive
  • Un support natif du dépôt APT de Grafana Labs
  • Une excellente compatibilité avec Docker
  • Idéal pour les environnements de développement et de production

Méthodes d’installation

Méthode 1 : Installer via le dépôt APT (Recommandée)

C’est la méthode la plus simple, offrant des mises à jour automatiques via le gestionnaire de paquets Ubuntu. Si vous débutez avec le terminal Ubuntu ou si vous souhaitez améliorer votre productivité, notre feuille de rappel des raccourcis clavier Ubuntu peut vous aider à naviguer plus efficacement dans le système.

Étape 1 : Installer les prérequis

sudo apt-get install -y apt-transport-https software-properties-common wget

Étape 2 : Ajouter la clé GPG Grafana

sudo mkdir -p /etc/apt/keyrings/
wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null

Étape 3 : Ajouter le dépôt APT Grafana

Pour les versions stables :

echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list

Étape 4 : Mettre à jour et installer Grafana

sudo apt-get update
sudo apt-get install grafana

Étape 5 : Démarrer et activer le service Grafana

sudo systemctl daemon-reload
sudo systemctl start grafana-server
sudo systemctl enable grafana-server.service

Étape 6 : Vérifier l’installation

sudo systemctl status grafana-server

Grafana sera désormais en cours d’exécution sur http://localhost:3000

Méthode 2 : Installer avec Docker

Docker offre un isolement et une gestion plus facile des déploiements conteneurisés.

Étape 1 : Installer Docker (si ce n’est pas déjà fait)

sudo apt-get update
sudo apt-get install docker.io
sudo systemctl start docker
sudo systemctl enable docker

Étape 2 : Exécuter le conteneur Grafana

docker run -d \
  --name=grafana \
  -p 3000:3000 \
  -v grafana-storage:/var/lib/grafana \
  grafana/grafana-oss

Pour la persistance avec la configuration :

docker run -d \
  --name=grafana \
  -p 3000:3000 \
  -v grafana-storage:/var/lib/grafana \
  -v $(pwd)/grafana.ini:/etc/grafana/grafana.ini \
  -e "GF_SERVER_ROOT_URL=http://your-domain.com" \
  -e "GF_SECURITY_ADMIN_PASSWORD=your-secure-password" \
  grafana/grafana-oss

Méthode 3 : Installer avec Docker Compose

Créez un fichier docker-compose.yml :

version: '3.8'

services:
  grafana:
    image: grafana/grafana-oss:latest
    container_name: grafana
    restart: unless-stopped
    ports:
      - '3000:3000'
    volumes:
      - grafana-storage:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=your-secure-password
      - GF_USERS_ALLOW_SIGN_UP=false
      - GF_SERVER_ROOT_URL=http://your-domain.com

volumes:
  grafana-storage:

Démarrer avec :

docker-compose up -d

Configuration initiale

Première connexion

  1. Accédez à http://your-server-ip:3000
  2. Identifiants par défaut :
    • Nom d’utilisateur : admin
    • Mot de passe : admin
  3. Vous serez invité à changer le mot de passe immédiatement (très recommandé !)

Configurer votre première source de données

Exemple : Ajouter Prometheus

  1. Cliquez sur Configuration (icône de roue dentée) → Sources de données
  2. Cliquez sur Ajouter une source de données
  3. Sélectionnez Prometheus
  4. Configurez :
    • Nom : Prometheus
    • URL : http://localhost:9090 (ajustez selon votre instance Prometheus)
    • Accès : Serveur (par défaut)
  5. Cliquez sur Enregistrer et tester

Exemple : Ajouter InfluxDB

  1. Sélectionnez InfluxDB comme source de données
  2. Configurez :
    • Langage de requête : Flux ou InfluxQL
    • URL : http://localhost:8086
    • Base de données : votre_nom_de_base_de_données
    • Utilisateur/Mot de passe : vos identifiants
  3. Cliquez sur Enregistrer et tester

Créer votre premier tableau de bord

  1. Cliquez sur Créer (+) → Tableau de bord
  2. Cliquez sur Ajouter un nouveau panneau
  3. Sélectionnez votre source de données
  4. Écrivez votre requête (exemple pour Prometheus) :
rate(http_requests_total[5m])
  1. Personnalisez la visualisation :
    • Choisissez le type de panneau (Graphique, Jauge, Statistique, Tableau, etc.)
    • Configurez les légendes, les axes, les seuils
    • Ajoutez des transformations si nécessaire
  2. Cliquez sur Appliquer pour enregistrer le panneau
  3. Cliquez sur Enregistrer le tableau de bord (icône de disque)

Configuration avancée

Configurer les paramètres de Grafana

Éditez le fichier de configuration principal :

sudo nano /etc/grafana/grafana.ini

Paramètres importants :

[server]
# Protocole (http, https, h2, socket)
protocol = http
http_port = 3000
domain = your-domain.com
root_url = http://your-domain.com

[security]
admin_user = admin
admin_password = your-secure-password
secret_key = your-secret-key

[users]
# Désactiver l’inscription utilisateur
allow_sign_up = false
allow_org_create = false

[auth.anonymous]
enabled = false

[smtp]
enabled = true
host = smtp.gmail.com:587
user = your-email@gmail.com
password = your-app-password
from_address = your-email@gmail.com
from_name = Grafana

Redémarrez après les modifications :

sudo systemctl restart grafana-server

Configurer un proxy inverse (Nginx)

Installer Nginx :

sudo apt install nginx

Créer la configuration Nginx :

sudo nano /etc/nginx/sites-available/grafana

server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://localhost:3000;
        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;
    }
}

Activer et redémarrer :

sudo ln -s /etc/nginx/sites-available/grafana /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Activer HTTPS avec Let’s Encrypt

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d your-domain.com

Configurer l’alerte

Étape 1 : Configurer le canal de notification

  1. Accédez à Alertes → Points de contact
  2. Cliquez sur Nouveau point de contact
  3. Choisissez le type (E-mail, Slack, PagerDuty, Webhook, etc.)
  4. Configurez les paramètres (par exemple, l’URL du webhook Slack)
  5. Testez et enregistrez

Étape 2 : Créer une règle d’alerte

  1. Éditez un panneau de votre tableau de bord
  2. Cliquez sur l’onglet Alerte
  3. Configurez les conditions :
    • Quand : avg()
    • De : query(A, 5m, now)
    • Est supérieur à : 80
  4. Définissez l’intervalle d’évaluation
  5. Ajoutez un canal de notification
  6. Enregistrez

Cas d’utilisation populaires

Surveillance de l’infrastructure

Stack : Prometheus + Node Exporter + Grafana

Surveillez les métriques du système :

  • CPU, mémoire, utilisation du disque
  • Trafic réseau
  • Charge du système
  • I/O du disque

Pour la surveillance spécifique des GPU NVIDIA, vous pouvez envisager d’explorer des applications de surveillance des GPU pour Linux/Ubuntu qui s’intègrent bien avec Grafana.

Importez l’ID du tableau de bord : 1860 (Node Exporter Full)

Surveillance Kubernetes

Stack : Prometheus + kube-state-metrics + Grafana

Surveillez le cluster K8s :

  • Métriques des pods et conteneurs
  • Utilisation des ressources du cluster
  • Statut des déploiements
  • Surveillance des services et des entrées

Importez l’ID du tableau de bord : 15757 (Surveillance du cluster Kubernetes)

Surveillance des performances des applications

Stack : Loki + Promtail + Grafana

Surveillez les logs et les métriques des applications :

  • Taux de requêtes et latences
  • Taux d’erreurs
  • Agrégation et filtrage des logs
  • Suivi distribué

Surveillance des bases de données

Surveillez MySQL, PostgreSQL, MongoDB :

  • Performance des requêtes
  • Pools de connexions
  • Requêtes lentes
  • Statut de la réplication

Bonnes pratiques pour les tableaux de bord

  1. Organisez par objectif : Créez des tableaux de bord séparés pour différentes équipes/services
  2. Utilisez des variables : Créez des tableaux de bord dynamiques avec des variables de modèle
  3. Définissez des plages de temps appropriées : Défaut à des fenêtres de temps significatives
  4. Ajoutez des annotations : Marquez les déploiements et les incidents
  5. Utilisez des dossiers : Organisez logiquement les tableaux de bord
  6. Activez la versionning : Suivez les modifications des tableaux de bord
  7. Définissez des intervalles de rafraîchissement : Équilibrez les besoins en temps réel et les performances
  8. Ajoutez une documentation : Utilisez des panneaux de texte pour expliquer les métriques

Dépannage des problèmes courants

Le service Grafana ne démarre pas

# Vérifiez les journaux
sudo journalctl -u grafana-server -f

# Vérifiez la configuration
sudo grafana-cli admin reset-admin-password newpassword

Problèmes de connexion à la source de données

  • Vérifiez la connectivité réseau : telnet datasource-host port
  • Vérifiez les règles de pare-feu
  • Vérifiez les identifiants
  • Vérifiez les journaux du service de la source de données

Problèmes de performance

  • Réduisez les plages de temps des requêtes
  • Optimisez les requêtes de la source de données
  • Augmentez les ressources du serveur
  • Utilisez le cache là où possible
  • Considérez le cache des résultats des requêtes

Le tableau de bord ne charge pas

  • Videz le cache du navigateur
  • Vérifiez les erreurs dans la console du navigateur
  • Vérifiez que le JSON du tableau de bord n’est pas corrompu
  • Vérifiez les journaux du serveur Grafana

Sauvegarde et maintenance

Sauvegarder la base de données Grafana

# Arrêtez Grafana
sudo systemctl stop grafana-server

# Sauvegardez la base de données SQLite
sudo cp /var/lib/grafana/grafana.db /backup/grafana-$(date +%Y%m%d).db

# Sauvegardez la configuration
sudo cp /etc/grafana/grafana.ini /backup/grafana-ini-$(date +%Y%m%d).bak

# Démarrer Grafana
sudo systemctl start grafana-server

Script de sauvegarde automatisé

Voici un script bash pour automatiser vos sauvegardes Grafana. Si vous avez besoin d’un rappel rapide sur la syntaxe et les commandes bash, consultez notre feuille de rappel bash pour des conseils et exemples utiles.

#!/bin/bash
BACKUP_DIR="/backup/grafana"
mkdir -p $BACKUP_DIR
DATE=$(date +%Y%m%d_%H%M%S)

# Sauvegarde de la base de données
sudo cp /var/lib/grafana/grafana.db $BACKUP_DIR/grafana-$DATE.db

# Sauvegarde des tableaux de bord via l’API
curl -H "Authorization: Bearer YOUR_API_KEY" \
  http://localhost:3000/api/search?type=dash-db | \
  jq -r '.[] | .uid' | \
  xargs -I{} curl -H "Authorization: Bearer YOUR_API_KEY" \
  http://localhost:3000/api/dashboards/uid/{} > $BACKUP_DIR/dashboards-$DATE.json

# Gardez uniquement les sauvegardes des 30 derniers jours
find $BACKUP_DIR -mtime +30 -delete

Mettre à jour Grafana

# Méthode APT
sudo apt update
sudo apt upgrade grafana

# Méthode Docker
docker pull grafana/grafana-oss:latest
docker-compose down
docker-compose up -d

Renforcement de la sécurité

  1. Changer les identifiants par défaut immédiatement
  2. Utiliser HTTPS avec des certificats valides
  3. Configurer le pare-feu : 
    sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
  4. Désactiver l’accès anonyme
  5. Utiliser une authentification forte (LDAP, OAuth, SAML)
  6. Mises à jour régulières : Gardez Grafana à jour
  7. Limiter les permissions des utilisateurs : Utilisez le contrôle d’accès basé sur les rôles
  8. Activer le journal d’audit
  9. Utiliser des sources de données en lecture seule là où possible
  10. Implémenter une limitation de débit

Surveillance de Grafana elle-même

Surveillez votre instance Grafana :

  1. Activez le point de terminaison des métriques dans grafana.ini : 
    [metrics]
enabled = true
  2. Ajoutez Grafana comme cible Prometheus
  3. Importez le tableau de bord des métriques Grafana

Plugins utiles

Installez des plugins via l’interface CLI :

sudo grafana-cli plugins install <plugin-id>
sudo systemctl restart grafana-server

Plugins recommandés :

  • grafana-piechart-panel : Graphiques à secteurs améliorés
  • grafana-worldmap-panel : Visualisation de données géographiques
  • grafana-clock-panel : Affichage de l’heure et de la date
  • grafana-simple-json-datasource : Connectez-vous à des API JSON personnalisées
  • alexanderzobnin-zabbix-app : Intégration Zabbix

Exemples d’intégration

Grafana + Prometheus + Node Exporter

Configuration complète du stack de surveillance :

# Installez Node Exporter
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvfz node_exporter-1.7.0.linux-amd64.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
sudo useradd -rs /bin/false node_exporter

# Créez un service systemd
sudo tee /etc/systemd/system/node_exporter.service << EOF
[Unit]
Description=Node Exporter
After=network.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl start node_exporter
sudo systemctl enable node_exporter

Grafana avec InfluxDB et Telegraf

Configuration de surveillance en temps série :

# Installez InfluxDB
wget -q https://repos.influxdata.com/influxdata-archive_compat.key
echo '393e8779c89ac8d958f81f942f9ad7fb82a25e133faddaf92e15b16e6ac9ce4c influxdata-archive_compat.key' | sha256sum -c && cat influxdata-archive_compat.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null
echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main' | sudo tee /etc/apt/sources.list.d/influxdata.list
sudo apt update && sudo apt install influxdb
sudo systemctl start influxdb
sudo systemctl enable influxdb

# Installez Telegraf
sudo apt install telegraf
sudo systemctl start telegraf
sudo systemctl enable telegraf

Optimisation des performances

Optimisation des requêtes

  • Utilisez des plages de temps appropriées
  • Limitez le nombre de points de données retournés
  • Utilisez des stratégies de mise en cache
  • Agrégez les données à la source si possible
  • Utilisez des règles d’enregistrement dans Prometheus

Optimisation du serveur

[database]
# Augmentez le nombre maximum de connexions
max_open_conn = 300
max_idle_conn = 100

[dataproxy]
# Paramètres de délai
timeout = 30
keep_alive_seconds = 30

[rendering]
# Activez la limite de rendu concurrent
concurrent_render_limit = 10

Liens utiles

Conclusion

Grafana sur Ubuntu offre une plateforme puissante et flexible pour le monitoring et l’observabilité. Que vous surveilliez un seul serveur ou un grand cluster Kubernetes, les capacités de visualisation riches de Grafana, le large support des sources de données et sa communauté active en font un excellent choix pour les équipes DevOps.

Commencez avec une configuration simple via la méthode du dépôt APT, connectez votre première source de données, puis développez progressivement vos capacités de monitoring. N’oubliez pas de prioriser la sécurité, les sauvegardes régulières et l’optimisation des performances à mesure que votre déploiement Grafana grandit.

Avec une configuration appropriée et des bonnes pratiques, Grafana devient un outil indispensable dans votre stack d’observabilité, fournissant des informations exploitables qui aident à maintenir des systèmes fiables et performants.