IT

Applicazioni

Installare Prometheus e Grafana

Installa Prometheus, node_exporter e Grafana senza Docker su Debian o Ubuntu, con dashboard, accesso HTTPS protetto, aggiornamenti e backup.

7 min di lettura, aggiornato il 18 novembre 2026

In questa pagina

I tuoi valori

Inseriscili una volta: i comandi della guida si aggiornano.

Questa guida spiega come installare una piattaforma di monitoraggio completa, senza Docker, su un VPS o un server dedicato con Debian 12/13 o Ubuntu 22.04/24.04.

Componente Ruolo Porta Ascolto
node_exporter Espone le metriche del sistema 9100 127.0.0.1
Prometheus Raccoglie e memorizza le metriche 9090 127.0.0.1
Grafana Mostra le dashboard 3000 127.0.0.1
Nginx Pubblica Grafana in HTTPS 80, 443 Pubblico

Solo Grafana viene pubblicato, dietro Nginx, in HTTPS e con un account. Prometheus e node_exporter non sono mai esposti su Internet.

Ordinare un server

Per ospitare il tuo sistema di monitoraggio, HostMyServers offre diverse opzioni:

Prerequisiti

  • Un server con Debian 12/13 o Ubuntu 22.04/24.04, con architettura amd64 o arm64
  • Un accesso SSH con un utente che dispone di sudo
  • Un nome di dominio con un record A: grafana.tuo-dominio.com deve puntare all'indirizzo IP del server
  • Per Grafana, almeno 512 MB di RAM e 1 core CPU secondo la sua documentazione, in aggiunta alle esigenze di Prometheus
  • Spazio disco per le metriche: dipende dal numero di serie raccolte e dal periodo di conservazione

Preparare il server

Terminale
sudo apt update
sudo apt upgrade -y
sudo apt install -y curl wget tar jq gnupg ufw nginx certbot python3-certbot-nginx apache2-utils

Configura il firewall. Consenti SSH prima di attivare UFW e sostituisci 22 se usi un'altra porta.

Terminale
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw allow 80,443/tcp
sudo ufw enable

Le porte 3000, 9090 e 9100 non devono essere aperte.

Installare Prometheus

Creare l'utente e le cartelle

Terminale
sudo useradd --system --no-create-home --shell /usr/sbin/nologin prometheus
sudo mkdir -p /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Scaricare e verificare l'archivio

Terminale
VERSION=3.13.5
ARCH=$(dpkg --print-architecture)
cd "$(mktemp -d)"
wget "https://github.com/prometheus/prometheus/releases/download/v${VERSION}/prometheus-${VERSION}.linux-${ARCH}.tar.gz"
wget "https://github.com/prometheus/prometheus/releases/download/v${VERSION}/sha256sums.txt"
sha256sum --check --ignore-missing sha256sums.txt
tar -xzf "prometheus-${VERSION}.linux-${ARCH}.tar.gz"
sudo install -m 0755 "prometheus-${VERSION}.linux-${ARCH}/prometheus" "prometheus-${VERSION}.linux-${ARCH}/promtool" /usr/local/bin/
prometheus --version

La verifica deve mostrare OK per l'archivio scaricato.

Configurare la raccolta

Terminale
sudo nano /etc/prometheus/prometheus.yml
YAML
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets: ["127.0.0.1:9090"]

  - job_name: node
    static_configs:
      - targets: ["127.0.0.1:9100"]

Controlla il file:

Terminale
sudo chown -R root:prometheus /etc/prometheus
sudo chmod 750 /etc/prometheus
sudo chmod 640 /etc/prometheus/prometheus.yml
sudo promtool check config /etc/prometheus/prometheus.yml

Creare il servizio systemd

