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.