Graphite Monitoring · 13 min read · Oct 27, 2025
Comment installer et configurer le système de surveillance Graphite sur Ubuntu 22.04
Graphite est un outil open-source utilisé pour suivre et représenter graphiquement les performances des systèmes informatiques. Vous pouvez l’utiliser pour suivre les performances des sites Web, des applications, des services commerciaux et des serveurs en réseau. Il est très flexible et peut être configuré de manière à vous permettre de bénéficier à la fois d’une représentation détaillée et d’une vue d’ensemble des performances et de la santé des métriques que vous suivez.
Graphite est composé de plusieurs composants : l’application web, un backend de stockage appelé Carbon, et la bibliothèque de base de données appelée whisper. Dans ce tutoriel, vous apprendrez à installer et configurer Graphite sur un serveur Ubuntu 22.04.
Prérequis
- Un serveur exécutant Ubuntu 22.04.
- Un nom de domaine entièrement qualifié (FQDN) pointant vers le serveur. Pour notre tutoriel, nous utiliserons le domaine
graphite.example.com. - Un utilisateur non-root avec des privilèges sudo.
- Le pare-feu uncomplicated (UFW) est activé et en cours d’exécution.
- Assurez-vous que tout est à jour.
$ sudo apt update && sudo apt upgrade - Installez des paquets utilitaires de base. Certains d’entre eux peuvent déjà être installés.
$ sudo apt install wget curl nano unzip -y
Étape 1 - Configurer le pare-feu
Avant d’installer des paquets, la première étape consiste à configurer le pare-feu pour autoriser les connexions HTTP et HTTPS.
Vérifiez l’état du pare-feu.
$ sudo ufw status
Vous devriez voir quelque chose comme ce qui suit.
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
Autorisez les ports HTTP et HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Vérifiez à nouveau l’état pour confirmer.
$ sudo ufw status
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
80/tcp ALLOW Anywhere
443 ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
80/tcp (v6) ALLOW Anywhere (v6)
443 (v6) ALLOW Anywhere (v6)
Étape 2 - Installer les paquets requis
Nous allons installer Graphite en utilisant le gestionnaire de paquets PIP Python. La première étape consiste à installer les paquets requis pour l’installation.
$ sudo apt install vim python3-dev python3-pip libcairo2-dev libffi-dev build-essential
Étape 3 - Installer Graphite et Graphite Web
Nous allons installer Graphite dans le répertoire /opt/graphite.
$ export PYTHONPATH="/opt/graphite/lib/:/opt/graphite/webapp/"
$ sudo pip install --no-binary=:all: https://github.com/graphite-project/whisper/tarball/master
$ sudo pip install --no-binary=:all: https://github.com/graphite-project/carbon/tarball/master
$ sudo pip install --no-binary=:all: https://github.com/graphite-project/graphite-web/tarball/master
Étape 4 - Installer et configurer PostgreSQL
Nous allons utiliser le dépôt APT officiel de PostgreSQL pour installer. Exécutez la commande suivante pour ajouter la clé GPG de PostgreSQL.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Ajoutez le dépôt APT à votre liste de sources.
$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/postgresql-key.gpg arch=amd64] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
Mettez à jour le dépôt système.
$ sudo apt update
Maintenant, vous pouvez installer PostgreSQL et les paquets d’assistance en utilisant la commande suivante.
$ sudo apt install postgresql postgresql-contrib libpq-dev
Vérifiez l’état du service PostgreSQL.
$ sudo systemctl status postgresql
? postgresql.service - PostgreSQL RDBMS
Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; vendor preset: enabled)
Active: active (exited) since Tue 2022-09-27 10:09:35 UTC; 4s ago
Process: 4456 ExecStart=/bin/true (code=exited, status=0/SUCCESS)
Main PID: 4456 (code=exited, status=0/SUCCESS)
CPU: 1ms
Sep 27 10:09:35 matrix systemd[1]: Starting PostgreSQL RDBMS...
Sep 27 10:09:35 matrix systemd[1]: Finished PostgreSQL RDBMS.
Vous pouvez voir que le service est activé et en cours d’exécution par défaut.
Connectez-vous à l’interface en ligne de commande PostgreSQL.
$ sudo -su postgres psql
Créez un utilisateur de base de données pour Graphite.
postgres=# CREATE USER graphite WITH PASSWORD 'your_password';
Créez une base de données pour Graphite et donnez la propriété à l’utilisateur graphite.
postgres=# CREATE DATABASE graphitedb WITH OWNER graphite;
Quittez l’interface en ligne de commande PostgreSQL.
postgres=# \q
Étape 5 - Configurer Graphite Carbon et Web
L’étape suivante consiste à configurer Graphite Carbon et Graphite web.
Configurer Carbon
Carbon se compose de trois services :
- carbon-cache : accepte les métriques et les écrit sur le disque.
- carbon-relay : réplique les données.
- carbon-aggregator : fonctionne devant le service carbon-cache pour mettre en mémoire tampon les métriques au fil du temps avant de les transmettre à Whisper.
Configurer carbon-cache est nécessaire, mais carbon-relay et carbon-aggregator sont optionnels.
Créez le fichier carbon.conf en utilisant le fichier exemple donné.
$ sudo cp /opt/graphite/conf/carbon.conf.example /opt/graphite/conf/carbon.conf
Ensuite, créez la configuration des schémas de stockage.
$ sudo cp /opt/graphite/conf/storage-schemas.conf.example /opt/graphite/conf/storage-schemas.conf
Ouvrez le fichier de configuration du schéma de stockage.
$ sudo nano /opt/graphite/conf/storage-schemas.conf
À l’intérieur, vous trouverez des entrées comme
[carbon]
pattern = ^carbon\.
retentions = 60:90d
Cela implique qu’un motif qui correspond à une expression régulière ^carbon\. doit conserver les données avec une politique de rétention 60:90d, ce qui signifie
- à quelle fréquence une métrique est enregistrée : 60 secondes
- durée de stockage de ces valeurs : 90 jours
Vous pouvez ajouter votre propre entrée. Prenons un exemple test, c’est-à-dire des points de données de surveillance et nos entrées de points de données commenceront par la chaîne test. Cette entrée doit être ajoutée avant l’entrée par défaut mentionnée en bas du fichier.
[test]
pattern = ^test\.
retentions = 10s:10m,1m:1h
Cela correspondra à toutes les métriques commençant par test. Il stockera les données qu’il collecte deux fois, avec des détails variés. La première définition (1s:10m) créera un point de données toutes les dix secondes. Elle ne stockera les données que pendant dix minutes. La deuxième définition créera un point de données chaque minute. Elle rassemblera toutes les données de la minute précédente (six points, puisque la définition précédente crée un point toutes les dix secondes) et les agrégera pour créer le point. Elle stocke les données à ce niveau de détail pendant une heure.
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Démarrez le service carbon-cache.
$ sudo /opt/graphite/bin/carbon-cache.py start
Configurer le Web de Graphite
L’étape suivante consiste à configurer l’application web Graphite.
Générez une clé secrète pour l’application Graphite. Copiez la clé affichée pour une utilisation ultérieure.
$ python3 -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'
sp%71)6b$%^bc(7xpz1d!)x3(azog01&k^8l02*!y0#)72p07y
Créez le fichier de paramètres de l’application web.
$ sudo cp /opt/graphite/webapp/graphite/local_settings.py.example /opt/graphite/webapp/graphite/local_settings.py
Vous devez configurer l’application web Graphite avec les paramètres de la base de données. Ouvrez le local_settings.py pour l’édition.
$ sudo nano /opt/graphite/webapp/graphite/local_settings.py
Décommentez la variable SECRET_KEY et entrez une valeur aléatoire pour celle-ci.
SECRET_KEY = 'your-secret-key'
Décommentez la variable ALLOWED_HOSTS.
ALLOWED_HOSTS = [ '*' ]
Décommentez la variable TIME_ZONE et définissez-la sur la valeur appropriée.
TIME_ZONE = 'Asia/Kolkata'
Décommentez la variable USE_REMOTE_USER_AUTHENTICATION et définissez-la sur TRUE afin que l’utilisateur distant soit authentifié avant d’apporter des modifications à la base de données.
USE_REMOTE_USER_AUTHENTICATION = True
Modifiez les paramètres de la base de données.
DATABASES = {
'default': {
'NAME': 'graphitedb',
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'USER': 'graphite',
'PASSWORD': 'your_password',
'HOST': '127.0.0.1',
'PORT': ''
}
}
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Installez quelques prérequis pour le wrapper PostgreSQL de Python.
$ sudo pip install psycopg2-binary
Exécutez la commande suivante pour importer le schéma de la base de données.
$ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py migrate --settings=graphite.settings
Vous obtiendrez la sortie suivante.
Operations to perform:
Apply all migrations: account, admin, auth, contenttypes, dashboard, events, sessions, tagging, tags, url_shortener
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying account.0001_initial... OK
Applying admin.0001_initial... OK
Applying admin.0002_logentry_remove_auto_add... OK
Applying admin.0003_logentry_add_action_flag_choices... OK
Applying contenttypes.0002_remove_content_type_name... OK
Applying auth.0002_alter_permission_name_max_length... OK
Applying auth.0003_alter_user_email_max_length... OK
Applying auth.0004_alter_user_username_opts... OK
Applying auth.0005_alter_user_last_login_null... OK
Applying auth.0006_require_contenttypes_0002... OK
Applying auth.0007_alter_validators_add_error_messages... OK
Applying auth.0008_alter_user_username_max_length... OK
Applying auth.0009_alter_user_last_name_max_length... OK
Applying auth.0010_alter_group_name_max_length... OK
Applying auth.0011_update_proxy_permissions... OK
Applying auth.0012_alter_user_first_name_max_length... OK
Applying dashboard.0001_initial... OK
Applying events.0001_initial... OK
Applying sessions.0001_initial... OK
Applying tagging.0001_initial... OK
Applying tagging.0002_on_delete... OK
Applying tags.0001_initial... OK
Applying url_shortener.0001_initial... OK
Ensuite, collectez les fichiers statiques.
$ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py collectstatic --settings=graphite.settings
Définissez les paramètres de propriété corrects.
$ sudo chown -R www-data:www-data /opt/graphite/storage/
$ sudo chown -R www-data:www-data /opt/graphite/static/
$ sudo chown -R www-data:www-data /opt/graphite/webapp/
Créez un utilisateur root pour la connexion.
$ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py createsuperuser --settings=graphite.settings
Username (leave blank to use 'root'): navjot
Email address: [email protected]
Password:
Password (again):
Superuser created successfully.
Il vous sera demandé de créer un superutilisateur. Cet utilisateur sera utilisé plus tard pour se connecter à l’application Graphite.
Étape 6 - Configurer Apache
Graphite est livré avec des fichiers de configuration Apache par défaut. Installez le serveur Apache.
$ sudo apt install apache2 libapache2-mod-wsgi-py3
Créez le fichier mod_wsgi.
$ sudo cp /opt/graphite/conf/graphite.wsgi.example /opt/graphite/conf/graphite.wsgi
Copiez le fichier de configuration exemple de graphite à l’emplacement Apache.
$ sudo cp /opt/graphite/examples/example-graphite-vhost.conf /etc/apache2/sites-available/graphite.conf
Ouvrez le fichier de configuration Graphite pour l’édition.
$ sudo nano /etc/apache2/sites-available/graphite.conf
Changez le numéro de port dans la première ligne de 80 à 127.0.0.1:8080. Mettre 127.0.0.1 devant restreint l’accès depuis le web.
Ajoutez votre nom de domaine.
ServerName graphite.example.com #Remplacez par votre domaine
Ajoutez les lignes suivantes sous la ligne Alias /static/ /opt/graphite/static/.
#Ajoutez les lignes ci-dessous
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Désactivez l’hôte virtuel par défaut et activez le fichier d’hôte virtuel Graphite.
$ sudo a2dissite 000-default
$ sudo a2ensite graphite
Nous devrons également dire à Apache d’écouter le port 8080 et d’arrêter d’écouter le port 80 car nous utiliserons Nginx comme serveur proxy.
Ouvrez le fichier /etc/apache2/ports.conf pour l’édition.
$ sudo nano /etc/apache2/ports.conf
Trouvez la ligne Listen 80 et remplacez-la par ce qui suit.
Listen 127.0.0.1:8080
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Redémarrez le serveur Apache.
$ sudo systemctl restart apache2
Pour vérifier que Graphite fonctionne correctement et est accessible, exécutez la commande suivante.
$ curl 127.0.0.1:8080
Vous obtiendrez la sortie suivante.
Graphite Browser
Cela confirme que cela fonctionne bien.
Étape 7 - Installer Nginx
Nous allons utiliser Nginx comme serveur proxy pour Apache. De cette façon, nous pouvons tirer parti de la sécurité et de l’obscurité tout en utilisant la configuration existante fournie par Graphite.
Ubuntu 22.04 est livré avec une version plus ancienne de Nginx. Pour installer la dernière version, vous devez télécharger le dépôt officiel de Nginx.
Importez la clé de signature de Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Ajoutez le dépôt pour la version stable de Nginx.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Mettez à jour les dépôts système.
$ sudo apt update
Installez Nginx.
$ sudo apt install nginx
Vérifiez l’installation.
$ nginx -v
nginx version: nginx/1.22.0
Démarrez le serveur Nginx.
$ sudo systemctl start nginx
Étape 8 - Installer SSL
Nous devons installer Certbot pour générer le certificat SSL. Vous pouvez soit installer Certbot en utilisant le dépôt d’Ubuntu, soit obtenir la dernière version en utilisant l’outil Snapd. Nous allons utiliser la version Snapd.
Ubuntu 22.04 est livré avec Snapd installé par défaut. Exécutez les commandes suivantes pour vous assurer que votre version de Snapd est à jour.
$ sudo snap install core
$ sudo snap refresh core
Installez Certbot.
$ sudo snap install --classic certbot
Utilisez la commande suivante pour vous assurer que la commande Certbot peut être exécutée en créant un lien symbolique vers le répertoire /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Exécutez la commande suivante pour générer un certificat SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d graphite.example.com
La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/graphite.example.com sur votre serveur.
Générez un certificat de groupe Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Vérifiez le service de planification de renouvellement de Certbot.
$ sudo systemctl list-timers
Vous trouverez snap.certbot.renew.service comme l’un des services programmés pour s’exécuter.
NEXT LEFT LAST PASSED UNIT ACTIVATES
.................................................................................................................................
Wed 2022-09-28 00:00:00 UTC 7h left Tue 2022-09-27 00:00:01 UTC 16h ago logrotate.timer logrotate.service
Wed 2022-09-28 02:39:09 UTC 10h left Tue 2022-09-27 09:42:42 UTC 6h ago apt-daily.timer apt-daily.service
Wed 2022-09-28 06:02:00 UTC 13h left n/a n/a snap.certbot.renew.timer snap.certbot.renew.service
Pour vérifier si le renouvellement SSL fonctionne correctement, effectuez un essai à sec du processus.
$ sudo certbot renew --dry-run
Si vous ne voyez aucune erreur, vous êtes prêt. Votre certificat se renouvellera automatiquement.
Étape 9 - Configurer Nginx
Ouvrez le fichier /etc/nginx/nginx.conf pour l’édition.
$ sudo nano /etc/nginx/nginx.conf
Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Créez et ouvrez le fichier /etc/nginx/conf.d/uvdesk.conf pour l’édition.
$ sudo nano /etc/nginx/conf.d/graphite.conf
Collez le code suivant dedans.
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name graphite.example.com;
access_log /var/log/nginx/graphite.access.log;
error_log /var/log/nginx/graphite.error.log;
# SSL
ssl_certificate /etc/letsencrypt/live/graphite.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/graphite.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/graphite.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 8.8.8.8;
location / {
proxy_set_header Connection "upgrade";
proxy_set_header Upgrade $http_upgrade;
proxy_http_version 1.1;
proxy_set_header Host $http_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-NginX-Proxy true;
proxy_pass http://127.0.0.1:8080;
proxy_redirect off;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name graphite.example.com;
return 301 https://$host$request_uri;
}
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité une fois terminé.
Vérifiez la syntaxe du fichier de configuration Nginx.
$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
Redémarrez le service Nginx.
$ sudo systemctl restart nginx
Étape 10 - Accéder et utiliser Graphite
Visitez l’URL https://graphite.example.com dans votre navigateur et vous obtiendrez l’écran suivant.
Cliquez sur le lien Connexion en haut à droite pour ouvrir la page de connexion. Entrez vos identifiants de superutilisateur créés à l’étape 5 et appuyez sur le bouton connexion pour continuer.
Il existe plusieurs méthodes pour alimenter des données dans Graphite. Nous avons ajouté un correspondance de motif dans le schéma de stockage, selon lequel tout motif qui commence par test sera enregistré comme notre motif. Ajoutons quelques données aléatoires en utilisant la commande suivante.
$ echo "test.count 9 `date +%s`" | nc -q0 127.0.0.1 2003;
Cela ajoutera une métrique de données d’une valeur de 9 au système. Ajoutons quelques données supplémentaires en parcourant les valeurs.
$ for i in 4 6 8 16 2; do echo "test.count $i `date +%s`" | nc -q0 127.0.0.1 2003; sleep 6; done
Retournez au tableau de bord Graphite et ouvrez Metrics >> test >> count dans la barre latérale gauche. Vous devriez voir quelque chose comme ce qui suit.
Vous pouvez maintenant commencer à l’utiliser pour la surveillance. Vous pouvez également le combiner avec Grafana pour obtenir un niveau élevé de personnalisation.
Conclusion
Cela conclut notre tutoriel sur l’installation et la configuration de Graphite sur un serveur Ubuntu 22.04 avec Nginx comme serveur proxy. Si vous avez des questions, posez-les dans les commentaires ci-dessous.
Recevez de nouveaux articles dans votre boîte de réception.
Aucun spam. Désabonnez-vous à tout moment.