So installierst du Grafana und Prometheus unter Ubuntu 22.04
Grafana ist eine quelloffene und plattformübergreifende Datenvisualisierungsplattform, die von Grafana Labs entwickelt wurde. Grafana bietet eine interaktive Webanwendung zur Datenvisualisierung, die Diagramme, Grafiken und Warnmeldungen enthält. Mit Grafana kannst du Metriken, Logs und Traces der TSDB abfragen, visualisieren, Alarme einrichten und untersuchen. Es ist ein leistungsfähiges Tool, das Daten aus Zeitreihen-Datenbanken (TSDB) in aufschlussreiche Grafiken und Visualisierungen verwandelt.
In Grafana kannst du deine Zeitreihendaten über die „Datenquelle“ hinzufügen. Grafana unterstützt zahlreiche Datenquellen wie Prometheus, InfluxDB, PostgreSQL, Loki, Jaeger, Graphite, Google Cloud Monitoring, AWS CloudWatch, Azure Monitor und viele mehr.
Dieses Tutorial behandelt die Installation von Grafana, Prometheus und dem Node-Exporter auf einem Ubuntu 22.04 Server. Mit Grafana als Dashboard und Datenvisualisierungstool, Prometheus als Datenquelle, in der alle Überwachungsdaten gespeichert werden, und dem node_exporter, einer Anwendung, die Informationen und Metriken über deine Systeme sammelt und an Prometheus sendet, baust du einen leistungsstarken Monitoring-Stack auf.
Voraussetzungen
Es gibt einige Voraussetzungen, die du erfüllen musst, bevor du beginnst:
- Ein Ubuntu 22.04 Server – für den Einsatz mit einem einzelnen Server. Für mehrere Server benötigst du jedoch Server mit den folgenden Angaben:
- server1 – wird als Grafana-Server verwendet.
- server2 – wird als Prometheus-Server verwendet.
- erver3 – Zielserver für die Überwachung, auf dem node_exporter installiert wird.
- Außerdem brauchst du einen Nicht-Root-Benutzer mit sudo/root-Administrator-Rechten.
Hinzufügen des Grafana-Repositorys
Im ersten Schritt richtest du das Grafana-Repository auf deinem Ubuntu-System ein. Du installierst grundlegende Abhängigkeiten und fügst den GPG-Schlüssel und das Grafana-Repository zu deinem System hinzu.
Führe den folgenden apt-Befehl aus, um einige Paketabhängigkeiten zu installieren.
sudo apt install gnupg2 apt-transport-https software-properties-common wget
Gib y ein, wenn du zur Bestätigung aufgefordert wirst, und drücke ENTER, um fortzufahren.
Als nächstes führst du den folgenden Befehl aus, um den GPG-Schlüssel für das Grafana-Repository hinzuzufügen. Der erste Befehl lädt den GPG-Schlüssel des Grafana-Repositorys herunter und der zweite Befehl konvertiert die .key-Datei in das Format .gpg.
wget -q -O - https://packages.grafana.com/gpg.key > grafana.key cat grafana.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/grafana.gpg > /dev/null
Führe nun den folgenden Befehl aus, um das Grafana-Repository hinzuzufügen. In diesem Beispiel fügst du die Grafana OSS (Open Source Edition) mit einem stabilen Zweig hinzu.
echo 'deb [signed-by=/etc/apt/trusted.gpg.d/grafana.gpg] https://packages.grafana.com/oss/deb stable main' | sudo tee /etc/apt/sources.list.d/grafana.list
Zum Schluss aktualisierst du deinen Paketindex mit dem folgenden apt-Befehl.
sudo apt update
Du erhältst dann die Meldung, dass das Grafana-Repository zu deinem System hinzugefügt wurde.
Installieren und Konfigurieren von Grafana
Nachdem das Grafana-Repository nun hinzugefügt wurde, kannst du Grafana auf deinem System installieren. In diesem Schritt installierst du Grafana, startest und aktivierst den Grafana-Dienst und konfigurierst dann den Grafana-Server.
Führe zunächst den folgenden apt-Befehl aus, um das Grafana-Paket auf deinem System zu installieren.
sudo apt install grafana
Gib y ein, wenn du dazu aufgefordert wirst, und drücke ENTER, um fortzufahren.
Nachdem der Grafana-Server installiert ist, führe den folgenden Befehl aus, um den systemd manager neu zu laden und die neuen systemd-Dienste anzuwenden.
sudo systemctl daemon-reload
Als Nächstes führst du den folgenden systemctl-Befehl aus, um den„grafana-server“ zu starten und ihn zu aktivieren.
sudo systemctl start grafana-server sudo systemctl enable grafana-server
Der grafana-server sollte jetzt laufen und ist aktiviert. Überprüfe den grafana-server mit dem unten stehenden systemctl-Befehl.
sudo systemctl status grafana-server
Du solltest die Ausgabe erhalten, dass der grafana-server läuft und aktiviert ist, was bedeutet, dass der Dienst beim Hochfahren automatisch ausgeführt wird.
Wenn der Grafana-Server läuft, kannst du als Nächstes die Grafana-Installation über die Konfigurationsdatei„/etc/grafana/grafana.ini“ einrichten.
Öffne die Grafana-Konfigurationsdatei „/etc/grafana/grafana.ini“ mit dem unten stehenden nano-Editor-Befehl.
sudo nano /etc/grafana/grafana.ini
Ändere im Abschnitt „Server“ die Standardkonfiguration mit den folgenden Zeilen. Achte außerdem darauf, dass du die Option„domain“ mit deinem Domainnamen änderst. Du kannst die lokale Domain verwenden, die du in der Konfigurationsdatei„/etc/hosts“ konfigurieren kannst.
In diesem Beispiel wirst du den Grafana-Server mit der lokalen Domain„gpe.hwdomain.io“ betreiben.
[server]
# The IP address to bind to, empty will bind to all interfaces
http_addr = localhost
# The http port to use
http_port = 3000
# The public facing domain name used to access grafana from a browser
domain = gpe.hwdomain.io
Speichere die Datei und schließe den Editor, wenn du fertig bist.
Zum Schluss führst du den folgenden systemctl-Befehl aus, um den Dienst„grafana-server“ neu zu starten und die Änderungen zu übernehmen.
sudo systemctl restart grafana-server
Damit hast du die Installation und Grundkonfiguration des Grafana-Servers abgeschlossen. Der Grafana-Server läuft derzeit auf localhost mit dem Standard-TCP-Port 3000.
In den nächsten Schritten wirst du Nginx als Reverse Proxy für den Grafana-Server einrichten.
Installieren und Konfigurieren von Nginx
Nachdem der Grafana-Server installiert und konfiguriert ist, installierst und konfigurierst du nun Nginx als Reverse-Proxy für den Grafana-Server. Du wirst den Grafana-Server mit einer lokalen Domain betreiben, die mit SSL-Zertifikaten gesichert ist.
Bevor du anfängst, solltest du sicherstellen, dass du eine lokale Domain hast, die auf die IP-Adresse des Grafana-Servers aufgelöst ist und dass du SSL-Zertifikate für deine Domain erstellt hast. Du kannst selbstsignierte Zertifikate erstellen und als Beispiel für deinen Einsatz verwenden.
Um zu beginnen, führe den folgenden apt-Befehl aus, um das Nginx-Paket zu installieren.
sudo apt install nginx
Gib y ein, wenn du zur Bestätigung aufgefordert wirst, und drücke ENTER, um fortzufahren.
Nachdem Nginx installiert ist, erstellst du mit dem unten stehenden nano-Editor-Befehl eine neue Serverblock-Konfiguration „/etc/nginx/sites-available/grafana.conf“.
sudo nano /etc/nginx/sites-available/grafana.conf
Füge die folgenden Zeilen in die Datei ein und achte darauf, dass du den Domainnamen „gpe.hwdomain.io“ durch den Domainnamen deines Grafana-Servers ersetzt. Achte außerdem darauf, den Pfad der SSL-Zertifikate durch deine Zertifikatsdateien zu ersetzen.
Mit dieser Konfiguration wird Nginx als Reverse Proxy für den Grafana-Server eingesetzt, der auf localhost mit Port 3000 läuft. Außerdem sicherst du den Grafana-Server über eine HTTPS-Verbindung.
# this is required to proxy Grafana Live WebSocket connections.
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
server {
listen 80;
server_name gpe.hwdomain.io;
rewrite ^ https://$server_name$request_uri? permanent;
}
server {
listen 443 ssl http2;
server_name gpe.hwdomain.io;
root /usr/share/nginx/html;
index index.html index.htm;
ssl_certificate /etc/letsencrypt/live/gpe.hwdomain.io/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/gpe.hwdomain.io/privkey.pem;
access_log /var/log/nginx/grafana-access.log;
error_log /var/log/nginx/grafana-error.log;
location / {
proxy_set_header Host $http_host;
proxy_pass http://localhost:3000/;
}
# Proxy Grafana Live WebSocket connections.
location /api/live {
rewrite ^/(.*) /$1 break;
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/;
}
}
Speichere die Datei und beende den Editor, wenn du fertig bist.
Als Nächstes führst du den folgenden Befehl aus, um die Nginx-Serverkonfigurationsdatei “ zu aktivieren. Überprüfe dann die Nginx-Konfiguration, um sicherzustellen, dass du die richtigen Einstellungen vorgenommen hast.
sudo ln -s /etc/nginx/sites-available/grafana.conf /etc/nginx/sites-enabled/ sudo nginx -t
Du solltest eine Ausgabe wie „Test erfolgreich – Syntax ok“ erhalten, wenn du richtig konfiguriert hast.
Abbildung
Führe nun den folgenden Befehl aus, um den Nginx-Dienst neu zu starten und die Änderungen am Nginx-Dienst zu übernehmen.
sudo systemctl restart nginx
Zum Schluss führst du den folgenden systemctl-Befehl aus, um den Nginx-Dienst zu überprüfen und sicherzustellen, dass der Dienst läuft und aktiviert ist.
sudo systemctl is-enabled nginx sudo systemctl status nginx
Du erhältst eine ähnliche Ausgabe wie die folgende – Der Nginx-Dienst ist aktiviert und wird beim Hochfahren automatisch ausgeführt. Und der Status des Nginx-Dienstes ist „running“.
Wenn Nginx läuft und als Reverse Proxy für Grafana konfiguriert ist, kannst du jetzt über deine lokale Domain auf deinen Grafana-Server zugreifen.
Öffne deinen Webbrowser und rufe den Domainnamen deiner Grafana-Server-Installation auf (z.B.: https://gpe.hwdomain.io/). Du siehst dann die Anmeldeseite des Grafana-Servers.
Gib den Standardbenutzernamen und das Passwort „admin“ ein und klicke auf„Anmelden„.
Danach wirst du aufgefordert, das Standardpasswort für den Grafana-Admin-Benutzer zu ändern. Gib ein neues Passwort ein, wiederhole es und klicke auf„Absenden„, um es zu übernehmen.
Du erhältst nun das Grafana-Administrations-Dashboard.
Jetzt hast du Nginx als Reverse-Proxy für den Grafana-Server installiert und konfiguriert. Außerdem hast du den Standard-Admin-Benutzer und das Passwort für den Grafana-Server geändert und das Grafana-Administrations-Dashboard aufgerufen.
In den nächsten Schritten wirst du die Installation von Prometheus und node_exporter starten.
Installation von Prometheus
In diesem Schritt installierst du Prometheus manuell mit dem Binärpaket, das du von GitHub herunterladen kannst.
Nachfolgend findest du einige Schritte, die du für die Installation von Prometheus durchführen musst
- Prometheus-Benutzer einrichten
- Herunterladen des Prometheus-Binärpakets
- Prometheus konfigurieren
- Prometheus als systemd-Dienst ausführen
Jetzt können wir mit der Installation von Prometheus beginnen.
Einrichten des Prometheus-Benutzers
Führe den folgenden Befehl aus, um einen neuen Benutzer und die Gruppe„prometheus“ zu erstellen.
sudo groupadd --system prometheus sudo useradd -s /sbin/nologin --system -g prometheus prometheus
Prometheus herunterladen und installieren
Now create new data directories that will be used to store Prometheus data via the below command.
sudo mkdir /var/lib/prometheus
for i in rules rules.d files_sd; do sudo mkdir -p /etc/prometheus/${i}; done
Als Nächstes lädst du das Binärpaket für Prometheus mit dem unten stehenden curl-Befehl herunter.
curl -s https://api.github.com/repos/prometheus/prometheus/releases/latest|grep browser_download_url|grep linux-amd64|cut -d '"' -f 4|wget -qi -
Nachdem das Prometheus-Binärpaket heruntergeladen wurde, führe den folgenden Befehl aus, um Prometheus zu entpacken und verschiebe dein Arbeitsverzeichnis in das neue Prometheus-Verzeichnis.
tar xvf prometheus*.tar.gz cd prometheus*/
Führe nun den folgenden Befehl aus, um die Binärdateien „promtheus“ und „promtool“ in das Verzeichnis „/usr/local/bin“ zu verschieben.
sudo mv prometheus promtool /usr/local/bin/
Verschiebe einige Verzeichnisse und die Prometheus-Konfigurationsdatei in das Verzeichnis„/etc/prometheus„.
sudo mv consoles console_libraries prometheus.yml /etc/prometheus/
Als Nächstes änderst du die Eigentümerschaft der Prometheus-Konfigurationsdateien und -Verzeichnisse auf den Benutzer und die Gruppe„prometheus„. Führe die folgenden chmod und chown Befehle aus.
for i in rules rules.d files_sd; do sudo chown -R prometheus:prometheus /etc/prometheus/${i}; done
for i in rules rules.d files_sd; do sudo chmod -R 775 /etc/prometheus/${i}; done
sudo chown -R prometheus:prometheus /var/lib/prometheus/
Prometheus konfigurieren
Führe den folgenden apt-Befehl aus, um das Paket „apache2-utils“ zu installieren. Damit wird das bcrypt-Passwort generiert, mit dem die Prometheus-Installation durch Authentifizierung gesichert wird.
sudo apt install apache2-utils -y
Führe nun den Befehl„htpasswd“ aus, um ein neues bcrypt-Passwort zu erstellen.
htpasswd -nB promadmin
Gib das neue Passwort ein und wiederhole das Passwort. Du erhältst eine ähnliche Ausgabe wie diese – kopiere die Ausgabe in deine temporäre Notiz.
promadmin:$2y$05$PAHx4xWBNyZjPn9TGlYp.uH0esB1hXKQZfdQzn3PtcO49cUpOoxWG
Als nächstes erstellst du eine neue YML-Konfigurationsdatei „/etc/prometheus/web.yml“ mit dem unten stehenden nano-Editor-Befehl.
sudo nano /etc/prometheus/web.yml
Füge die folgenden Zeilen in die Datei ein und stelle sicher, dass du den Pfad der TLS/SSL-Zertifikate sowie den Benutzernamen und das Hash-Passwort änderst. Mit dieser Konfiguration aktivierst du sichere HTTPS-Verbindungen auf Prometheus und aktivierst die grundlegende Authentifizierung über den Benutzernamen und das Passwort.
# tls certificates tls_server_config: cert_file: /etc/letsencrypt/live/gpe.hwdomain.io/fullchain.pem key_file: /etc/letsencrypt/live/gpe.hwdomain.io/privkey.pem
# basic_auth
basic_auth_users:
promadmin: $2y$05$PAHx4xWBNyZjPn9TGlYp.uH0esB1hXKQZfdQzn3PtcO49cUpOoxWG
Speichere die Datei und schließe den Editor, wenn du fertig bist.
Führe nun den folgenden Befehl aus, um den Eigentümer der neuen Datei„/etc/prometheus/web.yml“ auf den Benutzer und die Gruppe„prometheus“ zu ändern.
sudo chown prometheus: /etc/prometheus/web.yml
Als Nächstes öffnest du die Hauptkonfiguration für Prometheus„/etc/prometheus/prometheus.yml“ mit dem unten stehenden nano-Editor-Befehl.
sudo nano /etc/prometheus/prometheus.yml
Im Abschnitt „scrape_configs“ änderst du den Standardwert „job_name: „prometheus““ durch die folgenden Zeilen. Achte außerdem darauf, die TLS-Konfiguration und den Pfad der SSL/TLS-Zertifikate sowie den Admin-Benutzer und das Passwort für deinen Prometheus-Server zu ändern.
Das Zielsystem oder der Server ist„localhost:9090„, also der Prometheus-Server selbst.
scrape_configs: # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config. - job_name: "prometheus" # metrics_path defaults to '/metrics' # scheme defaults to 'http'. # add settings for certificate and authentication scheme: https tls_config: cert_file: /etc/letsencrypt/live/gpe.hwdomain.io/fullchain.pem key_file: /etc/letsencrypt/live/gpe.hwdomain.io/privkey.pem # if using self-signed certificate, set [true] insecure_skip_verify: true basic_auth: username: 'admin' password: 'uniquepass' static_configs: # if using a valid certificate, set the same hostname in the certificate - targets: ["localhost:9090"]
Speichere die Datei und beende den Editor, wenn du fertig bist.
Prometheus als Systemd-Dienst starten
Als Nächstes führst du den folgenden Befehl aus, um eine neue systemd-Dienstdatei„/etc/systemd/system/prometheus.service“ zu erstellen.
Damit führst du Prometheus als systemd-Dienst aus, mit dem du Prometheus über das Dienstprogramm systemctl verwalten kannst. Außerdem aktivierst du die spezifische Konfiguration für die Prometheus-Webdatei„/etc/prometheus/web.yml„, die die sichere HTTPS-Verbindung und die grundlegende Authentifizierung aktiviert.
Schließlich wird der Prometheus-Dienst als Benutzer und Gruppe „prometheus“ mit dem Host „0.0.0.0“ und dem Port„9090“ ausgeführt.
sudo tee /etc/systemd/system/prometheus.service<<EOF [Unit] Description=Prometheus Documentation=https://prometheus.io/docs/introduction/overview/ Wants=network-online.target After=network-online.target [Service] Type=simple User=prometheus Group=prometheus ExecReload=/bin/kill -HUP $MAINPID ExecStart=/usr/local/bin/prometheus \ --config.file=/etc/prometheus/prometheus.yml \ --storage.tsdb.path=/var/lib/prometheus \ --web.console.templates=/etc/prometheus/consoles \ --web.console.libraries=/etc/prometheus/console_libraries \ --web.listen-address=0.0.0.0:9090 \ --web.config.file=/etc/prometheus/web.yml \ SyslogIdentifier=prometheus Restart=always [Install] WantedBy=multi-user.target EOF
Speichere die Datei und schließe den Editor, wenn du fertig bist.
Führe nun den unten stehenden systemctl-Befehl aus, um den systemd Manager neu zu starten und eine neue Servicedatei anzuwenden.
sudo systemctl daemon-reload
Starte und aktiviere dann den Prometheus-Dienst mit dem unten stehenden Befehl. Prometheus sollte jetzt als systemd-Dienst laufen und wird beim Hochfahren automatisch gestartet.
sudo systemctl start prometheus sudo systemctl enable prometheus
Überprüfe den Promtheheus-Dienst mit dem folgenden Befehl.
sudo systemctl status prometheus
Du erhältst eine Ausgabe wie im folgenden Screenshot – Der Prometheus wird gerade ausgeführt und ist jetzt aktiviert.
An diesem Punkt hast du die Installation von Prometheus auf einem Ubuntu-Server abgeschlossen. Prometheus läuft jetzt auf „0.0.0.0“ mit dem Standardport „9090“. Außerdem läuft er mit einer sicheren HTTPS-Verbindung und aktivierter Basisauthentifizierung.
Schließlich hast du„scrape_configs“ konfiguriert, um Metriken des Prometheus-Servers selbst zu sammeln.
In den nächsten Schritten installierst und konfigurierst du den node_exporter, um Systemmetriken zu sammeln und die gesammelten Daten und Metriken an den Prometheus-Server zu senden.
Installation von node_exporter
In den folgenden Schritten installierst du den node_exporter auf einem Ubuntu-System. Der node_exporter sammelt Systemmetriken und stellt eine HTTP-API bereit, die über den Standard-TCP-Port„9100“ läuft.
Führe den folgenden Befehl aus, um die neueste Version des Binärpakets node_exporter herunterzuladen.
curl -s https://api.github.com/repos/prometheus/node_exporter/releases/latest| grep browser_download_url|grep linux-amd64|cut -d '"' -f 4|wget -qi -
Nachdem du den node_exporter heruntergeladen hast, entpacke die Datei und verschiebe das Arbeitsverzeichnis dorthin.
tar -xvf node_exporter*.tar.gz cd node_exporter*/
Kopiere nun die Binärdatei von „node_exporter“ in das Verzeichnis „/usr/local/bin“.
sudo cp node_exporter /usr/local/bin
Überprüfe dann den node_exporter mit dem unten stehenden Befehl. Du solltest den vollständigen Pfad der node_exporter-Binärdatei und die aktuelle Version von node_exporter sehen.
which node_exporter node_exporter --version
In der folgenden Ausgabe siehst du, dass der node_exporter v1.4.0 installiert ist.
Als nächstes führst du den folgenden Befehl aus, um einen neuen systemd-Dienst für node_exporter zu erstellen: „/etc/systemd/system/node_exporter.service“. Damit kannst du node_exporter ganz einfach über das Dienstprogramm systemctl verwalten.
sudo tee /etc/systemd/system/node_exporter.service <<EOF [Unit] Description=Node Exporter Wants=network-online.target After=network-online.target [Service] User=prometheus ExecStart=/usr/local/bin/node_exporter [Install] WantedBy=default.target EOF
Lade nun den systemd manager neu, um die Änderungen und die neue Servicedatei zu übernehmen.
sudo systemctl daemon-reload
Starte und aktiviere den Dienst„node_exporter“ mit dem folgenden systemctl-Befehl. Der Dienst „node_exporter“ sollte jetzt aktiviert sein und wird beim Systemstart automatisch ausgeführt.
sudo systemctl start node_exporter sudo systemctl enable node_exporter
Überprüfe den node_exporter mit dem unten stehenden systemctl-Befehl.
sudo systemctl status node_exporter
Du erhältst eine ähnliche Ausgabe wie diese – Der node_exporter-Dienst läuft jetzt und ist aktiviert.
Damit hast du node_exporter installiert und so konfiguriert, dass der node_exporter als systemd-Dienst läuft. Der node_exporter läuft auf der Standard-IP-Adresse 0.0.0.0 mit dem Port„9100„. In den nächsten Schritten fügst du den node_exporter zum Prometheus-Server hinzu.
Hinzufügen von node_exporter zu Prometheus
Öffne die Prometheus-Konfigurationsdatei “ mit dem unten stehenden nano-Editor-Befehl.
sudo nano /etc/prometheus/prometheus.yml
Füge den neuen Scraper zum Abschnitt „scrape_configs“ hinzu. Füge die folgenden Zeilen in den Abschnitt „scrape_configs“ ein. Achte darauf, dass du den „job_name“ und den Zielserver mit deinen Angaben änderst.
scrape_configs: .... .... - job_name: "node_exporter" static_configs: - targets: ["192.168.5.100:9100"]
Speichere die Datei und beende den Editor, wenn du fertig bist.
Führe nun den folgenden systemcxtl-Befehl aus, um den Prometheus-Dienst neu zu starten und die Änderungen zu übernehmen.
sudo systemctl restart prometheus
Der neue Scraper node_exporter wird zum Prometheus-Server hinzugefügt.
Als Nächstes öffnest du deinen Webbrowser und rufst den Prometheus-Server mit der IP-Adresse„192.168.5.100“ und dem TCP-Port„9090“ auf – https://192.168.5.100:9090/. Du wirst nun zur Prometheus-Basisauthentifizierung aufgefordert.
Gib deinen Benutzernamen und dein Passwort ein und klicke zur Bestätigung auf„Anmelden„.
Wenn du den richtigen Benutzernamen und das richtige Passwort eingegeben hast, siehst du das Prometheus-Administrations-Dashboard.
Um zu überprüfen, ob der node_exporter aktiv ist oder nicht, gib die Prometheus-Abfrage wie„node_memory_Active_bytes“ ein und klicke auf „Ausführen„. Daraufhin erhältst du das einfache Diagramm, das von Prometheus erstellt wurde.
Klicke nun oben auf das Menü„Status“ und wähle„Ziele„. Du solltest zwei verschiedene Zielabfälle sehen, die aktiv sind und laufen. Das„prometheus“ zum Sammeln von Prometheus-Server-Metriken und das„node_exporter“ zum Sammeln von Systemmetriken.
Zu diesem Zeitpunkt sind die Komponenten für die Gebäudeüberwachung konfiguriert. Die Grafana-Datenvisualisierung läuft mit Nginx als Reverse Proxy, der Prometheus-Server läuft mit HTTPS und aktivierter Basisauthentifizierung, und der Zielhost ist ebenfalls mit node_exporter konfiguriert.
In den nächsten Schritten fügst du Prometheus als Datenquelle für die Grafana-Datenvisualisierung hinzu und erstellst dann das Dashboard-Monitoring.
Hinzufügen von Prometheus zu Grafana als Datenquelle
Grafana unterstützt mehrere Datenquellen wie MySQL, PostgreSQL, Influxdb, Graphite, Prometheus und viele mehr. In diesem Schritt fügst du Prometheus als Datenquelle auf dem Grafana-Server hinzu.
Gehe zurück zum Grafana Dashboard, klicke auf das Menü„Konfiguration“ und wähle„Datenquellen„.
Klicke auf„Datenquelle hinzufügen„, um neue Datenquellen in Grafana einzurichten.
Wähle nun die Art der Datenquelle aus, die du hinzufügen möchtest. In diesem Beispiel ist die Datenquelle Prometheus.
Gib die Details zum Prometheus-Server ein. Dazu gehören der Benutzername und das Passwort, mit denen du dich beim Prometheus-Server anmeldest, sowie die Prometheus-Hostadresse, die auf dem Standardport 9090 läuft. Achte außerdem darauf, dass du die Optionen„Basic auth“ und „Skip TLS verify“ aktivierst, wenn du selbstsignierte Zertifikate hast.
Klicke jetzt auf„Speichern & testen„, um die Datenquelle zu übermitteln und die Verbindung zu überprüfen. Du solltest eine Meldung wie „Datenquelle funktioniert“ erhalten.
Nachdem der Prometheus-Server als Datenquelle zum Grafana-Server hinzugefügt wurde, richtest du als Nächstes das Dashboard-Monitoring in Grafana ein.
Einrichten der Dashboard-Überwachung
Nachdem du Prometheus als Datenquelle zu Grafana hinzugefügt hast, erstellst du nun ein neues Dashboard für die Überwachung mit dem Datenvisualisierungstool Grafana. Du kannst das Dashboard manuell für jede Zelle erstellen und spezifische Prometheus-Abfragen für die Überwachung deines Systems definieren oder du kannst auch ein Beispiel für das Grafana-Dashboard aus dem Grafana-Repository importieren.
In diesem Schritt richtest du das Grafana-Dashboard ein, indem du das verfügbare Dashboard online in das Grafana importierst.
Klicke auf das Menü„Dashboard“ und wähle„Importieren„.
Jetzt kannst du Beispiele für ein Dashboard aus dem Grafana Dashboard Repository finden. In diesem Beispiel wird das Grafana Dashboard mit der ID „15172“ verwendet.
Gib die Dashboard-ID „15172“ ein, die du importieren möchtest, und klicke dann auf„Laden„.
Gib nun den Namen des neuen Dashboards ein und wähle„Prometheus“ als Datenquelle. Klicke zum Bestätigen auf„Importieren„.
Im folgenden Screenshot siehst du, dass das neue Grafana-Dashboard mit der Datenquelle Prometheus für die Systemüberwachung erstellt wurde.
Fazit
In diesem Tutorial hast du Grafana zur Datenvisualisierung mit Nginx als Reverse Proxy auf einem Ubuntu 22.04 Server installiert. Du hast auch Prometheus und node_exporter zusammen mit Grafana installiert.
Prometheus läuft mit aktivierter SSL/TLS-Verbindung, das Modul basic_auth ist für die Benutzerauthentifizierung aktiviert, und du hast zwei Scrapes zum Sammeln von Systemmetriken mit Prometheus selbst und node_expoter konfiguriert.
Schließlich hast du Prometheus als Datenquelle zu Grafana hinzugefügt und ein Dashboard zur Datenvisualisierung mit den von Prometheus und node_exporter gesammelten Daten importiert. Von hier aus kannst du einen weiteren Exporter für deine Anwendung zu Prometheus hinzufügen und alle Metriken über das Grafana Datenvisualisierungs-Dashboard visualisieren.