So installierst und konfigurierst du das Graphite Monitoring System unter Ubuntu 22.04

Graphite ist ein Open-Source-Tool, mit dem du die Leistung von Computersystemen verfolgen und grafisch darstellen kannst. Du kannst damit die Leistung von Websites, Anwendungen, Geschäftsdiensten und vernetzten Servern verfolgen. Es ist sehr flexibel und kann so konfiguriert werden, dass du sowohl von einer detaillierten Darstellung als auch von einem breiten Überblick über die Leistung und den Zustand der von dir verfolgten Metriken profitierst.

Graphite besteht aus mehreren Komponenten: der Webanwendung, einem Speicher-Backend namens Carbon und der Datenbankbibliothek namens Whisper. In diesem Lernprogramm lernst du, wie du Graphite auf einem Ubuntu 22.04 Server installierst und konfigurierst.

Voraussetzungen

  • Ein Server, auf dem Ubuntu 22.04 läuft.
  • Ein Fully Qualified Domain Name (FQDN), der auf den Server verweist. Für unser Tutorial werden wir die Domain graphite.example.com verwenden.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Die Unkomplizierte Firewall (UFW) ist aktiviert und läuft.
  • Stelle sicher, dass alles auf dem neuesten Stand ist.
    $ sudo apt update && sudo apt upgrade
    
  • Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon installiert.
    $ sudo apt install wget curl nano unzip -y
    

Schritt 1 – Firewall konfigurieren

Bevor du die Pakete installierst, musst du die Firewall so konfigurieren, dass sie HTTP- und HTTPS-Verbindungen zulässt.

Überprüfe den Status der Firewall.

$ sudo ufw status

Du solltest etwas wie das Folgende sehen.

Status: active

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

Erlaube HTTP- und HTTPs-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Überprüfe den Status zur Bestätigung noch einmal.

$ 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)

Schritt 2 – Erforderliche Pakete installieren

Wir werden Graphite mit Hilfe des PIP Python Paketmanagers installieren. Der erste Schritt ist die Installation der Pakete, die für die Installation benötigt werden.

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

Schritt 3 – Graphite und Graphite Web installieren

Wir installieren Graphite in dem Verzeichnis /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

Schritt 4 – PostgreSQL installieren und konfigurieren

Wir verwenden für die Installation das offizielle APT-Repository von PostgreSQL. Führe den folgenden Befehl aus, um den PostgreSQL GPG-Schlüssel hinzuzufügen.

$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null

Füge das APT-Repository zu deiner Quellenliste hinzu.

$ 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'

Aktualisiere das System-Repository.

$ sudo apt update

Jetzt kannst du PostgreSQL und die Hilfspakete mit dem folgenden Befehl installieren.

$ sudo apt install postgresql postgresql-contrib libpq-dev

Überprüfe den Status des PostgreSQL-Dienstes.

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

Du kannst sehen, dass der Dienst aktiviert ist und standardmäßig läuft.

Melde dich in der PostgreSQL-Shell an.

$ sudo -su postgres psql

Erstelle einen Datenbankbenutzer für Graphite.

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

Erstelle eine Datenbank für Graphite und gib dem Benutzer graphite die Rechte.

postgres=# CREATE DATABASE graphitedb WITH OWNER graphite;

Beende die PostgreSQL-Shell.

postgres=# \q

Schritt 5 – Graphite Carbon und Web konfigurieren

Der nächste Schritt ist die Konfiguration von Graphite Carbon und Graphite Web.

Carbon konfigurieren

Carbon besteht aus drei Diensten:

  • carbon-cache: nimmt Metriken entgegen und schreibt sie auf die Festplatte.
  • carbon-relay: repliziert die Daten.
  • carbon-aggregator: läuft vor dem carbon-cache Dienst und puffert die Messdaten, bevor er sie an Whisper weiterleitet.

Die Konfiguration von carbon-cache ist notwendig, aber carbon-relay und carbon-aggregator sind optional.

Erstelle die Datei carbon.conf anhand der angegebenen Beispieldatei.

$ sudo cp /opt/graphite/conf/carbon.conf.example /opt/graphite/conf/carbon.conf

Als Nächstes erstellst du die Konfiguration des Speicherschemas.

$ sudo cp /opt/graphite/conf/storage-schemas.conf.example /opt/graphite/conf/storage-schemas.conf

Öffne die Speicherschema-Konfigurationsdatei.

$ sudo nano /opt/graphite/conf/storage-schemas.conf