Terminale
sudo nano /etc/systemd/system/prometheus.service
Configurazione
[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus \
  --storage.tsdb.retention.time=30d \
  --web.listen-address=127.0.0.1:9090 \
  --web.enable-admin-api
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
NoNewPrivileges=true
ProtectSystem=full
ProtectHome=true
PrivateTmp=true

[Install]
WantedBy=multi-user.target
Opzione Effetto
--storage.tsdb.retention.time=30d Conserva 30 giorni di metriche (15 giorni per impostazione predefinita)
--web.listen-address=127.0.0.1:9090 Ascolta solo sull'interfaccia locale
--web.enable-admin-api Attiva l'API usata per i backup tramite snapshot

Avvia il servizio:

Terminale
sudo systemctl daemon-reload
sudo systemctl enable --now prometheus
sudo systemctl status prometheus --no-pager

Installare node_exporter

Terminale
sudo useradd --system --no-create-home --shell /usr/sbin/nologin node_exporter
VERSION=1.13.0
ARCH=$(dpkg --print-architecture)
cd "$(mktemp -d)"
wget "https://github.com/prometheus/node_exporter/releases/download/v${VERSION}/node_exporter-${VERSION}.linux-${ARCH}.tar.gz"
wget "https://github.com/prometheus/node_exporter/releases/download/v${VERSION}/sha256sums.txt"
sha256sum --check --ignore-missing sha256sums.txt
tar -xzf "node_exporter-${VERSION}.linux-${ARCH}.tar.gz"
sudo install -m 0755 "node_exporter-${VERSION}.linux-${ARCH}/node_exporter" /usr/local/bin/
sudo nano /etc/systemd/system/node_exporter.service
Configurazione
[Unit]
Description=Prometheus Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter --web.listen-address=127.0.0.1:9100
Restart=on-failure
NoNewPrivileges=true

[Install]
WantedBy=multi-user.target
Terminale
sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter
curl -s http://127.0.0.1:9100/metrics | head -n 5

Verifica che Prometheus raccolga correttamente entrambi i target. Attendi una quindicina di secondi dopo l'avvio:

Terminale
curl -s http://127.0.0.1:9090/api/v1/targets | jq -r '.data.activeTargets[] | "\(.labels.job) \(.health)"'

Il risultato atteso è:

Testo
node up
prometheus up

Installare Grafana

Aggiungere il repository ufficiale

Terminale
sudo mkdir -p /etc/apt/keyrings
sudo wget -O /etc/apt/keyrings/grafana.asc https://apt.grafana.com/gpg-full.key
sudo chmod 644 /etc/apt/keyrings/grafana.asc
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 update
sudo apt install -y grafana

Limitare Grafana all'interfaccia locale

L'account iniziale di Grafana è admin / admin. Limita l'ascolto prima del primo avvio:

Terminale
sudo nano /etc/grafana/grafana.ini

Nella sezione [server], decommenta o aggiungi:

Configurazione
[server]
http_addr = 127.0.0.1
http_port = 3000

Avvia il servizio e verifica che risponda:

Terminale
sudo systemctl daemon-reload
sudo systemctl enable --now grafana-server
sudo ss -tlnp | grep 3000
curl -s http://127.0.0.1:3000/api/health

Cambiare la password dell'amministratore

Cambia la password prima di pubblicare Grafana. Dal tuo computer, apri un tunnel SSH e lascia aperta questa sessione:

Terminale
ssh -L 3000:127.0.0.1:3000 TUO_USER@IP_DEL_TUO_SERVER

Apri http://localhost:3000, accedi con admin / admin, poi imposta una password robusta quando Grafana te lo chiede. Puoi quindi chiudere il tunnel.

Dichiarare Prometheus come origine dati

Terminale
sudo nano /etc/grafana/provisioning/datasources/prometheus.yaml
YAML
apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://127.0.0.1:9090
    isDefault: true
    editable: false
Terminale
sudo chown root:grafana /etc/grafana/provisioning/datasources/prometheus.yaml
sudo chmod 640 /etc/grafana/provisioning/datasources/prometheus.yaml
sudo systemctl restart grafana-server

Pubblicare Grafana in HTTPS

Creare il sito Nginx

Terminale
sudo nano /etc/nginx/sites-available/grafana.conf
Nginx
map $http_upgrade $connection_upgrade {
    default upgrade;
    '' close;
}

upstream grafana {
    server 127.0.0.1:3000;
}

server {
    listen 80;
    listen [::]:80;
    server_name grafana.tuo-dominio.com;

    location / {
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_pass http://grafana;
    }

    location /api/live/ {
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header Host $host;
        proxy_pass http://grafana;
    }
}
Terminale
sudo ln -s /etc/nginx/sites-available/grafana.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
sudo certbot --nginx -d grafana.tuo-dominio.com -m admin@tuo-dominio.com --agree-tos --no-eff-email --redirect
sudo certbot renew --dry-run

Per maggiori dettagli sui certificati, consulta la guida Installare un certificato SSL con Let's Encrypt.

Completare la configurazione di Grafana

Terminale
sudo nano /etc/grafana/grafana.ini

Adatta le sezioni seguenti:

Configurazione
[server]
http_addr = 127.0.0.1
http_port = 3000
domain = grafana.tuo-dominio.com
root_url = https://grafana.tuo-dominio.com/

[security]
cookie_secure = true
cookie_samesite = lax
strict_transport_security = true

[users]
allow_sign_up = false
Terminale
sudo systemctl restart grafana-server

Importare una dashboard

  1. Apri https://grafana.tuo-dominio.com e accedi.
  2. Clicca su Dashboards nel menu principale.
  3. Clicca su New, poi su Import dashboard.
  4. Inserisci l'identificativo 1860 (Node Exporter Full) e clicca su Load.
  5. Seleziona l'origine dati Prometheus, poi clicca su Import.

Verificare l'installazione

Sul server, nessun servizio interno deve essere in ascolto su un indirizzo pubblico:

Terminale
sudo ss -tlnp | grep -E ':(3000|9090|9100)\b'

Ogni riga deve iniziare con 127.0.0.1. Dal tuo computer, questi comandi devono fallire:

Terminale
curl -m 5 http://IP_DEL_TUO_SERVER:3000/
curl -m 5 http://IP_DEL_TUO_SERVER:9090/
curl -m 5 http://IP_DEL_TUO_SERVER:9100/metrics

Infine, https://grafana.tuo-dominio.com deve mostrare la pagina di accesso, con un certificato valido.

Per consultare l'interfaccia di Prometheus, passa da un tunnel SSH, poi apri http://localhost:9090:

Terminale
ssh -L 9090:127.0.0.1:9090 TUO_USER@IP_DEL_TUO_SERVER

Proteggere Prometheus con una password (facoltativo)

L'ascolto locale impedisce già qualsiasi accesso da Internet. Aggiungi una password se altri utenti o applicazioni hanno accesso al server.

Genera prima l'hash della password:

Terminale
htpasswd -nBC 12 "" | tr -d ':\n'; echo

Crea /etc/prometheus/web.yml con sudo nano, poi incollaci questo hash:

YAML
basic_auth_users:
  admin: "HASH_BCRYPT"

Salva anche la password in chiaro, necessaria a Prometheus per raccogliere le proprie metriche:

Terminale
sudo install -o root -g prometheus -m 640 /dev/null /etc/prometheus/web-password
sudo nano /etc/prometheus/web-password
sudo chown root:prometheus /etc/prometheus/web.yml
sudo chmod 640 /etc/prometheus/web.yml
sudo promtool check web-config /etc/prometheus/web.yml

Applica poi queste tre modifiche:

  1. In prometheus.service, aggiungi --web.config.file=/etc/prometheus/web.yml al comando ExecStart.

  2. In prometheus.yml, completa il job prometheus:

    YAML
    - job_name: prometheus
      basic_auth:
        username: admin
        password_file: /etc/prometheus/web-password
      static_configs:
        - targets: ["127.0.0.1:9090"]
  3. Nell'origine dati di Grafana, aggiungi le credenziali:

    YAML
    basicAuth: true
    basicAuthUser: admin
    secureJsonData:
      basicAuthPassword: TUA_PASSWORD_PROMETHEUS

Ricarica la configurazione e riavvia i servizi:

Terminale
sudo promtool check config /etc/prometheus/prometheus.yml
sudo systemctl daemon-reload
sudo systemctl restart prometheus grafana-server

D'ora in poi aggiungi -u admin ai comandi curl rivolti alla porta 9090.

Monitorare un altro server

Installa node_exporter sul secondo server, con --web.listen-address=0.0.0.0:9100 nel suo servizio. Su questo secondo server, autorizza solo il tuo server Prometheus:

Terminale
sudo ufw allow from IP_DEL_TUO_SERVER to any port 9100 proto tcp

Aggiungi poi il target in /etc/prometheus/prometheus.yml, quindi ricarica Prometheus:

YAML
  - job_name: node
    static_configs:
      - targets: ["127.0.0.1:9100", "IP_SECONDO_SERVER:9100"]
Terminale
sudo promtool check config /etc/prometheus/prometheus.yml
sudo systemctl reload prometheus

Aggiornare

Esegui prima il backup dei dati e leggi le note di rilascio.

Prometheus: ripeti il blocco di download con il nuovo valore di VERSION, poi:

Terminale
sudo promtool check config /etc/prometheus/prometheus.yml
sudo systemctl restart prometheus
prometheus --version

node_exporter: ripeti allo stesso modo download e installazione, poi:

Terminale
sudo systemctl restart node_exporter
node_exporter --version

Grafana: il pacchetto si aggiorna con APT.

Terminale
sudo apt update
sudo apt install --only-upgrade grafana
sudo systemctl restart grafana-server

Eseguire backup e ripristino

Prometheus

La documentazione di Prometheus consiglia gli snapshot:

Terminale
SNAPSHOT=$(curl -fsS -X POST http://127.0.0.1:9090/api/v1/admin/tsdb/snapshot | jq -r '.data.name')
sudo tar -czpf "/root/prometheus-${SNAPSHOT}.tar.gz" -C /var/lib/prometheus/snapshots "$SNAPSHOT"
sudo rm -rf "/var/lib/prometheus/snapshots/${SNAPSHOT}"
sudo tar -czpf "/root/prometheus-config-$(date +%F).tar.gz" /etc/prometheus /etc/systemd/system/prometheus.service

Per ripristinare uno snapshot:

Terminale
sudo systemctl stop prometheus
sudo mv /var/lib/prometheus /var/lib/prometheus.old
sudo mkdir /var/lib/prometheus
sudo tar -xzpf /root/prometheus-NOME_SNAPSHOT.tar.gz --strip-components=1 -C /var/lib/prometheus
sudo chown -R prometheus:prometheus /var/lib/prometheus
sudo systemctl start prometheus

Grafana

Per impostazione predefinita, Grafana memorizza account e dashboard nel database SQLite /var/lib/grafana/grafana.db. Ferma il servizio durante la copia:

Terminale
sudo systemctl stop grafana-server
sudo tar -czpf "/root/grafana-$(date +%F).tar.gz" /var/lib/grafana /etc/grafana
sudo systemctl start grafana-server

Per ripristinare:

Terminale
sudo systemctl stop grafana-server
sudo tar -xzpf /root/grafana-AAAA-MM-GG.tar.gz -C /
sudo chown -R grafana:grafana /var/lib/grafana
sudo systemctl start grafana-server

Questi archivi contengono dati sensibili: limita i loro permessi con sudo chmod 600 /root/*.tar.gz e copiali fuori dal server.

In caso di problemi

Prometheus non si avvia

Terminale
sudo journalctl -u prometheus -n 50 --no-pager
sudo promtool check config /etc/prometheus/prometheus.yml
sudo ls -ld /var/lib/prometheus

Un errore permission denied sulla cartella dei dati si risolve con sudo chown -R prometheus:prometheus /var/lib/prometheus. address already in use significa che un altro processo occupa la porta 9090: individualo con sudo ss -tlnp | grep 9090.

Un target è nello stato down

Consulta il campo lastError:

Terminale
curl -s http://127.0.0.1:9090/api/v1/targets | jq '.data.activeTargets[] | {job: .labels.job, health, lastError}'

connection refused indica che l'exporter è fermo o è in ascolto su un altro indirizzo. Un context deadline exceeded verso un altro server fa pensare piuttosto al firewall.

Errore 502 Bad Gateway su Grafana

Terminale
sudo systemctl status grafana-server --no-pager
sudo journalctl -u grafana-server -n 50 --no-pager
curl -s http://127.0.0.1:3000/api/health

Ciclo di accesso o messaggio « origin not allowed »

Verifica che domain e root_url corrispondano esattamente all'indirizzo usato nel browser e che l'intestazione Host venga trasmessa correttamente da Nginx. cookie_secure = true richiede un accesso in HTTPS.

La dashboard non mostra alcun dato

  • Verifica che entrambi i target siano up.
  • Allarga il periodo visualizzato a qualche ora.
  • Nella dashboard, verifica che l'origine dati, il job e l'istanza selezionati siano corretti.

Password dell'amministratore di Grafana persa

Reimpostala dal server, poi cambiala di nuovo nell'interfaccia:

Terminale
sudo -u grafana grafana cli --homepath /usr/share/grafana --config /etc/grafana/grafana.ini admin reset-admin-password PASSWORD_TEMPORANEA

Il disco si riempie

Riduci --storage.tsdb.retention.time, oppure aggiungi un limite con --storage.tsdb.retention.size=10GB, poi esegui sudo systemctl daemon-reload e sudo systemctl restart prometheus. La guida Verificare spazio disco e utilizzo in Linux ti aiuta a individuare ciò che occupa lo spazio.

Per approfondire

Se cerchi una soluzione più semplice per un solo server, consulta la guida Monitorare il tuo server con Netdata.

Riferimenti