Monitoraggio di Prometheus: Configurazione Completa e Migliori Pratiche

Configura un monitoraggio dell'infrastruttura robusto con Prometheus

Indice

Prometheus è diventato lo standard de facto per il monitoraggio delle applicazioni e dell’infrastruttura cloud-native, offrendo la raccolta di metriche, interrogazioni e integrazione con strumenti di visualizzazione.

technical-diagram

Cosa è Prometheus?

Prometheus è un toolkit open-source per il monitoraggio e l’allerting, originariamente sviluppato da SoundCloud nel 2012 e ora un progetto graduate del Cloud Native Computing Foundation (CNCF). È stato progettato specificamente per la affidabilità e la scalabilità in ambienti cloud dinamici, diventando la soluzione di riferimento per il monitoraggio di microservizi, contenitori e cluster Kubernetes.

Funzionalità principali

Database a serie temporale: Prometheus archivia tutti i dati come serie temporali, identificate da nomi di metriche e coppie chiave-valore (etichette), abilitando capacità di interrogazione flessibili e potenti.

Modello basato su pull: A differenza dei sistemi tradizionali basati su push, Prometheus esegue attivamente il scraping delle metriche da destinazioni configurate a intervalli specifici, rendendolo più affidabile e più semplice da configurare.

Linguaggio di interrogazione PromQL: Un potente linguaggio funzionale di interrogazione consente di sezionare e manipolare i dati delle metriche in tempo reale, eseguendo aggregazioni, trasformazioni e calcoli complessi.

Scoperta dei servizi: Scoperta automatica dei destinazioni del monitoraggio tramite diversi meccanismi, tra cui Kubernetes, Consul, EC2 e configurazioni statiche.

Nessuna dipendenza esterna: Prometheus opera come un singolo binario senza dipendenze esterne necessarie, semplificando il deployment e riducendo la complessità operativa.

Allerting integrato: AlertManager gestisce gli allerti provenienti da Prometheus, fornendo deduplicazione, gruppo e routing ai canali di notifica come email, PagerDuty o Slack.

Panoramica dell’architettura

Comprendere l’architettura di Prometheus è cruciale per un deployment efficace. I componenti principali includono:

  • Server Prometheus: Scrapa e archivia le metriche, valuta le regole e serve le interrogazioni
  • Librerie client: Strumenta il codice dell’applicazione per esporre le metriche
  • Exporter: Collega sistemi terze al formato Prometheus
  • AlertManager: Gestisce gli allerti e le notifiche
  • Pushgateway: Accetta le metriche da job di breve durata che non possono essere scrape

Il tipico flusso dei dati: Le applicazioni espongono endpoint delle metriche → Prometheus effettua lo scraping di questi endpoint → I dati vengono archiviati nel database a serie temporale → Le interrogazioni PromQL recuperano e analizzano i dati → Gli allerti vengono generati in base alle regole → AlertManager processa e indirizza le notifiche.

Quando si distribuisce l’infrastruttura su Ubuntu 24.04, Prometheus fornisce una base eccellente per un monitoraggio completo.

Installazione di Prometheus su Ubuntu

Passiamo attraverso l’installazione di Prometheus su un sistema Linux. Utilizzeremo Ubuntu come esempio, ma il processo è simile per altre distribuzioni.

Scarica e installa

Prima di tutto, crea un utente dedicato per Prometheus:

sudo useradd --no-create-home --shell /bin/false prometheus

Scarica l’ultima versione di Prometheus:

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.48.0/prometheus-2.48.0.linux-amd64.tar.gz
tar xvf prometheus-2.48.0.linux-amd64.tar.gz
cd prometheus-2.48.0.linux-amd64

Copia i binari e crea le directory:

sudo cp prometheus /usr/local/bin/
sudo cp promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

sudo cp -r consoles /etc/prometheus
sudo cp -r console_libraries /etc/prometheus
sudo cp prometheus.yml /etc/prometheus/prometheus.yml
sudo chown -R prometheus:prometheus /etc/prometheus

Per la gestione dei pacchetti su Ubuntu, consulta la nostra completa guida alla gestione dei pacchetti in Ubuntu.

Configura Prometheus

Modifica /etc/prometheus/prometheus.yml:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093']

rule_files:
  - 'alert_rules.yml'

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']

Crea il servizio Systemd

Crea /etc/systemd/system/prometheus.service:

