Ricerca nel sito web

Come installare e configurare il sistema di monitoraggio della grafite su Ubuntu 22.04

Su questa pagina

  1. Prerequisiti
  2. Passaggio 1: configurazione del firewall
  3. Passaggio 2 - Installa i pacchetti richiesti
  4. Passaggio 3 - Installa Graphite e Graphite Web
  5. Passaggio 4 - Installa e configura PostgreSQL
  6. Passaggio 5 - Configura Graphite Carbon e Web
    1. Configura Carbon
    2. Configura il Web di grafite

    La grafite è uno strumento open source utilizzato per tracciare e rappresentare graficamente le prestazioni dei sistemi informatici. Puoi usarlo per tenere traccia delle prestazioni di siti Web, applicazioni, servizi aziendali e server in rete. È altamente flessibile e può essere configurato in modo da poter ottenere i vantaggi sia di una rappresentazione dettagliata che di ampie panoramiche delle prestazioni e dello stato delle metriche che stai monitorando.

    La grafite è composta da diversi componenti: l'applicazione web, un backend di archiviazione chiamato Carbon e la libreria di database chiamata whisper. In questo tutorial imparerai a installare e configurare Graphite su un server Ubuntu 22.04.

    Prerequisiti

    • A server running Ubuntu 22.04.

    • A Fully Qualified domain name (FQDN) pointing to the server. For our tutorial, we will use the graphite.example.com domain.

    • A non-root user with sudo privileges.

    • The uncomplicated Firewall(UFW) is enabled and running.

    • Make sure everything is updated. 

      $ sudo apt update && sudo apt upgrade

    • Install basic utility packages. Some of them may already be installed. 

      $ sudo apt install wget curl nano unzip -y

    Passaggio 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 al seguente.

    Status: active

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

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

    Passaggio 2: installare i pacchetti richiesti

    Installeremo Graphite utilizzando il gestore di pacchetti PIP Python. Il primo passaggio consiste nell'installare i pacchetti richiesti per l'installazione.

    $ sudo apt install vim python3-dev python3-pip libcairo2-dev libffi-dev build-essential

    Passaggio 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 - Installa e configura PostgreSQL

    Useremo il repository APT ufficiale di PostgreSQL per l'installazione. Eseguire il comando seguente per aggiungere la chiave GPG 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 all'elenco delle fonti.

    $ 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 helper usando 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 PostgreSQL.

    $ sudo -su postgres psql

    Creare un utente del database per Graphite.

    postgres=# CREATE USER graphite WITH PASSWORD 'your_password';

    Crea un database per Graphite e dai la proprietà all'utente Graphite.

    postgres=# CREATE DATABASE graphitedb WITH OWNER graphite;

    Uscire dalla shell PostgreSQL.

    postgres=# \q

    Passaggio 5: configurare Graphite Carbon e Web

    Il prossimo passo è configurare Graphite Carbon e Graphite web.

    Configura Carbon

    Carbon comprende tre servizi:

    • carbon-cache: accetta le metriche e le scrive sul disco.
    • carbon-relay: replica i dati.
    • carbon-aggregator: viene eseguito davanti al servizio carbon-cache per bufferizzare le metriche nel tempo prima di inoltrarle a Whisper.

    La configurazione di carbon-cache è necessaria, ma carbon-relay e carbon-aggregator sono opzionali.

    Crea il file carbon.conf usando 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

    Ciò implica che un modello che corrisponde a un'espressione regolare ^carbon\. dovrebbe conservare i dati con la politica di conservazione 60:90d che significa

    • quanto spesso viene registrata una metrica: 60 secondi
    • periodo di tempo per la memorizzazione di tali valori: 90 giorni

    Puoi aggiungere la tua voce. Facciamo un esempio di test, ovvero il monitoraggio dei punti dati e le nostre voci dei punti dati inizieranno con la stringa test. Questa voce deve essere aggiunta prima della voce predefinita menzionata in fondo al file.

    [test]
pattern = ^test\.
retentions = 10s:10m,1m:1h

    Ciò corrisponderà a qualsiasi metrica che inizia con test. Memorizzerà i dati che raccoglie due volte, in vari dettagli. 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 aggregherà per creare il punto. Memorizza i dati a questo livello di dettaglio per un'ora.

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

    Avvia il servizio carbon-cache.

    $ sudo /opt/graphite/bin/carbon-cache.py start

    Configura il Web di grafite

    Il passaggio successivo consiste nel configurare l'app Web Graphite.

    Genera una chiave segreta per l'applicazione Graphite. Copiare 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

    Creare il file delle impostazioni dell'app Web.

    $ sudo cp /opt/graphite/webapp/graphite/local_settings.py.example /opt/graphite/webapp/graphite/local_settings.py

    È necessario configurare l'applicazione Web Graphite con le impostazioni del database. Apri local_settings.py per la modifica.

    $ sudo nano /opt/graphite/webapp/graphite/local_settings.py

    Rimuovere il commento dalla variabile SECRET_KEY e inserire un valore casuale per essa.

    SECRET_KEY = 'your-secret-key'

    Rimuovere il commento dalla variabile ALLOWED_HOSTS.

    ALLOWED_HOSTS = [ '*' ]

    Rimuovere il commento dalla variabile TIME_ZONE e impostarla sul valore appropriato.

    TIME_ZONE = 'Asia/Kolkata'

    Rimuovere il commento dalla variabile USE_REMOTE_USER_AUTHENTICATION e impostarla su TRUE in modo che l'utente remoto venga autenticato prima di apportare modifiche al database.

    USE_REMOTE_USER_AUTHENTICATION = True

    Modificare 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 immettendo Y quando richiesto.

    Installa alcuni prerequisiti per il wrapper PostgreSQL di Python.

    $ sudo pip install psycopg2-binary

    Eseguire il comando seguente per importare lo schema del database.

    $ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py migrate --settings=graphite.settings

    Otterrai 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 impostazioni di proprietà corrette.

    $ 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: 
