Ricerca nel sito web

Come installare TIG Stack (Telegraf, InfluxDB e Grafana) su Debian 12


Lo stack TIG (Telegraf, InfluxDB e Grafana) è l'acronimo di una piattaforma di strumenti open source per semplificare la raccolta, l'archiviazione, la creazione di grafici e gli avvisi delle metriche di sistema. Puoi monitorare e visualizzare parametri quali memoria, spazio su disco, utenti registrati, carico del sistema, utilizzo dello swap, tempo di attività, processi in esecuzione, ecc. da un unico posto. Gli strumenti utilizzati nello stack sono i seguenti:

  • Telegraf: è un agente di raccolta di metriche open source per la raccolta e l'invio di dati ed eventi da database, sistemi e sensori IoT. Supporta vari plugin di output come InfluxDB, Graphite, Kafka, ecc. a cui può inviare i dati raccolti.
  • InfluxDB: è un database di serie temporali open source scritto nel linguaggio Go. È ottimizzato per un'archiviazione veloce e ad alta disponibilità ed è adatto a qualsiasi cosa coinvolga grandi quantità di dati con timestamp, inclusi parametri, eventi e analisi in tempo reale.
  • Grafana: è una suite di visualizzazione e monitoraggio dei dati open source. Supporta vari plugin di input come Graphite, ElasticSearch, InfluxDB, ecc. Fornisce una bellissima dashboard e analisi metriche che ti consentono di visualizzare e monitorare qualsiasi tipo di metrica di sistema e dati sulle prestazioni.

In questo tutorial imparerai come installare e configurare lo stack TIG su un singolo server Debian 12.

Prerequisiti

    Un server che esegue Debian 12 con un minimo di 1 GB di RAM.

    Un utente non sudo con privilegi root.

    Il semplice Firewall (UFW) è abilitato e funzionante.

    Un nome di dominio completo (FQDN) come grafana.example.com che punta al tuo server.

    Un account SMTP con un servizio e-mail come Amazon SES o Mailgun per ricevere notifiche e-mail per gli avvisi di servizio.

    Assicurati che tutto sia aggiornato.

    $ sudo apt update && sudo apt upgrade
    

    Sono necessari alcuni pacchetti essenziali per l'esecuzione del tutorial e di Craft CMS. Alcuni di questi saranno già sul tuo server.

    $ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y
    

Passaggio 1: configurare il firewall

Prima di installare qualsiasi pacchetto, il primo passo è configurare il firewall per aprire le porte per InfluxDB e Grafana.

Controlla lo stato del firewall.

$ sudo ufw status

Dovresti vedere qualcosa di simile al seguente.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Apri la porta 8086 per InfluxDB e 3000 per il server Grafana.

$ sudo ufw allow 8086
$ sudo ufw allow 3000

Consenti 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
8086                       ALLOW       Anywhere
3000                       ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
8086 (v6)                  ALLOW       Anywhere (v6)
3000 (v6)                  ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Passaggio 2: installare InfluxDB

Utilizzeremo il repository ufficiale di InfluxDB per installarlo.

Scarica la chiave GPG InfluxDB.

$ wget -q https://repos.influxdata.com/influxdata-archive_compat.key

Importa la chiave GPG nel server.

$ 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
influxdata-archive_compat.key: OK

Importa il repository InfluxDB.

$ 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

Aggiorna l'elenco dei repository del sistema.

$ sudo apt update

Hai la possibilità di installare InfluxDB 1.8.xo 2.0.x. Tuttavia, è meglio utilizzare la versione più recente. Installa InfluxDB.

$ sudo apt install influxdb2

Avvia il servizio InfluxDB.

$ sudo systemctl start influxdb

Controlla lo stato del servizio.

$ sudo systemctl status influxdb
? influxdb.service - InfluxDB is an open-source, distributed, time series database
     Loaded: loaded (/lib/systemd/system/influxdb.service; enabled; preset: enabled)
     Active: active (running) since Tue 2024-01-02 02:39:41 UTC; 1s ago
       Docs: https://docs.influxdata.com/influxdb/
    Process: 5584 ExecStart=/usr/lib/influxdb/scripts/influxd-systemd-start.sh (code=exited, status=0/SUCCESS)
   Main PID: 5585 (influxd)
      Tasks: 8 (limit: 2299)
     Memory: 53.1M
        CPU: 735ms
     CGroup: /system.slice/influxdb.service
             ??5585 /usr/bin/influxd