Darin findest du Einträge wie

[carbon]
pattern = ^carbon\.
retentions = 60:90d

Das bedeutet, dass ein Muster, das auf einen regulären Ausdruck ^carbon\. passt, die Daten mit der Aufbewahrungsrichtlinie 60:90d aufbewahren soll, was bedeutet

  • wie oft eine Kennzahl aufgezeichnet wird: 60 Sekunden
  • wie lange diese Werte gespeichert werden sollen: 90 Tage

Du kannst deinen eigenen Eintrag hinzufügen. Nehmen wir als Beispiel test, d.h. Überwachungsdatenpunkte, und unsere Datenpunkteinträge beginnen mit der Zeichenfolge test. Dieser Eintrag sollte vor dem unten in der Datei erwähnten Standardeintrag hinzugefügt werden.

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

Er passt zu allen Metriken, die mit test beginnen. Er speichert die Daten, die er sammelt, zwei Mal in unterschiedlicher Ausführlichkeit. Bei der ersten Definition (1s:10m) wird alle zehn Sekunden ein Datenpunkt erstellt. Sie speichert die Daten nur für zehn Minuten. Bei der zweiten Definition wird jede Minute ein Datenpunkt erstellt. Sie sammelt alle Daten der letzten Minute (sechs Punkte, da die vorherige Definition alle zehn Sekunden einen Punkt erstellt) und aggregiert sie, um den Punkt zu erstellen. Sie speichert die Daten auf dieser Detailstufe für eine Stunde.

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starten Sie den Dienst carbon-cache.

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

Das Graphite Web konfigurieren

Der nächste Schritt ist die Konfiguration der Graphite Web App.

Erstelle einen geheimen Schlüssel für die Graphite-Anwendung. Kopiere den angezeigten Schlüssel zur späteren Verwendung.

$ 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

Erstelle die Einstellungsdatei für die Webanwendung.

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

Du musst die Graphite-Webanwendung mit den Datenbankeinstellungen konfigurieren. Öffne die Datei local_settings.py zur Bearbeitung.

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

Entferne das Kommentarzeichen in der Variable SECRET_KEY und gib einen zufälligen Wert für sie ein.

SECRET_KEY = 'your-secret-key'

Entferne die Markierung in der Variable ALLOWED_HOSTS.

ALLOWED_HOSTS = [ '*' ]

Dekommentiere die Variable TIME_ZONE und setze sie auf den entsprechenden Wert.

TIME_ZONE = 'Asia/Kolkata'

Entferne das Kommentarzeichen in der Variable USE_REMOTE_USER_AUTHENTICATION und setze sie auf TRUE, damit der Fernbenutzer authentifiziert wird, bevor er Änderungen an der Datenbank vornimmt.

USE_REMOTE_USER_AUTHENTICATION = True

Ändere die Datenbankeinstellungen.