[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/ \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --storage.tsdb.retention.time=30d

[Install]
WantedBy=multi-user.target

Avvia e abilita Prometheus:

sudo systemctl daemon-reload
sudo systemctl start prometheus
sudo systemctl enable prometheus
sudo systemctl status prometheus

Accedi all’interfaccia web di Prometheus a http://localhost:9090.

Configurazione del Node Exporter

Il Node Exporter espone metriche hardware e del sistema operativo per i sistemi Linux. Installalo per monitorare i tuoi server:

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvf node_exporter-1.7.0.linux-amd64.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/node_exporter

Crea il servizio systemd /etc/systemd/system/node_exporter.service:

[Unit]
Description=Node Exporter
After=network.target

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

[Install]
WantedBy=multi-user.target

Avvia Node Exporter:

sudo systemctl daemon-reload
sudo systemctl start node_exporter
sudo systemctl enable node_exporter

Il Node Exporter espone ora le metriche sulla porta 9100.

Comprendere PromQL

PromQL (Prometheus Query Language) è il cuore dell’interrogazione dei dati di Prometheus. Ecco alcuni pattern di query essenziali:

Query di base

Seleziona tutte le serie temporali per una metrica:

node_cpu_seconds_total

Filtra per etichetta:

node_cpu_seconds_total{mode="idle"}

Filtri multipli per etichetta:

node_cpu_seconds_total{mode="idle",cpu="0"}

Vettori di intervallo e aggregazioni

Calcola il tasso nel tempo:

rate(node_cpu_seconds_total{mode="idle"}[5m])

Somma su tutti i CPU:

sum(rate(node_cpu_seconds_total{mode="idle"}[5m]))

Gruppo per etichetta:

sum by (mode) (rate(node_cpu_seconds_total[5m]))

Esempi pratici

Percentuale di utilizzo CPU:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Utilizzo della memoria:

(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

Utilizzo del disco:

(node_filesystem_size_bytes - node_filesystem_avail_bytes) / node_filesystem_size_bytes * 100

Tasso di traffico di rete:

rate(node_network_receive_bytes_total[5m])

Deployment in Docker

Eseguire Prometheus in contenitori Docker offre flessibilità e gestione più semplice:

Crea docker-compose.yml:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  node_exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    command:
      - '--path.rootfs=/host'
    volumes:
      - '/:/host:ro,rslave'
    ports:
      - "9100:9100"
    restart: unless-stopped

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
      - alertmanager_data:/alertmanager
    ports:
      - "9093:9093"
    restart: unless-stopped

volumes:
  prometheus_data:
  alertmanager_data:

Avvia lo stack:

docker-compose up -d

Monitoraggio di Kubernetes

Prometheus eccelle nel monitoraggio dei cluster Kubernetes. Il Helm chart kube-prometheus-stack fornisce una soluzione completa di monitoraggio.

Installa utilizzando Helm:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack

Questo installa:

  • Prometheus Operator
  • Istanza Prometheus
  • AlertManager
  • Grafana
  • Node Exporter
  • kube-state-metrics
  • Dashboard e allerti preconfigurati

Accedi a Grafana:

kubectl port-forward svc/prometheus-grafana 3000:80

Credenziali predefinite: admin/prom-operator

Per diverse distribuzioni Kubernetes, il processo di deployment è simile con piccole modifiche per le caratteristiche specifiche della piattaforma.

Configurazione dell’allerting

AlertManager gestisce gli allerti inviati da Prometheus. Configura le regole degli allerti e i canali di notifica.

Regole degli allerti

Crea /etc/prometheus/alert_rules.yml:

groups:
  - name: system_alerts
    interval: 30s
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Utilizzo CPU elevato su {{ $labels.instance }}"
          description: "L'utilizzo della CPU è superiore al 80% (valore corrente: {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Utilizzo della memoria elevato su {{ $labels.instance }}"
          description: "L'utilizzo della memoria è superiore all'85% (valore corrente: {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Spazio su disco insufficiente su {{ $labels.instance }}"
          description: "Lo spazio disponibile sul disco è inferiore al 15% su {{ $labels.mountpoint }}"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "L'istanza {{ $labels.instance }} è inattiva"
          description: "L'istanza {{ $labels.job }} {{ $labels.instance }} è inattiva da più di 2 minuti"

Configurazione di AlertManager

Crea /etc/prometheus/alertmanager.yml:

global:
  resolve_timeout: 5m
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: 'alerts@example.com'
  smtp_auth_username: 'alerts@example.com'
  smtp_auth_password: 'your-password'

route:
  group_by: ['alertname', 'cluster', 'service']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 12h
  receiver: 'team-email'
  routes:
    - match:
        severity: critical
      receiver: 'team-pagerduty'
    - match:
        severity: warning
      receiver: 'team-slack'

receivers:
  - name: 'team-email'
    email_configs:
      - to: 'team@example.com'
        headers:
          Subject: '{{ .GroupLabels.alertname }}: {{ .Status | toUpper }}'

  - name: 'team-slack'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#alerts'
        title: 'Alert: {{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

  - name: 'team-pagerduty'
    pagerduty_configs:
      - service_key: 'your-pagerduty-key'

Integrazione con Grafana

Sebbene Prometheus abbia un’interfaccia web di base, Grafana fornisce una visualizzazione superiore per la creazione di dashboard comprensive.

Aggiungi Prometheus come fonte di dati

  1. Apri Grafana e vai su Configurazione → Fonti di dati
  2. Clicca su “Aggiungi fonte di dati”
  3. Seleziona “Prometheus”
  4. Imposta l’URL su http://localhost:9090 (o il tuo server Prometheus)
  5. Clicca su “Salva & Test”

ID dei dashboard popolari

Importa dashboard predefinite da grafana.com:

  • Node Exporter Full (ID: 1860): Metriche complete per Linux
  • Kubernetes Cluster Monitoring (ID: 7249): Panoramica di K8s
  • Docker Container Monitoring (ID: 193): Metriche dei container
  • Prometheus Stats (ID: 2): Metriche interne di Prometheus

Creare dashboard personalizzate

Crea pannelli utilizzando le query PromQL:

{
  "title": "Utilizzo CPU",
  "targets": [{
    "expr": "100 - (avg(rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)"
  }]
}

Exporter popolari

Espandi il monitoraggio di Prometheus con degli exporter specializzati:

Blackbox Exporter

Prova endpoint tramite HTTP, HTTPS, DNS, TCP e ICMP:

scrape_configs:
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - https://example.com
          - https://api.example.com
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: localhost:9115

Exporter per database

  • mysqld_exporter: Metriche per MySQL/MariaDB
  • postgres_exporter: Metriche per PostgreSQL
  • mongodb_exporter: Metriche per MongoDB
  • redis_exporter: Metriche per Redis

Exporter per applicazioni

  • nginx_exporter: Metriche del server web NGINX
  • apache_exporter: Metriche del server HTTP Apache
  • haproxy_exporter: Metriche del bilanciatore di carico HAProxy

Exporter per cloud

  • cloudwatch_exporter: Metriche di AWS CloudWatch
  • stackdriver_exporter: Metriche di Google Cloud
  • azure_exporter: Metriche di Azure Monitor

Best Practices

Retention dei dati

Configura una retention appropriata in base alle tue esigenze:

--storage.tsdb.retention.time=30d
--storage.tsdb.retention.size=50GB

Regole di registrazione

Pre-calcola espressioni spesso interrogate:

groups:
  - name: example_rules
    interval: 30s
    rules:
      - record: job:node_cpu_utilization:avg
        expr: 100 - (avg by (job) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Gestione delle etichette

  • Mantieni bassa la cardinalità delle etichette
  • Usa convenzioni di nomi coerenti
  • Evita etichette ad alta cardinalità (ID utente, timestamp)

Sicurezza

  • Abilita l’autenticazione e l’HTTPS
  • Limita l’accesso all’API di Prometheus
  • Usa politiche di rete in Kubernetes
  • Implementa RBAC per le metriche sensibili

Alta disponibilità

  • Esegui più istanze di Prometheus
  • Usa Thanos o Cortex per lo storage a lungo termine
  • Implementa la federazione per le configurazioni gerarchiche

Risoluzione dei problemi comuni

Alto utilizzo della memoria

  • Riduci la frequenza di scraping
  • Riduci il periodo di retention
  • Ottimizza le query PromQL
  • Implementa le regole di registrazione

Metriche mancanti

  • Controlla lo stato dei target in /targets
  • Verifica la connettività di rete
  • Valida la configurazione di scraping
  • Controlla i log dell’exporter

Query lente

  • Usa le regole di registrazione per le aggregazioni complesse
  • Ottimizza i filtri delle etichette
  • Riduci l’intervallo temporale
  • Aggiungi indici se si utilizza lo storage remoto

Ottimizzazione delle prestazioni

Ottimizzazione delle query

# Cattivo: Alta cardinalità
sum(rate(http_requests_total[5m]))

# Buono: Gruppo per etichette rilevanti
sum by (status, method) (rate(http_requests_total[5m]))

Limiti di risorse

Per le distribuzioni Kubernetes:

resources:
  requests:
    memory: "2Gi"
    cpu: "1000m"
  limits:
    memory: "4Gi"
    cpu: "2000m"

Conclusione

Prometheus fornisce una soluzione robusta e scalabile per il monitoraggio dell’infrastruttura moderna. La sua architettura basata su pull, il potente linguaggio di interrogazione e l’ampio ecosistema degli exporter lo rendono ideale per il monitoraggio di tutto, dalle macchine fisiche ai complessi cluster Kubernetes.

Combinando Prometheus con Grafana per la visualizzazione e AlertManager per le notifiche, si crea una piattaforma di osservabilità completa in grado di gestire le esigenze di monitoraggio su larga scala. La comunità attiva e il supporto CNCF garantiscono uno sviluppo continuo e supporto.

Inizia con la raccolta di metriche di base, aggiungi gradualmente gli exporter per i tuoi servizi specifici e raffina le regole degli allerti in base all’esperienza reale. Prometheus scala con la tua infrastruttura, da deployment su singoli server a architetture di monitoraggio multi-datacenter.

Risorse correlate

Riferimenti esterni