........

Passaggio 3: creare il database InfluxDB e le credenziali dell'utente

Per memorizzare i dati da Telegraf, è necessario configurare il database e l'utente Influx.

InfluxDB viene fornito con uno strumento da riga di comando denominato influx per interagire con il server InfluxDB. Pensa a influx come allo strumento da riga di comando mysql.

Eseguire il comando seguente per eseguire la configurazione iniziale per Influx.

$ influx setup
> Welcome to InfluxDB 2.0!
? Please type your primary username navjot
? Please type your password ***************
? Please type your password again ***************
? Please type your primary organization name howtoforge
? Please type your primary bucket name tigstack
? Please type your retention period in hours, or 0 for infinite 360
? Setup with these parameters?
  Username:          navjot
  Organization:      howtoforge
  Bucket:            tigstack
  Retention Period:  360h0m0s
 Yes
User    Organization    Bucket
navjot  howtoforge      tigstack

È necessario impostare il nome utente iniziale, la password, il nome dell'organizzazione, il nome del bucket principale in cui archiviare i dati e il periodo di conservazione in ore per tali dati. I tuoi dati sono memorizzati nel file /home/username/.influxdbv2/configs.

Puoi anche eseguire questa configurazione avviando l'URL http://:8086/ nel tuo browser. Una volta eseguita la configurazione iniziale, è possibile accedere all'URL con le credenziali create sopra.

Dovresti essere accolto con la seguente dashboard.

Il processo di configurazione iniziale crea un token predefinito che dispone dell'accesso completo in lettura e scrittura a tutte le organizzazioni nel database. Per motivi di sicurezza è necessario un nuovo token che si connetterà solo all'organizzazione e al bucket a cui vogliamo connetterci.

Per creare un nuovo token, fai clic sulla seguente icona nella barra laterale di sinistra e fai clic sul collegamento Token API per procedere.

Verrai indirizzato alla pagina Token API. Qui vedrai il token predefinito che abbiamo creato al momento della configurazione iniziale.

Fai clic sul pulsante Genera token API e seleziona l'opzione Token API personalizzato per avviare un nuovo popup in overlay. Dai un nome al token (telegraf) ed espandi la sezione Risorse e seleziona il bucket predefinito che abbiamo creato nelle sezioni Leggi e Scrivi.

Fai clic su Genera per completare la creazione del token. Fai clic sul pulsante COPIA NEGLI APPUNTI per copiare il token. In alcuni casi il pulsante potrebbe non funzionare, quindi assicurati di confermare prima di chiudere il popup.

Conservatelo per ora poiché ne avremo bisogno in seguito.

Questo completa l'installazione e la configurazione di InfluxDB. Successivamente, dobbiamo installare Telegraf.

Passaggio 4: installare Telegraf

Telegraf e InfluxDB condividono lo stesso repository. Significa che puoi installare direttamente Telegraf.

$ sudo apt install telegraf

Il servizio di Telegraf viene abilitato e avviato automaticamente durante l'installazione.

Telegraf è un agente basato su plug-in e dispone di 4 tipi di plug-in:

  1. I plug-in di input raccolgono metriche.
  2. I plug-in del processore trasformano, decorano e filtrano le metriche.
  3. I plug-in aggregatori creano e aggregano metriche.
  4. I plug-in di output definiscono le destinazioni in cui vengono inviate le metriche, incluso InfluxDB.

Telegraf memorizza la sua configurazione per tutti questi plugin nel file /etc/telegraf/telegraf.conf. Il primo passo è connettere Telegraf a InfluxDB abilitando il plugin di output influxdb_v2. Apri il file /etc/telegraf/telegraf.conf per modificarlo.

$ sudo nano /etc/telegraf/telegraf.conf

