Monitoraggio · 13 min read · Oct 27, 2025
Come installare e configurare il sistema di monitoraggio Graphite su Ubuntu 22.04
Graphite è uno strumento open-source utilizzato per monitorare e rappresentare graficamente le prestazioni dei sistemi informatici. Puoi usarlo per monitorare le prestazioni di siti web, applicazioni, servizi aziendali e server in rete. È altamente flessibile e può essere configurato in modo da ottenere i vantaggi sia di una rappresentazione dettagliata che di una panoramica generale delle prestazioni e della salute delle metriche che stai monitorando.
Graphite è composto da diversi componenti: l’applicazione web, un backend di archiviazione chiamato Carbon e la libreria del database chiamata whisper. In questo tutorial, imparerai a installare e configurare Graphite su un server Ubuntu 22.04.
Prerequisiti
- Un server che esegue Ubuntu 22.04.
- Un nome di dominio completamente qualificato (FQDN) che punta al server. Per il nostro tutorial, utilizzeremo il dominio
graphite.example.com. - Un utente non root con privilegi sudo.
- Il firewall semplice (UFW) è abilitato e in esecuzione.
- Assicurati che tutto sia aggiornato.
$ sudo apt update && sudo apt upgrade - Installa i pacchetti di utilità di base. Alcuni di essi potrebbero già essere installati.
$ sudo apt install wget curl nano unzip -y
Passo 1 - Configurare il Firewall
Prima di installare qualsiasi pacchetto, il primo passo è configurare il firewall per consentire le connessioni HTTP e HTTPS.
Controlla lo stato del firewall.
$ sudo ufw status
Dovresti vedere qualcosa di simile a quanto segue.
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
Consenti le porte HTTP e HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Controlla di nuovo lo stato per confermare.
$ 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)
Passo 2 - Installare i pacchetti richiesti
Installeremo Graphite utilizzando il gestore di pacchetti PIP di Python. Il primo passo è installare i pacchetti necessari per l’installazione.
$ sudo apt install vim python3-dev python3-pip libcairo2-dev libffi-dev build-essential
Passo 3 - Installare Graphite e Graphite Web
Installeremo Graphite nella directory /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
Passo 4 - Installare e configurare PostgreSQL
Utilizzeremo il repository APT ufficiale di PostgreSQL per l’installazione. Esegui il seguente comando per aggiungere la chiave GPG di PostgreSQL.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Aggiungi il repository APT alla tua lista di sorgenti.
$ 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'
Aggiorna il repository di sistema.
$ sudo apt update
Ora puoi installare PostgreSQL e i pacchetti di supporto utilizzando il seguente comando.
$ sudo apt install postgresql postgresql-contrib libpq-dev
Controlla lo stato del servizio 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.
Puoi vedere che il servizio è abilitato e in esecuzione per impostazione predefinita.
Accedi alla shell di PostgreSQL.
$ sudo -su postgres psql
Crea un utente del database per Graphite.
postgres=# CREATE USER graphite WITH PASSWORD 'your_password';
Crea un database per Graphite e assegna la proprietà all’utente graphite.
postgres=# CREATE DATABASE graphitedb WITH OWNER graphite;
Esci dalla shell di PostgreSQL.
postgres=# \q
Passo 5 - Configurare Graphite Carbon e Web
Il passo successivo è configurare Graphite Carbon e Graphite web.
Configurare Carbon
Carbon è composto da tre servizi:
- carbon-cache: accetta metriche e le scrive su disco.
- carbon-relay: replica i dati.
- carbon-aggregator: funziona davanti al servizio carbon-cache per memorizzare le metriche nel tempo prima di inoltrarle a Whisper.
Configurare carbon-cache è necessario, ma carbon-relay e carbon-aggregator sono facoltativi.
Crea il file carbon.conf utilizzando il file di esempio fornito.
$ sudo cp /opt/graphite/conf/carbon.conf.example /opt/graphite/conf/carbon.conf
Successivamente, crea la configurazione degli schemi di archiviazione.
$ sudo cp /opt/graphite/conf/storage-schemas.conf.example /opt/graphite/conf/storage-schemas.conf
Apri il file di configurazione dello schema di archiviazione.
$ sudo nano /opt/graphite/conf/storage-schemas.conf
All’interno, troverai voci come
[carbon]
pattern = ^carbon\.
retentions = 60:90d
Questo implica che un pattern che corrisponde a un’espressione regolare ^carbon\. dovrebbe mantenere i dati con una politica di retention 60:90d che significa
- quanto spesso una metrica viene registrata: 60 secondi
- durata del tempo per memorizzare quei valori: 90 giorni
Puoi aggiungere la tua voce. Prendiamo ad esempio test, cioè monitorare i punti dati e le nostre voci di punti dati inizieranno con la stringa test. Questa voce dovrebbe essere aggiunta prima della voce predefinita menzionata in fondo al file.
[test]
pattern = ^test\.
retentions = 10s:10m,1m:1h
Questo corrisponderà a qualsiasi metrica che inizia con test. Memorizzerà i dati che raccoglie due volte, con dettagli variabili. La prima definizione (1s:10m) creerà un punto dati ogni dieci secondi. Memorizzerà i dati solo per dieci minuti. La seconda definizione creerà un punto dati ogni minuto. Raccoglierà tutti i dati dell’ultimo minuto (sei punti, poiché la definizione precedente crea un punto ogni dieci secondi) e li aggrega per creare il punto. Memorizza i dati a questo livello di dettaglio per un’ora.
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Avvia il servizio carbon-cache.
$ sudo /opt/graphite/bin/carbon-cache.py start
Configurare il Graphite Web
Il passo successivo è configurare l’app web di Graphite.
Genera una chiave segreta per l’applicazione Graphite. Copia la chiave visualizzata per un uso successivo.
$ 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
Crea il file di impostazioni dell’app web.
$ sudo cp /opt/graphite/webapp/graphite/local_settings.py.example /opt/graphite/webapp/graphite/local_settings.py
Devi configurare l’applicazione web di Graphite con le impostazioni del database. Apri il local_settings.py per la modifica.
$ sudo nano /opt/graphite/webapp/graphite/local_settings.py
Decommenta la variabile SECRET_KEY e inserisci un valore casuale per essa.
SECRET_KEY = 'your-secret-key'
Decommenta la variabile ALLOWED_HOSTS.
ALLOWED_HOSTS = [ '*' ]
Decommenta la variabile TIME_ZONE e impostala sul valore appropriato.
TIME_ZONE = 'Asia/Kolkata'
Decommenta la variabile USE_REMOTE_USER_AUTHENTICATION e impostala su TRUE in modo che l’utente remoto venga autenticato prima di apportare modifiche al database.
USE_REMOTE_USER_AUTHENTICATION = True
Cambia le impostazioni del database.
DATABASES = {
'default': {
'NAME': 'graphitedb',
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'USER': 'graphite',
'PASSWORD': 'your_password',
'HOST': '127.0.0.1',
'PORT': ''
}
}
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Installa alcuni prerequisiti per il wrapper PostgreSQL di Python.
$ sudo pip install psycopg2-binary
Esegui il seguente comando per importare lo schema del database.
$ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py migrate --settings=graphite.settings
Riceverai il seguente output.
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
Successivamente, raccogli i file statici.
$ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py collectstatic --settings=graphite.settings
Imposta le corrette impostazioni di proprietà.
$ 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/
Crea un utente root per il login.
$ 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.
Ti verrà chiesto di creare un superutente. Questo utente sarà utilizzato in seguito per connettersi all’applicazione Graphite.
Passo 6 - Configurare Apache
Graphite viene fornito con file di configurazione di Apache per impostazione predefinita. Installa il server Apache.
$ sudo apt install apache2 libapache2-mod-wsgi-py3
Crea il file mod_wsgi.
$ sudo cp /opt/graphite/conf/graphite.wsgi.example /opt/graphite/conf/graphite.wsgi
Copia il file di configurazione di esempio di graphite nella posizione di Apache.
$ sudo cp /opt/graphite/examples/example-graphite-vhost.conf /etc/apache2/sites-available/graphite.conf
Apri il file di configurazione di Graphite per la modifica.
$ sudo nano /etc/apache2/sites-available/graphite.conf
Cambia il numero di porta nella prima riga da 80 a 127.0.0.1:8080. Mettere 127.0.0.1 davanti ad esso lo rende non accessibile tramite il web.
Aggiungi il tuo nome di dominio.
ServerName graphite.example.com #Sostituisci con il tuo dominio
Aggiungi le seguenti righe sotto la riga Alias /static/ /opt/graphite/static/.
#Aggiungi le righe sotto
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Disabilita il virtual host predefinito e abilita il file del virtual host di Graphite.
$ sudo a2dissite 000-default
$ sudo a2ensite graphite
Dobbiamo anche dire ad Apache di ascoltare sulla porta 8080 e smettere di ascoltare sulla porta 80 perché utilizzeremo Nginx come server proxy.
Apri il file /etc/apache2/ports.conf per la modifica.
$ sudo nano /etc/apache2/ports.conf
Trova la riga Listen 80 e sostituiscila con quanto segue.
Listen 127.0.0.1:8080
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Riavvia il server Apache.
$ sudo systemctl restart apache2
Per verificare che Graphite funzioni correttamente e sia accessibile, esegui il seguente comando.
$ curl 127.0.0.1:8080
Riceverai il seguente output.
Graphite Browser
Questo conferma che funziona correttamente.
Passo 7 - Installare Nginx
Utilizzeremo Nginx come server proxy per Apache. In questo modo possiamo raccogliere i benefici della sicurezza e dell’oscurità, utilizzando nel contempo la configurazione esistente fornita da Graphite.
Ubuntu 22.04 viene fornito con una versione più vecchia di Nginx. Per installare l’ultima versione, devi scaricare il repository ufficiale di Nginx.
Importa la chiave di firma di Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Aggiungi il repository per la versione stabile di 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
Aggiorna i repository di sistema.
$ sudo apt update
Installa Nginx.
$ sudo apt install nginx
Verifica l’installazione.
$ nginx -v
nginx version: nginx/1.22.0
Avvia il server Nginx.
$ sudo systemctl start nginx
Passo 8 - Installare SSL
Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Ubuntu o scaricare l’ultima versione utilizzando lo strumento Snapd. Utilizzeremo la versione Snapd.
Ubuntu 22.04 viene fornito con Snapd installato per impostazione predefinita. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.
$ sudo snap install core
$ sudo snap refresh core
Installa Certbot.
$ sudo snap install --classic certbot
Usa il seguente comando per assicurarti che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Esegui il seguente comando per generare un certificato SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d graphite.example.com
Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/graphite.example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Controlla il servizio del programma di rinnovo di Certbot.
$ sudo systemctl list-timers
Troverai snap.certbot.renew.service come uno dei servizi programmati per l’esecuzione.
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
Per controllare se il rinnovo SSL funziona correttamente, esegui un tentativo di prova del processo.
$ sudo certbot renew --dry-run
Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.
Passo 9 - Configurare Nginx
Apri il file /etc/nginx/nginx.conf per la modifica.
$ sudo nano /etc/nginx/nginx.conf
Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Crea e apri il file /etc/nginx/conf.d/uvdesk.conf per la modifica.
$ sudo nano /etc/nginx/conf.d/graphite.conf
Incolla il seguente codice in esso.
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;
}
Salva il file premendo Ctrl + X e inserendo Y quando richiesto una volta terminato.
Verifica la sintassi del file di configurazione di 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
Riavvia il servizio Nginx.
$ sudo systemctl restart nginx
Passo 10 - Accedere e utilizzare Graphite
Visita l’URL https://graphite.example.com nel tuo browser e vedrai la seguente schermata.
Clicca sul link Login in alto a destra per aprire la pagina di accesso. Inserisci le tue credenziali di superutente create nel passo 5 e premi il pulsante login per procedere.
Ci sono diversi metodi per alimentare dati a Graphite. Abbiamo aggiunto un matcher di pattern nello schema di archiviazione, secondo il quale qualsiasi pattern che inizia con test, sarà registrato come il nostro pattern. Aggiungiamo alcuni dati casuali utilizzando il seguente comando.
$ echo "test.count 9 `date +%s`" | nc -q0 127.0.0.1 2003;
Questo aggiungerà una metrica di dati di valore 9 al sistema. Aggiungiamo alcuni altri dati eseguendo un ciclo attraverso i valori.
$ 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
Torna alla dashboard di Graphite e apri Metrics >> test >> count dalla barra laterale sinistra. Dovresti vedere qualcosa di simile a quanto segue.
Ora puoi iniziare a usarlo per il monitoraggio. Puoi anche combinarlo con Grafana per ottenere un alto livello di personalizzazione.
Conclusione
Questo conclude il nostro tutorial su come installare e configurare Graphite su un server Ubuntu 22.04 insieme a Nginx come server proxy. Se hai domande, postale nei commenti qui sotto.
Ricevi i nuovi post nella tua casella di posta.
Nessuno spam. Disiscriviti in qualsiasi momento.