Password: 
Password (again): 
Superuser created successfully.

    Ti chiederà di creare un superutente. Questo utente verrà utilizzato in seguito per connettersi all'applicazione Graphite.

    Passaggio 6: configurare Apache

    Graphite viene fornito con i 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 in grafite 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. Mettendo 127.0.0.1 davanti ad esso si impedisce che sia accessibile sul web.

    <VirtualHost 127.0.0.1:8080>

    Aggiungi il tuo nome di dominio.

    ServerName graphite.example.com #Replace with your domain

    Aggiungere le seguenti righe sotto la riga Alias /static/ /opt/graphite/static/.

    #Add below lines
<Directory /opt/graphite/static/>
     Require all granted
</Directory>

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

    Disabilita l'host virtuale predefinito e abilita il file dell'host virtuale Graphite.

    $ sudo a2dissite 000-default
$ sudo a2ensite graphite

    Dovremo anche dire ad Apache di ascoltare la porta 8080 e di smettere di ascoltare la 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 la seguente.

    Listen 127.0.0.1:8080

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

    Riavvia il server Apache.

    $ sudo systemctl restart apache2

    Per verificare che Graphite funzioni correttamente e sia accessibile, eseguire il seguente comando.

    $ curl 127.0.0.1:8080

    Otterrai il seguente output.

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
<!-- Copyright 2008 Orbitz WorldWide

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. -->

<html>
  <head>
    <title>Graphite Browser</title>
  </head>


<frameset rows="80,*" frameborder="1" border="1">
  <frame src="/browser/header" name="Header" id='header' scrolling="no" noresize="true" />

    <frame src="/composer?" name="content" id="composerFrame"/>

</frameset>
</html>

    Questo conferma che sta funzionando bene.

    Passaggio 7: installa Nginx

    Useremo Nginx come server proxy per Apache. In questo modo possiamo raccogliere i vantaggi della sicurezza e dell'oscurità utilizzando la configurazione esistente fornita da Graphite.

    Ubuntu 22.04 viene fornito con una versione precedente di Nginx. Per installare l'ultima versione, devi scaricare il repository Nginx ufficiale.

    Importa la chiave di firma Nginxs.

    $ 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 Nginxs.

    $ 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

    Verificare l'installazione.

    $ nginx -v
nginx version: nginx/1.22.0

    Avvia il server Nginx.

    $ sudo systemctl start nginx

    Passaggio 8: installa SSL

    Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot usando il repository Ubuntus o prendere l'ultima versione usando lo strumento Snapd. Useremo 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 Cerbot.

    $ sudo snap install --classic certbot

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

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

    Eseguire il seguente comando per generare un certificato SSL.

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

    Il comando precedente 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 di pianificazione del rinnovo di Certbot.

    $ sudo systemctl list-timers

    Troverai snap.certbot.renew.service come uno dei servizi pianificati 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 verificare se il rinnovo SSL funziona correttamente, eseguire un'esecuzione a secco del processo.

    $ sudo certbot renew --dry-run

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

    Passaggio 9: configurare Nginx

    Apri il file /etc/nginx/nginx.conf per la modifica.

    $ sudo nano /etc/nginx/nginx.conf

    Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.

    server_names_hash_bucket_size  64;

    Salva il file premendo Ctrl + X e immettendo 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 al suo interno.

    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.

    Verificare la sintassi del file di configurazione 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

    Passaggio 10: accesso e utilizzo della grafite

    Visita l'URL https://graphite.example.com nel tuo browser e otterrai la seguente schermata.

    Fare clic sul collegamento Accedi in alto a destra per aprire la pagina di accesso. Inserisci le tue credenziali di superutente create nel passaggio 5 e premi il pulsante di accesso per procedere.

    Esistono diversi metodi per fornire dati a Graphite. Abbiamo aggiunto un pattern matcher nello schema di archiviazione, in base al quale qualsiasi pattern che inizia con il test verrà registrato come nostro pattern. Aggiungiamo alcuni dati casuali usando il seguente comando.

    $ echo "test.count 9 `date +%s`" | nc -q0 127.0.0.1 2003;

    Ciò aggiungerà una metrica di dati di valore 9 al sistema. Aggiungiamo altri dati scorrendo 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 Metriche >> test >> conta dalla barra laterale sinistra. Dovresti vedere qualcosa di simile al seguente.

    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 sull'installazione e la configurazione di Graphite su un server Ubuntu 22.04 insieme a Nginx come server proxy. Se hai domande, pubblicale nei commenti qui sotto.