Trova la riga [[outputs.influxdb_v2]] e decommenta rimuovendo il # davanti ad essa. Modifica il codice sottostante nel modo seguente.

# # Configuration for sending metrics to InfluxDB 2.0
 [[outputs.influxdb_v2]]
#   ## The URLs of the InfluxDB cluster nodes.
#   ##
#   ## Multiple URLs can be specified for a single cluster, only ONE of the
#   ## urls will be written to each interval.
#   ##   ex: urls = ["https://us-west-2-1.aws.cloud2.influxdata.com"]
    urls = ["http://127.0.0.1:8086"]
#
#   ## Token for authentication.
   token = "$INFLUX_TOKEN"
#
#   ## Organization is the name of the organization you wish to write to.
   organization = "howtoforge"
#
#   ## Destination bucket to write into.
   bucket = "tigstack"

Incolla il valore del token InfluxDB salvato in precedenza al posto della variabile $INFLUX_TOKEN nel codice precedente.

Cerca la riga INPUT PLUGINS e vedrai i seguenti plugin di input abilitati per impostazione predefinita.

# Read metrics about cpu usage
[[inputs.cpu]]
  ## Whether to report per-cpu stats or not
  percpu = true
  ## Whether to report total system cpu stats or not
  totalcpu = true
  ## If true, collect raw CPU time metrics
  collect_cpu_time = false
  ## If true, compute and report the sum of all non-idle CPU states
  report_active = false
  ## If true and the info is available then add core_id and physical_id tags
  core_tags = false


# Read metrics about disk usage by mount point
[[inputs.disk]]
  ## By default stats will be gathered for all mount points.
  ## Set mount_points will restrict the stats to only the specified mount points.
  # mount_points = ["/"]

  ## Ignore mount points by filesystem type.
  ignore_fs = ["tmpfs", "devtmpfs", "devfs", "iso9660", "overlay", "aufs", "squashfs"]

  ## Ignore mount points by mount options.
  ## The 'mount' command reports options of all mounts in parathesis.
  ## Bind mounts can be ignored with the special 'bind' option.
  # ignore_mount_opts = []


# Read metrics about disk IO by device
[[inputs.diskio]]
....
....

# Get kernel statistics from /proc/stat
[[inputs.kernel]]
  # no configuration


# Read metrics about memory usage
[[inputs.mem]]
  # no configuration
  
# Get the number of processes and group them by status
[[inputs.processes]]
  # no configuration


# Read metrics about swap memory usage
[[inputs.swap]]
  # no configuration


# Read metrics about system load & uptime
[[inputs.system]]
  # no configuration

Puoi configurare plug-in di input aggiuntivi a seconda delle tue esigenze, inclusi Apache Server, contenitori Docker, Elasticsearch, firewall iptables, Kubernetes, Memcached, MongoDB, MySQL, Nginx, PHP-fpm, Postfix, RabbitMQ, Redis, Varnish, Wireguard, PostgreSQL, ecc.

Una volta terminato, salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Riavvia il servizio Telegraf una volta terminata l'applicazione delle modifiche.

$ sudo systemctl restart telegraf

Passaggio 5: verificare se le statistiche di Telegraf sono archiviate in InfluxDB

Prima di procedere oltre, è necessario verificare se le statistiche di Telegraf sono correttamente raccolte e inserite in InfluxDB. Apri l'interfaccia utente di InfluxDB nel tuo browser, fai clic sulla seconda icona dalla barra laterale sinistra e seleziona il menu Bucket.

Fai clic su tigstack e dovresti essere accolto con la pagina seguente.

Fai clic sul nome del bucket, quindi su uno dei valori nel filtro _measurement e continua a fare clic sugli altri valori man mano che vengono visualizzati. Una volta terminato, fai clic sul pulsante Invia. Dovresti vedere un grafico in alto. Potrebbe essere necessario attendere un po' di tempo prima che i dati vengano visualizzati. Abbiamo spostato l'intervallo di tempo da Ultima 1 ora a Ultimi 5 minuti per generare un grafico su un'ampia area.

Ciò dovrebbe confermare che i dati vengono trasmessi correttamente.