DATABASES = {
    'default': {
        'NAME': 'graphitedb',
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'USER': 'graphite',
        'PASSWORD': 'your_password',
        'HOST': '127.0.0.1',
        'PORT': ''
    }
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Installiere einige Voraussetzungen für den PostgreSQL-Wrapper von Python.

$ sudo pip install psycopg2-binary

Führe den folgenden Befehl aus, um das Datenbankschema zu importieren.

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

Du wirst die folgende Ausgabe erhalten.

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

Als nächstes sammelst du die statischen Dateien.

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

Setze die richtigen Eigentümereinstellungen.

$ 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/

Erstelle einen Root-Benutzer für die Anmeldung.

$ sudo PYTHONPATH=/opt/graphite/webapp/ django-admin.py createsuperuser --settings=graphite.settings
Username (leave blank to use 'root'): navjot
Email address: navjot@example.com
Password: 
Password (again): 
Superuser created successfully.

Du wirst gefragt, ob du einen Superuser anlegen möchtest. Dieser Benutzer wird später für die Verbindung mit der Graphite-Anwendung verwendet.

Schritt 6 – Apache konfigurieren

Graphite wird standardmäßig mit Apache-Konfigurationsdateien ausgeliefert. Installiere den Apache-Server.

$ sudo apt install apache2 libapache2-mod-wsgi-py3

Erstelle die Datei mod_wsgi.

$ sudo cp /opt/graphite/conf/graphite.wsgi.example /opt/graphite/conf/graphite.wsgi

Kopiere die Graphite-Beispielkonfigurationsdatei in das Apache-Verzeichnis.

$ sudo cp /opt/graphite/examples/example-graphite-vhost.conf /etc/apache2/sites-available/graphite.conf

Öffne die Graphite-Konfigurationsdatei zum Bearbeiten.

$ sudo nano /etc/apache2/sites-available/graphite.conf

Ändere die Portnummer in der ersten Zeile von 80 in 127.0.0.1:8080. Durch das Voranstellen von 127.0.0.1 wird der Zugriff über das Web eingeschränkt.

<VirtualHost 127.0.0.1:8080>

Füge deinen Domainnamen hinzu.

ServerName graphite.example.com #Replace with your domain

Füge die folgenden Zeilen unterhalb der Zeile Alias /static/ /opt/graphite/static/ ein.

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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Deaktiviere den Standard-Virtual-Host und aktiviere die Graphite Virtual-Host-Datei.

$ sudo a2dissite 000-default
$ sudo a2ensite graphite

Außerdem müssen wir dem Apache sagen, dass er auf Port 8080 hören soll und nicht mehr auf Port 80, weil wir Nginx als Proxy-Server verwenden werden.

Öffne die Datei /etc/apache2/ports.conf zum Bearbeiten.

$ sudo nano /etc/apache2/ports.conf

Suche die Zeile Listen 80 und ersetze sie durch die folgende.

Listen 127.0.0.1:8080

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starte den Apache-Server neu.

$ sudo systemctl restart apache2

Um zu überprüfen, ob Graphite richtig funktioniert und zugänglich ist, führe den folgenden Befehl aus.

$ curl 127.0.0.1:8080

Du erhältst die folgende Ausgabe.

<!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>

Dies bestätigt, dass Graphite einwandfrei funktioniert.

Schritt 7 – Nginx installieren

Wir werden Nginx als Proxy-Server für Apache verwenden. Auf diese Weise profitieren wir von den Vorteilen der Sicherheit und der Unsichtbarkeit und nutzen gleichzeitig die bestehende Konfiguration von Graphite.

Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Importiere den Signierschlüssel von Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Füge das Repository für die stabile Version von Nginx hinzu.

$ 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

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.0

Starte den Nginx-Server.

$ sudo systemctl start nginx

Schritt 8 – SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core
$ sudo snap refresh core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.

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

Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.

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

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/graphite.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Überprüfe den Certbot Erneuerungszeitplanungsdienst.

$ sudo systemctl list-timers

Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung geplant sind.

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

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, ist alles in Ordnung. Dein Zertifikat wird automatisch erneuert.

Schritt 9 – Nginx konfigurieren

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size  64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Erstelle und öffne die Datei /etc/nginx/conf.d/uvdesk.conf zum Bearbeiten.

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

Füge den folgenden Code in die Datei ein.

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;
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe die Syntax der Nginx-Konfigurationsdatei.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Starte den Nginx-Dienst neu.

$ sudo systemctl restart nginx

Schritt 10 – Zugriff und Nutzung von Graphite

Rufe die URL https://graphite.example.com in deinem Browser auf und du erhältst den folgenden Bildschirm.

Graphite Dashboard

Klicke oben rechts auf den Link Login, um die Anmeldeseite zu öffnen. Gib deine in Schritt 5 erstellten Superuser-Zugangsdaten ein und klicke auf den Login-Button, um fortzufahren.

Es gibt mehrere Methoden, um Graphite mit Daten zu versorgen. Wir haben im Speicherschema einen Pattern Matcher hinzugefügt, nach dem jedes Muster, das mit dem Test beginnt, als unser Muster aufgezeichnet wird. Fügen wir mit dem folgenden Befehl einige Zufallsdaten hinzu.

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

Dadurch wird dem System eine Datenmetrik mit dem Wert 9 hinzugefügt. Fügen wir weitere Daten hinzu, indem wir die Werte in einer Schleife durchgehen.

$ 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

Gehe zurück zum Graphite Dashboard und öffne Metrics >> test >> count in der linken Seitenleiste. Du solltest etwas wie das Folgende sehen.

Graphite Daten im Dashboard anzeigen

Jetzt kannst du es für die Überwachung verwenden. Du kannst es auch mit Grafana kombinieren, um ein hohes Maß an Anpassungsmöglichkeiten zu erhalten.

Fazit

Damit ist unser Tutorium zur Installation und Konfiguration von Graphite auf einem Ubuntu 22.04 Server zusammen mit Nginx als Proxy-Server abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …