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