Passaggio 6: installare Grafana

Utilizzeremo il repository ufficiale Grafana per installarlo. Importa la chiave 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

Aggiungi il repository al tuo sistema.

$ 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

Se desideri installare Grafana beta, aggiungi invece il seguente repository.

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

Aggiorna l'elenco dei repository di sistema.

$ sudo apt update

Installa Grafana.

$ sudo apt install grafana

Avvia e abilita il servizio Grafana.

$ sudo systemctl enable grafana-server --now

Controlla lo stato del servizio.

$ sudo systemctl status grafana-server
? grafana-server.service - Grafana instance
     Loaded: loaded (/lib/systemd/system/grafana-server.service; enabled; preset: enabled)
     Active: active (running) since Tue 2024-01-02 03:48:01 UTC; 3s ago
       Docs: http://docs.grafana.org
   Main PID: 8769 (grafana)
      Tasks: 7 (limit: 2299)
     Memory: 42.6M
        CPU: 1.804s
     CGroup: /system.slice/grafana-server.service
             ??8769 /usr/share/grafana/bin/grafana server --config=/etc/grafana/grafana.ini --pidfile=/run/grafana/grafana-server.pid --packaging=deb cfg:default.paths.logs=/var/log/grafana cfg:default.paths...
.......

Passaggio 7: impostare l'origine dati Grafana

Avvia l'URL http://:3000 nel tuo browser e la seguente pagina di accesso di Grafana dovrebbe accoglierti.

Accedi con il nome utente predefinito admin e la password admin. Successivamente, è necessario impostare una nuova password predefinita.

Verrai accolto con la seguente home page di Grafana. Fai clic sul pulsante Aggiungi la tua prima origine dati.

Fai clic sul pulsante InfluxDB.

Nella pagina successiva, seleziona Flux dal menu a discesa come linguaggio di query. Puoi utilizzare InfluxQL come linguaggio di query, ma è più complicato da configurare poiché supporta solo InfluxDB v1.x per impostazione predefinita. Flux supporta InfluxDB v2.x ed è più facile da impostare e configurare.

Immettere i seguenti valori.

URL: http://localhost:8086 Dettagli di autenticazione di base Utente: navjot Password: <yourinfluxdbpassword>

Dettagli InfluxDB Organizzazione: howtoforge Token: <influxdbtoken> Bucket predefinito: tigstack

Fai clic sul pulsante Salva e prova e dovresti visualizzare un messaggio di conferma che conferma che la configurazione è andata a buon fine.

Passaggio 8: configurare le dashboard Grafana

Il passaggio successivo è configurare Grafana Dashboards. Fai clic sul menu hamburger a sinistra di Home e fai clic su Dashboard per aprire la schermata Crea dashboard.

Fai clic sul pulsante Crea dashboard per procedere.

Nella pagina successiva, fai clic sul pulsante Aggiungi visualizzazione per avviare l'overlay e fai clic su influxdb-1 per selezionarlo come origine dati.

Verrai indirizzato alla seguente pagina Modifica pannello.

Incolla il codice seguente nell'editor di query.

from(bucket: "NAMEOFYOUBUCKET")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r["_measurement"] == "cpu")
  |> filter(fn: (r) => r["_field"] == "usage_idle")
  |> filter(fn: (r) => r["cpu"] == "cpu-total")
  |> filter(fn: (r) => r["host"] == "NAMEOFYOURHOST")
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> map(fn: (r) => ({ r with _value: r._value * -1.0 + 100.0 }))
  |> toFloat()
  |> yield(name: "mean")

Utilizza il nome del bucket utilizzato in precedenza. E il nome dell'host che puoi recuperare dal file /etc/hostname.

Il codice precedente calcolerà l'utilizzo della CPU e genererà un grafico per esso. Dai un titolo al pannello.

Fai clic sul pulsante Ispettore query, quindi fai clic sul pulsante Aggiorna per verificare se la query funziona correttamente. Fare clic sull'icona a forma di croce per chiudere la finestra di ispezione.

Puoi anche assegnare un nome all'asse utilizzando il campo Etichetta a destra sotto la sezione Asse.

Fai clic sul pulsante Applica per salvare il pannello. Al termine, fai clic sul pulsante Salva dashboard.

Assegna un nome alla dashboard e fai clic su Salva per terminare.

Si aprirà la dashboard e quindi farà clic sul pulsante Aggiungi visualizzazione per creare un altro pannello.

Ripeti il processo creando un altro pannello per l'utilizzo della RAM.

from(bucket: "NAMEOFYOUBUCKET")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r["_measurement"] == "mem")
  |> filter(fn: (r) => r["_field"] == "used_percent")
  |> filter(fn: (r) => r["host"] == "NAMEOFYOURHOST")
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> yield(name: "mean")

Utilizzare il seguente codice per visualizzare l'utilizzo dell'HDD.

from(bucket: "NAMEOFYOURBUCKET")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r["_measurement"] == "disk")
  |> filter(fn: (r) => r["_field"] == "used")
  |> filter(fn: (r) => r["path"] == "/")
  |> filter(fn: (r) => r["host"] == "NAMEOFYOURHOST")
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> map(fn: (r) => ({ r with _value: r._value / 1000000.0 }))
  |> toFloat()  
  |> yield(name: "mean")

Puoi creare un numero illimitato di pannelli.

Il codice sopra è basato sul linguaggio Flux Scripting. Fortunatamente, non è necessario imparare la lingua per scrivere query. È possibile generare la query dall'URL InfluxDB. Anche se l'apprendimento della lingua può trarre vantaggio dall'ottimizzazione delle query.

Devi tornare alla dashboard di InfluxDB e aprire la pagina Esplora per ottenere la query.

Fai clic sul nome del bucket, quindi su uno dei valori nel filtro _measurement e continua a fare clic sugli altri valori man mano che vengono visualizzati. Una volta terminato, fai clic sul pulsante Script Editor e dovresti vedere la pagina seguente. Anche il grafico dovrebbe essere aggiornato.

Copia la query mostrata e ora puoi utilizzarla nella dashboard di Grafana per costruire i tuoi grafici.

Passaggio 9: configurare avvisi e notifiche

L'utilizzo principale dell'impostazione dei monitoraggi è quello di ricevere avvisi in tempo quando il valore supera una determinata soglia.

Il primo passo è impostare la destinazione in cui desideri ricevere gli avvisi. Puoi ricevere notifiche tramite email, Slack, Kafka, Google Hangouts Chat, Microsoft Teams, Telegram, ecc.

Abiliteremo le notifiche email per il nostro tutorial. Per impostare le notifiche e-mail, dobbiamo prima configurare il servizio SMTP. Apri il file /etc/grafana/grafana.ini per la configurazione di SMTP.

$ sudo nano /etc/grafana/grafana.ini

Trova la seguente riga [smtp] al suo interno. Rimuovere il commento dalle righe seguenti e immettere i valori per il server SMTP personalizzato.

[smtp]
enabled = true
host = email-smtp.us-west-2.amazonaws.com:587
user = YOURUSERNAME
# If the password contains # or ; you have to wrap it with triple quotes. Ex """#password;"""
password = YOURUSERPASSWORD
;cert_file =
;key_file =
;skip_verify = false
from_address = [email 
from_name = HowtoForge Grafana
# EHLO identity in SMTP dialog (defaults to instance_name)
;ehlo_identity = dashboard.example.com
# SMTP startTLS policy (defaults to 'OpportunisticStartTLS')
;startTLS_policy = NoStartTLS

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Riavviare il server Grafana per applicare le impostazioni.

$ sudo systemctl restart grafana-server

Apri la pagina Grafana, clicca sull'icona Avviso e clicca su Punti di contatto.

Grafana crea e imposta automaticamente un punto di contatto email predefinito che deve essere configurato con l'indirizzo email corretto. Fai clic sul pulsante di modifica nel punto di contatto grafana-default-email.

Inserisci i dettagli per configurare il canale di notifica via email.

Se desideri inviare un messaggio aggiuntivo, fai clic sul link Impostazioni email facoltative e inserisci il messaggio.

Fai clic su Test per aprire il popup, quindi fai clic sul pulsante Invia notifica di prova per vedere se le impostazioni email funzionano. Al termine, fai clic su Salva punto di contatto.

Dovresti ricevere la seguente email di conferma delle impostazioni.

Ora che abbiamo impostato i canali di notifica, dobbiamo impostare gli avvisi su quando ricevere queste e-mail. Per impostare gli avvisi è necessario tornare ai pannelli della dashboard.

Torna alla schermata Dashboard. Fai clic sulla dashboard che abbiamo appena creato e otterrai la sua home page con diversi pannelli. Per modificare il pannello, fare clic sul nome del pannello e verrà visualizzato un menu a discesa. Fai clic sul link Modifica per procedere.

Fai clic sul Pannello avvisi e poi sul pulsante Nuova regola di avviso per impostare un nuovo avviso. Stiamo creando un avviso per il pannello di utilizzo della CPU.

Ora puoi configurare le condizioni in cui Grafana invierà l'avviso. Fai clic sul menu a discesa del link Opzioni e seleziona l'intervallo di tempo predefinito (da ora a 6 ore) per modificare l'intervallo di tempo in Ultimi 15 minuti, il che significa che controllerà dalle 15 minuti fa ad oggi.

Per impostazione predefinita, il tipo di avviso selezionato è l'avviso gestito Grafana. Ci sono due espressioni selezionate per impostazione predefinita. Eliminali premendo il pulsante del cestino contro di essi. Seleziona il menu a discesa Aggiungi espressione e seleziona la Condizione classica come tipo di espressione.

Fai clic su Imposta come condizione di avviso per selezionare l'espressione scelta per l'invio degli avvisi. In questo modo la casella dell'espressione verrà modificata come mostrato di seguito.

Condizioni

Grafana funziona su una query del formato seguente per determinare quando avviare un avviso.

avg() OF query(A) IS ABOVE 0.8
  • avg() controlla il modo in cui il valore di ciascuna serie deve essere ridotto a un valore comparabile rispetto alla soglia. Puoi fare clic sul nome della funzione per selezionare una funzione diversa come avg(), min(), max(), sum(), count(), ecc.

    query(A) La lettera tra parentesi definisce quale query eseguire dalla scheda Metriche.

    È SOTTO 14 Definisce il tipo di soglia e il valore di soglia. Puoi fare clic su È SOTTO per selezionare un tipo di soglia diverso.

Puoi aggiungere una seconda condizione sotto di essa facendo clic sul pulsante + sotto la prima condizione. Attualmente puoi utilizzare solo gli operatori AND e OR tra più condizioni.

Successivamente, imposteremo il comportamento di valutazione. Fai clic sul pulsante Nuova cartella per creare una cartella in cui archiviare le tue regole. Fai clic sul pulsante Nuovo gruppo di valutazione per creare un gruppo per le regole del club che verranno valutate dopo lo stesso intervallo di tempo. Imposta l'intervallo di tempo su 5 minuti durante la creazione del gruppo.

Una volta terminato, la pagina dovrebbe assomigliare alla seguente. Imposta lo Stato di avviso in caso di errore di esecuzione o timeout su Avviso.

Regola

  • Nome: inserisci un nome descrittivo per l'avviso
  • Cartella: crea o seleziona una cartella preesistente in cui archiviare la regola di notifica.
  • Gruppo: inserisci un nome per il tuo gruppo di avvisi. Gli avvisi in un singolo gruppo vengono valutati dopo lo stesso intervallo di tempo.
  • In attesa: specifica la frequenza con cui Grafana deve valutare l'avviso. Viene anche chiamato intervallo di valutazione. Puoi impostare qualsiasi valore desideri qui.

Nessuna gestione dei dati e degli errori

Puoi configurare il modo in cui Grafana deve gestire le query che non restituiscono dati o solo valori null utilizzando le seguenti condizioni:

  1. Nessun dato: imposta lo stato della regola su NoData
  2. Avviso: imposta lo stato della regola su Avviso
  3. Ok: imposta lo stato della regola di avviso su Ok, poiché riceverai un avviso anche se tutto va bene.

Puoi dire a Grafana come gestire gli errori di esecuzione o di timeout.

  1. Avviso: imposta lo stato della regola su Avviso
  2. Ok: imposta lo stato della regola di avviso su Ok, poiché riceverai un avviso anche se tutto va bene.
  3. Errore: imposta lo stato della regola di avviso su Errore per indicare che si è verificato un problema.

Una volta terminato, fai clic sul pulsante Anteprima avvisi per vedere se tutto funziona correttamente. Fai clic sul pulsante Salva regola ed esci in alto a destra per completare l'aggiunta dell'avviso. Ora dovresti iniziare a ricevere avvisi sulla tua email. Di seguito è riportato un esempio di una di queste e-mail.

Passaggio 10: installare Nginx

Debian 12 viene fornita con una versione precedente di Nginx. È necessario scaricare il repository ufficiale Nginx per installare la versione più recente.

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 principale di Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/mainline/debian `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

Verificare l'installazione. Sui sistemi Debian, il seguente comando funzionerà solo con sudo.

$ sudo nginx -v
nginx version: nginx/1.25.3

Avvia il server Nginx.

$ sudo systemctl start nginx

Controlla lo stato del servizio.

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
     Active: active (running) since Tue 2024-01-02 09:21:10 UTC; 5s ago
       Docs: https://nginx.org/en/docs/
    Process: 12964 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 12965 (nginx)
      Tasks: 3 (limit: 2299)
     Memory: 2.9M
        CPU: 86ms
     CGroup: /system.slice/nginx.service
             ??12965 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??12966 "nginx: worker process"
             ??12967 "nginx: worker process"

Jan 02 09:21:10 grafana systemd[1]: Starting nginx.service - nginx - high performance web server...
Jan 02 09:21:10 grafana systemd[1]: Started nginx.service - nginx - high performance web server.

Passaggio 11: installare SSL

Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository Debian o prendere la versione più recente utilizzando lo strumento Snapd. Utilizzeremo la versione Snapd.

Debian 12 non viene fornito con Snapd installato. Installa il pacchetto Snapd.

$ sudo apt install snapd

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

Utilizzare il comando seguente per garantire che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Verifica se Certbot funziona correttamente.

$ certbot --version
certbot 2.8.0

Esegui il comando seguente per generare un certificato SSL.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email  -d grafana.example.com

Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/grafana.example.com sul tuo server.

Genera un certificato gruppo Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Controlla il servizio di pianificazione del rinnovo di Certbot.

$ systemctl list-timers

Troverai snap.certbot.renew.service come uno dei servizi pianificati per l'esecuzione.

NEXT                        LEFT        LAST                        PASSED    UNIT                         ACTIVATES
-----------------------------------------------------------------------------------------------------------------------------------------
Tue 2024-01-02 15:24:52 UTC 6h left     Mon 2024-01-01 15:24:52 UTC 17h ago   systemd-tmpfiles-clean.timer systemd-tmpfiles-clean.service
Tue 2024-01-02 20:05:29 UTC 10h left    Tue 2024-01-02 09:02:47 UTC 21min ago apt-daily.timer              apt-daily.service
Tue 2024-01-02 20:35:00 UTC 11h left    -                           -         snap.certbot.renew.timer     snap.certbot.renew.service

Esegui un test del processo per verificare se il rinnovo SSL funziona correttamente.

$ sudo certbot renew --dry-run

Se non vedi errori, è tutto a posto. Il tuo certificato si rinnoverà automaticamente.

Passaggio 12: configurare Nginx per Grafana e InfluxDB

Apri il file /etc/nginx/nginx.conf per modificarlo.

$ 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/grafana.conf per la modifica.

$ sudo nano /etc/nginx/conf.d/grafana.conf

Incolla il seguente codice al suo interno. Sostituisci grafana.example.com con il tuo nome di dominio.

map $http_upgrade $connection_upgrade {
  default upgrade;
  '' close;
}

server {

    listen 443 ssl reuseport;
    listen [::]:443 ssl reuseport;

    http2 on;

    server_name grafana.example.com;

    access_log  /var/log/nginx/grafana.access.log;
    error_log   /var/log/nginx/grafana.error.log;

    ssl_certificate      /etc/letsencrypt/live/grafana.example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/grafana.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/grafana.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 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] valid=60s;
    resolver_timeout 2s;

    location / {
        proxy_set_header Host $http_host;
        proxy_pass http://localhost:3000;
    }

    location /api/live {
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header Host $http_host;
        proxy_pass http://localhost:3000;
	}

    location /influxdb/ {
     	access_log /var/log/nginx/influx.access.log;
        error_log /var/log/nginx/influx.error.log;
        rewrite ^/influxdb$ /influxdb/ permanent;
        rewrite ^/influxdb/(.*)$ /$1 break;
        proxy_cookie_path ~*^/api /influxdb/api;
        proxy_connect_timeout 600s;
        proxy_http_version 1.1;
        proxy_pass http://localhost:8086;
        proxy_read_timeout 600s;
        proxy_send_timeout 600s;
        proxy_set_header Authorization $http_authorization;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $http_host;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto https;
        proxy_set_header X-Real-IP $remote_addr;
        sub_filter '<base href="/">' '<base href="/influxdb/">';
        sub_filter 'src="/' 'src="/influxdb/';
        sub_filter 'href="/' 'href="/influxdb/';
        sub_filter 'data-basepath="' 'data-basepath="/influxdb/';
        sub_filter 'n.p="/"' 'n.p="/influxdb/"';
        sub_filter 'o.p="/"' 'o.p="/influxdb/"';
        sub_filter '/api/' '/influxdb/api/';
        sub_filter 'api/v2/query' 'influxdb/api/v2/query';
        sub_filter '/health`' '/influxdb/health`';
        sub_filter_types text/css text/javascript application/javascript application/json;
        sub_filter_once off;
	}
}
# enforce HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name grafana.example.com;
    return 301 https://$host$request_uri;
}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la tua configurazione Nginx.

$ sudo nginx -t

Riavvia il server Nginx.

$ sudo systemctl restart nginx

Configura Telegraf per HTTPS

Apri il file /etc/telegraf/telegraf.conf per modificarlo.

$ sudo nano /etc/telegraf/telegraf.conf

Cerca la sezione [[outputs.influxdb_v2]] e modifica il valore dell'URL in https://grafana.nspeaks.com/influxdb in modo che i dati tra InfluxDB e Telegraf è al sicuro.

urls = ["https://grafana.example.com/influxdb"]

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Riavviare il servizio Telegraf.

$ sudo systemctl restart telegraf

Configura Grafana per HTTPS

Successivamente, dobbiamo configurare Grafana per l'accesso HTTPS. Apri il file /etc/grafana/grafana.ini per modificarlo.

$ sudo nano /etc/grafana/grafana.ini

Trova la sezione [server] e modifica la variabile domain e root_url come segue.

# The public facing domain name used to access grafana from a browser
;domain = localhost
domain = grafana.example.com

# Redirect to correct domain if host header does not match domain
# Prevents DNS rebinding attacks
;enforce_domain = true

# The full public facing url you use in browser, used for redirects and emails
# If you use reverse proxy and sub path specify full url (with sub path)
;root_url = %(protocol)s://%(domain)s:%(http_port)s/
root_url = %(protocol)s://%(domain)s

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Riavviare il server Grafana.

$ sudo systemctl restart grafana-server

Chiudi le porte del firewall per InfluxDB e Grafana

Dovresti anche chiudere le porte InfluxDB e Grafana.

$ sudo ufw delete allow 8086
$ sudo ufw delete allow 3000

Grafana dovrebbe essere accessibile all'indirizzo https://grafana.example.com mentre l'interfaccia utente e l'API di InfluxDB dovrebbero essere entrambe accessibili all'URL https://grafana.example.com/influxdb.

Conclusione

Questo conclude il tutorial sull'installazione e la configurazione dello stack TIG su un server Debian 12. Se avete domande, pubblicatele nei commenti qui sotto.

Articoli correlati: