So installierst du den TIG Stack (Telegraf, InfluxDB und Grafana) unter Debian 12
Der TIG (Telegraf, InfluxDB und Grafana) Stack ist ein Akronym für eine Plattform von Open-Source-Tools, die das Sammeln, Speichern, Darstellen und Alarmieren von Systemmetriken erleichtern. Du kannst Metriken wie Arbeitsspeicher, Festplattenplatz, angemeldete Benutzer, Systemauslastung, Swap-Nutzung, Betriebszeit, laufende Prozesse usw. von einem Ort aus überwachen und visualisieren. Die im Stack verwendeten Tools sind wie folgt:
- Telegraf – ist ein Open-Source-Metriken-Sammel-Agent zum Sammeln und Senden von Daten und Ereignissen aus Datenbanken, Systemen und IoT-Sensoren. Er unterstützt verschiedene Output-Plugins wie InfluxDB, Graphite, Kafka usw., an die er die gesammelten Daten senden kann.
- InfluxDB – ist eine Open-Source-Zeitreihendatenbank, die in der Sprache Go geschrieben wurde. Sie ist für schnelle, hochverfügbare Speicherung optimiert und eignet sich für alles, was mit großen Mengen an Zeitstempeldaten zu tun hat, einschließlich Metriken, Ereignissen und Echtzeitanalysen.
- Grafana – ist eine Open-Source-Datenvisualisierungs- und Monitoring-Suite. Sie unterstützt verschiedene Input-Plugins wie Graphite, ElasticSearch, InfluxDB usw. Sie bietet ein wunderschönes Dashboard und Metrik-Analysen, mit denen du jede Art von Systemmetrik und Leistungsdaten visualisieren und überwachen kannst.
In diesem Tutorial lernst du, wie du den TIG Stack auf einem einzelnen Debian 12 Server installierst und konfigurierst.
Voraussetzungen
- Ein Server mit Debian 12 und mindestens 1 GB RAM.
- Ein Nicht-Sudo-Benutzer mit Root-Rechten.
- Die Unkomplizierte Firewall (UFW) ist aktiviert und läuft.
- Ein Fully Qualified Domain Name (FQDN) wie
grafana.example.com, der auf deinen Server zeigt. - Ein SMTP-Konto bei einem E-Mail-Dienst wie Amazon SES oder Mailgun, um E-Mail-Benachrichtigungen für Service-Warnungen zu erhalten.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update && sudo apt upgrade
- Einige wichtige Pakete werden benötigt, damit das Tutorial und das Craft CMS funktionieren. Einige davon befinden sich bereits auf deinem Server.
$ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y
Schritt 1 – Firewall konfigurieren
Bevor du die Pakete installierst, musst du als Erstes die Firewall so konfigurieren, dass sie die Ports für InfluxDB und Grafana öffnet.
Ü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)
Öffne Port 8086 für InfluxDB und 3000 für den Grafana-Server.
$ sudo ufw allow 8086 $ sudo ufw allow 3000
Erlaube HTTP und HTTPs Ports.
$ sudo ufw allow http $ sudo ufw allow https
Überprüfe den Status erneut, um ihn zu bestätigen.
$ sudo ufw status Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 8086 ALLOW Anywhere 3000 ALLOW Anywhere 80/tcp ALLOW Anywhere 443 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 8086 (v6) ALLOW Anywhere (v6) 3000 (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6)
Schritt 2 – Installiere InfluxDB
Wir verwenden das offizielle Repository von InfluxDB, um es zu installieren.
Lade den InfluxDB GPG-Schlüssel herunter.
$ wget -q https://repos.influxdata.com/influxdata-archive_compat.key
Importiere den GPG-Schlüssel auf den Server.
$ echo '393e8779c89ac8d958f81f942f9ad7fb82a25e133faddaf92e15b16e6ac9ce4c influxdata-archive_compat.key' | sha256sum -c && cat influxdata-archive_compat.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null influxdata-archive_compat.key: OK
Importiere das InfluxDB-Repository.
$ echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main' | sudo tee /etc/apt/sources.list.d/influxdata.list
Aktualisiere die Repository-Liste des Systems.
$ sudo apt update
Du hast die Möglichkeit, InfluxDB 1.8.x oder 2.0.x zu installieren. Es ist jedoch besser, die neueste Version zu verwenden. Installiere InfluxDB.
$ sudo apt install influxdb2
Starte den InfluxDB-Dienst.
$ sudo systemctl start influxdb
Überprüfe den Status des Dienstes.
$ sudo systemctl status influxdb
? influxdb.service - InfluxDB is an open-source, distributed, time series database
Loaded: loaded (/lib/systemd/system/influxdb.service; enabled; preset: enabled)
Active: active (running) since Tue 2024-01-02 02:39:41 UTC; 1s ago
Docs: https://docs.influxdata.com/influxdb/
Process: 5584 ExecStart=/usr/lib/influxdb/scripts/influxd-systemd-start.sh (code=exited, status=0/SUCCESS)
Main PID: 5585 (influxd)
Tasks: 8 (limit: 2299)
Memory: 53.1M
CPU: 735ms
CGroup: /system.slice/influxdb.service
??5585 /usr/bin/influxd
........
Schritt 3 – InfluxDB-Datenbank und Benutzeranmeldeinformationen erstellen
Um die Daten von Telegraf zu speichern, musst du die Influx-Datenbank und den Benutzer einrichten.
InfluxDB wird mit einem Kommandozeilen-Tool namens influx ausgeliefert, mit dem du mit dem InfluxDB-Server interagieren kannst. Stell dir influx als das mysql Kommandozeilentool vor.
Führe den folgenden Befehl aus, um die erste Konfiguration für Influx vorzunehmen.
$ influx setup > Welcome to InfluxDB 2.0! ? Please type your primary username navjot ? Please type your password *************** ? Please type your password again *************** ? Please type your primary organization name howtoforge ? Please type your primary bucket name tigstack ? Please type your retention period in hours, or 0 for infinite 360 ? Setup with these parameters? Username: navjot Organization: howtoforge Bucket: tigstack Retention Period: 360h0m0s Yes User Organization Bucket navjot howtoforge tigstack
Du musst deinen anfänglichen Benutzernamen, dein Passwort, den Namen deiner Organisation, den Namen des primären Buckets, in dem die Daten gespeichert werden, und die Aufbewahrungsfrist in Stunden für diese Daten festlegen. Deine Angaben werden in der Datei /home/username/.influxdbv2/configs gespeichert.
Du kannst diese Einrichtung auch vornehmen, indem du die URL http://<serverIP>:8086/ in deinem Browser aufrufst. Sobald du die Ersteinrichtung durchgeführt hast, kannst du dich mit den oben erstellten Anmeldedaten bei der URL anmelden.
Du solltest das folgende Dashboard sehen.
Bei der Ersteinrichtung wird ein Standard-Token erstellt, der vollen Lese- und Schreibzugriff auf alle Organisationen in der Datenbank hat. Aus Sicherheitsgründen benötigst du ein neues Token, das sich nur mit der Organisation und dem Bucket verbindet, mit denen wir uns verbinden wollen.
Um ein neues Token zu erstellen, klickst du auf das folgende Symbol in der linken Seitenleiste und dann auf den Link API-Tokens, um fortzufahren.
Du wirst auf die Seite mit den API-Tokens weitergeleitet. Hier siehst du das Standard-Token, das wir bei der Erstkonfiguration erstellt haben.
Klicke auf die Schaltfläche API-Token generieren und wähle die Option Benutzerdefiniertes API-Token, um ein neues Overlay-Popup zu öffnen. Gib dem Token einen Namen (telegraf), erweitere den Abschnitt Ressourcen und wähle den Standard-Bucket, den wir unter den Abschnitten Lesen und Schreiben erstellt haben.
Klicke auf Erzeugen, um die Erstellung des Tokens abzuschließen. Klicke auf die Schaltfläche COPY TO CLIPBOARD, um das Token zu kopieren. In manchen Fällen funktioniert die Schaltfläche nicht, daher solltest du sie bestätigen, bevor du das Popup-Fenster schließt.
Speichere es für den Moment, denn wir werden es später noch brauchen.
Damit ist die Installation und Konfiguration von InfluxDB abgeschlossen. Als Nächstes müssen wir Telegraf installieren.
Schritt 4 – Telegraf installieren
Telegraf und InfluxDB teilen sich das gleiche Repository. Das bedeutet, dass du Telegraf direkt installieren kannst.
$ sudo apt install telegraf
Der Dienst von Telegraf wird während der Installation automatisch aktiviert und gestartet.
Telegraf ist ein Plugin-gesteuerter Agent und verfügt über 4 Arten von Plugins:
- Input-Plugins sammeln Metriken.
- Prozessor-Plugins transformieren, dekorieren und filtern Metriken.
- Aggregator-Plugins erstellen und aggregieren Metriken.
- Output-Plugins definieren die Ziele, an die die Metriken gesendet werden, einschließlich InfluxDB.
Telegraf speichert seine Konfiguration für alle diese Plugins in der Datei /etc/telegraf/telegraf.conf. Der erste Schritt besteht darin, Telegraf mit InfluxDB zu verbinden, indem du das Output-Plugin influxdb_v2 aktivierst. Öffne die Datei /etc/telegraf/telegraf.conf zum Bearbeiten.
$ sudo nano /etc/telegraf/telegraf.conf
Finde die Zeile [[outputs.influxdb_v2]] und kommentiere sie aus, indem du das # davor entfernst. Bearbeite den Code darunter auf folgende Weise.
# # Configuration for sending metrics to InfluxDB 2.0
[[outputs.influxdb_v2]]
# ## The URLs of the InfluxDB cluster nodes.
# ##
# ## Multiple URLs can be specified for a single cluster, only ONE of the
# ## urls will be written to each interval.
# ## ex: urls = ["https://us-west-2-1.aws.cloud2.influxdata.com"]
urls = ["http://127.0.0.1:8086"]
#
# ## Token for authentication.
token = "$INFLUX_TOKEN"
#
# ## Organization is the name of the organization you wish to write to.
organization = "howtoforge"
#
# ## Destination bucket to write into.
bucket = "tigstack"
Füge den zuvor gespeicherten Wert des InfluxDB-Tokens anstelle der Variable $INFLUX_TOKEN in den obigen Code ein.
Suche nach der Zeile INPUT PLUGINS und du wirst sehen, dass die folgenden Eingabe-Plugins standardmäßig aktiviert sind.
# Read metrics about cpu usage [[inputs.cpu]] ## Whether to report per-cpu stats or not percpu = true ## Whether to report total system cpu stats or not totalcpu = true ## If true, collect raw CPU time metrics collect_cpu_time = false ## If true, compute and report the sum of all non-idle CPU states report_active = false ## If true and the info is available then add core_id and physical_id tags core_tags = false # Read metrics about disk usage by mount point [[inputs.disk]] ## By default stats will be gathered for all mount points. ## Set mount_points will restrict the stats to only the specified mount points. # mount_points = ["/"] ## Ignore mount points by filesystem type. ignore_fs = ["tmpfs", "devtmpfs", "devfs", "iso9660", "overlay", "aufs", "squashfs"] ## Ignore mount points by mount options. ## The 'mount' command reports options of all mounts in parathesis. ## Bind mounts can be ignored with the special 'bind' option. # ignore_mount_opts = [] # Read metrics about disk IO by device [[inputs.diskio]] .... .... # Get kernel statistics from /proc/stat [[inputs.kernel]] # no configuration # Read metrics about memory usage [[inputs.mem]] # no configuration # Get the number of processes and group them by status [[inputs.processes]] # no configuration # Read metrics about swap memory usage [[inputs.swap]] # no configuration # Read metrics about system load & uptime [[inputs.system]] # no configuration
Du kannst je nach Bedarf weitere Input-Plugins konfigurieren, z. B. Apache Server, Docker-Container, Elasticsearch, iptables firewall, Kubernetes, Memcached, MongoDB, MySQL, Nginx, PHP-fpm, Postfix, RabbitMQ, Redis, Varnish, Wireguard, PostgreSQL, usw.
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den Telegraf-Dienst neu, nachdem du die Änderungen vorgenommen hast.
$ sudo systemctl restart telegraf
Schritt 5 – Überprüfe, ob die Telegraf-Statistiken in InfluxDB gespeichert werden
Bevor du fortfährst, musst du überprüfen, ob die Telegraf-Statistiken korrekt erfasst und in die InfluxDB eingespeist werden. Öffne die InfluxDB-Benutzeroberfläche in deinem Browser, klicke auf das zweite Symbol in der linken Seitenleiste und wähle das Menü Buckets.
Klicke auf tigstack und du solltest die folgende Seite sehen.
Klicke auf den Bucket-Namen und dann auf einen der Werte im Filter _measurement und klicke immer wieder auf andere Werte, wenn sie erscheinen. Wenn du fertig bist, klicke auf die Schaltfläche Senden. Oben solltest du ein Diagramm sehen. Es kann sein, dass du einige Zeit warten musst, bis die Daten angezeigt werden. Wir haben das Zeitintervall von „Past 1 h “ auf „Past 5m“ verschoben, um ein Diagramm über einen großen Bereich zu erstellen.
Das sollte bestätigen, dass die Daten korrekt weitergegeben werden.
Schritt 6 – Grafana installieren
Wir verwenden das offizielle Grafana-Repository, um es zu installieren. Importiere den Grafana GPG-Schlüssel.
$ sudo mkdir -p /etc/apt/keyrings/ $ wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null
Füge das Repository zu deinem System hinzu.
$ echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
Wenn du Grafana beta installieren möchtest, füge stattdessen das folgende Repository hinzu.
$ echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com beta main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
Aktualisiere die Liste der System-Repositories.
$ sudo apt update
Installiere Grafana.
$ sudo apt install grafana
Starte und aktiviere den Grafana-Dienst.
$ sudo systemctl enable grafana-server --now
Überprüfe den Status des Dienstes.
$ sudo systemctl status grafana-server
? grafana-server.service - Grafana instance
Loaded: loaded (/lib/systemd/system/grafana-server.service; enabled; preset: enabled)
Active: active (running) since Tue 2024-01-02 03:48:01 UTC; 3s ago
Docs: http://docs.grafana.org
Main PID: 8769 (grafana)
Tasks: 7 (limit: 2299)
Memory: 42.6M
CPU: 1.804s
CGroup: /system.slice/grafana-server.service
??8769 /usr/share/grafana/bin/grafana server --config=/etc/grafana/grafana.ini --pidfile=/run/grafana/grafana-server.pid --packaging=deb cfg:default.paths.logs=/var/log/grafana cfg:default.paths...
.......
Schritt 7 – Grafana-Datenquelle einrichten
Starte die URL http://<serverIP>:3000 in deinem Browser und die folgende Grafana-Anmeldeseite sollte dich begrüßen.
Melde dich mit dem Standardbenutzernamen admin und dem Passwort admin an. Als Nächstes musst du ein neues Standardpasswort einrichten.
Du wirst mit der folgenden Grafana-Startseite begrüßt. Klicke auf die Schaltfläche Füge deine erste Datenquelle hinzu.
Klicke auf die Schaltfläche InfluxDB.
Auf der nächsten Seite wählst du Flux aus dem Dropdown-Menü als Abfragesprache aus. Du kannst auch InfluxQL als Abfragesprache verwenden, aber es ist komplizierter zu konfigurieren, da es standardmäßig nur InfluxDB v1.x unterstützt. Flux unterstützt InfluxDB v2.x und ist einfacher einzurichten und zu konfigurieren.
Gib die folgenden Werte ein.
URL: http://localhost:8086 Basic Auth Details Benutzer: navjot Passwort: <yourinfluxdbpassword>
InfluxDB Details Organisation: howtoforge Token: <influxdbtoken> Standard Bucket: tigstack
Klicke auf die Schaltfläche Speichern und testen und du solltest eine Bestätigungsmeldung sehen, die bestätigt, dass die Einrichtung erfolgreich war.
Schritt 8 – Grafana Dashboards einrichten
Im nächsten Schritt richtest du Grafana Dashboards ein. Klicke auf das Hamburger-Menü links neben Home und dann auf Dashboards, um den Bildschirm Dashboard erstellen zu öffnen.
Klicke auf die Schaltfläche Dashboard erstellen, um fortzufahren.
Auf der nächsten Seite klickst du auf die Schaltfläche Visualisierung hinzufügen, um das Overlay zu starten und auf influxdb-1, um es als Datenquelle auszuwählen.
Du gelangst zur folgenden Seite Panel bearbeiten.
Füge den folgenden Code in den Abfrage-Editor ein.
from(bucket: "NAMEOFYOUBUCKET")
|> range(start: v.timeRangeStart, stop: v.timeRangeStop)
|> filter(fn: (r) => r["_measurement"] == "cpu")
|> filter(fn: (r) => r["_field"] == "usage_idle")
|> filter(fn: (r) => r["cpu"] == "cpu-total")
|> filter(fn: (r) => r["host"] == "NAMEOFYOURHOST")
|> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
|> map(fn: (r) => ({ r with _value: r._value * -1.0 + 100.0 }))
|> toFloat()
|> yield(name: "mean")
Verwende den Namen des Buckets, den wir oben verwendet haben. Und den Namen des Hosts, den du aus der Datei /etc/hostname abrufen kannst.
Der obige Code berechnet die CPU-Auslastung und erstellt ein Diagramm dazu. Gib dem Panel einen Titel.
Klicke auf die Schaltfläche Abfrageinspektor und dann auf die Schaltfläche Aktualisieren, um zu überprüfen, ob deine Abfrage erfolgreich funktioniert. Klicke auf das Kreuzsymbol, um den Inspektor zu schließen.
Du kannst der Achse auch einen Namen geben, indem du das Beschriftungsfeld rechts unter dem Achsenabschnitt benutzt.
Klicke auf die Schaltfläche Übernehmen, um das Panel zu speichern. Klicke auf die Schaltfläche Dashboard speichern, wenn du fertig bist.
Gib dem Dashboard einen Namen und klicke zum Abschluss auf Speichern.
Das Dashboard wird geöffnet und du kannst auf die Schaltfläche Visualisierung hinzufügen klicken, um ein weiteres Panel zu erstellen.
Wiederhole den Vorgang und erstelle ein weiteres Panel für die RAM-Auslastung.
from(bucket: "NAMEOFYOUBUCKET") |> range(start: v.timeRangeStart, stop: v.timeRangeStop) |> filter(fn: (r) => r["_measurement"] == "mem") |> filter(fn: (r) => r["_field"] == "used_percent") |> filter(fn: (r) => r["host"] == "NAMEOFYOURHOST") |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false) |> yield(name: "mean")
Verwende den folgenden Code für die Anzeige der Festplattenauslastung.
from(bucket: "NAMEOFYOURBUCKET")
|> range(start: v.timeRangeStart, stop: v.timeRangeStop)
|> filter(fn: (r) => r["_measurement"] == "disk")
|> filter(fn: (r) => r["_field"] == "used")
|> filter(fn: (r) => r["path"] == "/")
|> filter(fn: (r) => r["host"] == "NAMEOFYOURHOST")
|> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
|> map(fn: (r) => ({ r with _value: r._value / 1000000.0 }))
|> toFloat()
|> yield(name: "mean")
Du kannst eine unbegrenzte Anzahl von Panels erstellen.
Der obige Code basiert auf der Flux Scripting Sprache. Zum Glück musst du diese Sprache nicht lernen, um Abfragen zu schreiben. Du kannst die Abfrage aus der InfluxDB URL generieren. Auch wenn das Erlernen der Sprache bei der Optimierung der Abfragen von Vorteil sein kann.
Um die Abfrage zu erhalten, musst du zum InfluxDB Dashboard zurückkehren und die Seite Explore öffnen.
Klicke auf den Bucket-Namen und dann auf einen der Werte im Filter _measurement und klicke immer wieder auf andere Werte, wenn sie erscheinen. Wenn du fertig bist, klicke auf die Schaltfläche Skript-Editor und du solltest die folgende Seite sehen. Das Diagramm sollte ebenfalls aktualisiert werden.
Kopiere die angezeigte Abfrage und du kannst sie jetzt im Grafana-Dashboard verwenden, um deine Diagramme zu erstellen.
Schritt 9 – Alarme und Benachrichtigungen konfigurieren
Die Einrichtung von Monitoren dient in erster Linie dazu, rechtzeitig Warnungen zu erhalten, wenn der Wert einen bestimmten Schwellenwert überschreitet.
Der erste Schritt besteht darin, das Ziel festzulegen, an das du die Benachrichtigungen senden möchtest. Du kannst Benachrichtigungen per E-Mail, Slack, Kafka, Google Hangouts Chat, Microsoft Teams, Telegram, etc. erhalten.
Für unseren Lehrgang werden wir E-Mail-Benachrichtigungen aktivieren. Um E-Mail-Benachrichtigungen einzurichten, müssen wir zunächst den SMTP-Dienst konfigurieren. Öffne die Datei /etc/grafana/grafana.ini, um SMTP zu konfigurieren.
$ sudo nano /etc/grafana/grafana.ini
Finde darin die folgende Zeile [smtp]. Hebe die Kommentare in den folgenden Zeilen auf und gib die Werte für den benutzerdefinierten SMTP-Server ein.
[smtp] enabled = true host = email-smtp.us-west-2.amazonaws.com:587 user = YOURUSERNAME # If the password contains # or ; you have to wrap it with triple quotes. Ex """#password;""" password = YOURUSERPASSWORD ;cert_file = ;key_file = ;skip_verify = false from_address = user@example.com from_name = HowtoForge Grafana # EHLO identity in SMTP dialog (defaults to instance_name) ;ehlo_identity = dashboard.example.com # SMTP startTLS policy (defaults to 'OpportunisticStartTLS') ;startTLS_policy = NoStartTLS
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den Grafana-Server neu, um die Einstellungen zu übernehmen.
$ sudo systemctl restart grafana-server
Öffne die Grafana-Seite, klicke auf das Alert-Symbol und dann auf Kontaktpunkte.
Grafana erstellt und richtet automatisch einen Standard-E-Mail-Kontaktpunkt ein, der mit der richtigen E-Mail-Adresse konfiguriert werden muss. Klicke auf die Schaltfläche Bearbeiten über dem Kontaktpunkt grafana-default-email.
Gib die Details ein, um den E-Mail-Benachrichtigungskanal einzurichten.
Wenn du eine zusätzliche Nachricht senden möchtest, klicke auf den Link Optionale E-Mail-Einstellungen und gib die Nachricht ein.
Klicke auf Testen, um das Popup zu öffnen, und dann auf die Schaltfläche Testbenachrichtigung senden, um zu sehen, ob die E-Mail-Einstellungen funktionieren. Klicke auf Kontaktpunkt speichern, wenn du fertig bist.
Du solltest die folgende E-Mail erhalten, in der die Einstellungen bestätigt werden.
Jetzt, wo wir die Benachrichtigungskanäle eingerichtet haben, müssen wir noch Benachrichtigungen einrichten, wenn wir diese E-Mails erhalten. Um die Benachrichtigungen einzurichten, musst du zurück zu den Dashboard-Panels gehen.
Gehe zurück zum Bildschirm Dashboards. Klicke auf das Dashboard, das wir gerade erstellt haben, und du erhältst die Startseite mit den verschiedenen Bereichen. Um ein Panel zu bearbeiten, klicke auf den Namen des Panels und ein Dropdown-Menü wird angezeigt. Klicke auf den Link Bearbeiten, um fortzufahren.
Klicke auf das Alarm-Panel und klicke auf die Schaltfläche Neue Alarmregel, um einen neuen Alarm einzurichten. Wir erstellen eine Warnung für das Panel CPU-Nutzung.
Du kannst nun die Bedingungen konfigurieren, unter denen Grafana den Alarm sendet. Klicke auf das Dropdown-Menü des Links Optionen und wähle den Standard-Zeitbereich (jetzt-6h bis jetzt), um den Zeitbereich auf die letzten 15 Minuten zu ändern, d.h. es wird von vor 15 Minuten bis jetzt geprüft.
Standardmäßig ist der ausgewählte Alarmtyp der von Grafana verwaltete Alarm. Es sind standardmäßig zwei Ausdrücke ausgewählt. Lösche sie, indem du auf die Schaltfläche Papierkorb drückst. Wähle das Dropdown-Menü Ausdruck hinzufügen und wähle die klassische Bedingung als Ausdruckstyp.
Klicke auf Als Alert-Bedingung festlegen, um den gewählten Ausdruck für den Versand der Alerts auszuwählen. Dadurch ändert sich das Ausdrucksfeld wie unten dargestellt.
Bedingungen
Grafana arbeitet mit einer Abfrage des folgenden Formats, um zu bestimmen, wann ein Alert ausgelöst werden soll.
avg() OF query(A) IS ABOVE 0.8
- avg() steuert, wie der Wert für jede Reihe auf einen vergleichbaren Wert zum Schwellenwert reduziert werden soll. Du kannst auf den Funktionsnamen klicken, um eine andere Funktion auszuwählen, z.B. avg(), min(), max(), sum(), count(), etc.
- Abfrage(A) Der Buchstabe in der Klammer legt fest, welche Abfrage auf der Registerkarte Metriken ausgeführt werden soll.
- IS BELOW 14 Legt die Art des Schwellenwerts und den Schwellenwert fest. Du kannst auf IS BELOW klicken, um einen anderen Schwellentyp auszuwählen.
Du kannst eine zweite Bedingung darunter hinzufügen, indem du auf die Schaltfläche + unter der ersten Bedingung klickst. Derzeit kannst du nur AND- und OR-Operatoren zwischen mehreren Bedingungen verwenden.
Als Nächstes legen wir das Auswertungsverhalten fest. Klicke auf die Schaltfläche Neuer Ordner, um einen Ordner zum Speichern deiner Regeln zu erstellen. Klicke auf die Schaltfläche Neue Bewertungsgruppe, um eine Gruppe von Regeln zu erstellen, die nach demselben Zeitintervall ausgewertet werden sollen. Lege bei der Erstellung der Gruppe das Zeitintervall auf 5m fest.
Wenn du fertig bist, sollte die Seite wie folgt aussehen. Setze den Alarmstatus bei Ausführungsfehler oder Zeitüberschreitung auf Alarmierung.
Regel
- Name – Gib einen beschreibenden Namen für die Warnung ein
- Ordner – Erstelle einen Ordner oder wähle einen bereits existierenden Ordner aus, um deine Benachrichtigungsregel zu speichern.
- Gruppe – Gib einen Namen für deine Benachrichtigungsgruppe ein. Benachrichtigungen in einer Gruppe werden nach dem gleichen Zeitintervall ausgewertet.
- Ausstehend – Lege fest, wie oft Grafana die Benachrichtigung auswerten soll. Es wird auch als Bewertungsintervall bezeichnet. Du kannst hier jeden beliebigen Wert einstellen.
Keine Daten & Fehlerbehandlung
Du kannst konfigurieren, wie Grafana Abfragen behandeln soll, die keine Daten oder nur Nullwerte zurückgeben, indem du die folgenden Bedingungen verwendest:
- Keine Daten – Setze den Regelstatus auf
NoData - Alerting – Setze den Regelstatus auf
Alerting - Ok – Setze den Status der Warnregel auf
Ok, da du eine Warnung erhältst, auch wenn alles in Ordnung ist.
Du kannst Grafana mitteilen, wie Ausführungs- oder Timeout-Fehler behandelt werden sollen.
- Alerting – Setze den Status der Regel auf
Alerting - Ok – Setze den Status der Warnregel auf
Ok, da du auch dann eine Warnung erhältst, wenn alles in Ordnung ist. - Fehler – Setze den Status der Warnregel auf Fehler, um anzuzeigen, dass es ein Problem gibt.
Wenn du fertig bist, klicke auf die Schaltfläche Vorschau der Warnmeldungen, um zu sehen, ob alles gut funktioniert. Klicke oben rechts auf die Schaltfläche Regel speichern und beenden, um das Hinzufügen der Warnmeldung abzuschließen. Du solltest jetzt Benachrichtigungen über deine E-Mails erhalten. Hier ist ein Beispiel für eine solche E-Mail.
Schritt 10 – Nginx installieren
Debian 12 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 Mainline-Version von Nginx hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/mainline/debian `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. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.
$ sudo nginx -v nginx version: nginx/1.25.3
Starte den Nginx-Server.
$ sudo systemctl start nginx
Überprüfe den Status des Dienstes.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
Active: active (running) since Tue 2024-01-02 09:21:10 UTC; 5s ago
Docs: https://nginx.org/en/docs/
Process: 12964 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 12965 (nginx)
Tasks: 3 (limit: 2299)
Memory: 2.9M
CPU: 86ms
CGroup: /system.slice/nginx.service
??12965 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??12966 "nginx: worker process"
??12967 "nginx: worker process"
Jan 02 09:21:10 grafana systemd[1]: Starting nginx.service - nginx - high performance web server...
Jan 02 09:21:10 grafana systemd[1]: Started nginx.service - nginx - high performance web server.
Schritt 11 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Debian 12 ist Snapd noch nicht installiert. Installiere das Snapd-Paket.
$ sudo apt install snapd
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
Überprüfe, ob Certbot richtig funktioniert.
$ certbot --version certbot 2.8.0
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 grafana.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/grafana.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.
$ systemctl list-timers
Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
NEXT LEFT LAST PASSED UNIT ACTIVATES ----------------------------------------------------------------------------------------------------------------------------------------- Tue 2024-01-02 15:24:52 UTC 6h left Mon 2024-01-01 15:24:52 UTC 17h ago systemd-tmpfiles-clean.timer systemd-tmpfiles-clean.service Tue 2024-01-02 20:05:29 UTC 10h left Tue 2024-01-02 09:02:47 UTC 21min ago apt-daily.timer apt-daily.service Tue 2024-01-02 20:35:00 UTC 11h left - - snap.certbot.renew.timer snap.certbot.renew.service
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 12 – Nginx für Grafana und InfluxDB 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/grafana.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/grafana.conf
Füge den folgenden Code in die Datei ein. Ersetze grafana.example.com durch deinen Domainnamen.
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
server {
listen 443 ssl reuseport;
listen [::]:443 ssl reuseport;
http2 on;
server_name grafana.example.com;
access_log /var/log/nginx/grafana.access.log;
error_log /var/log/nginx/grafana.error.log;
ssl_certificate /etc/letsencrypt/live/grafana.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/grafana.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/grafana.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 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] valid=60s;
resolver_timeout 2s;
location / {
proxy_set_header Host $http_host;
proxy_pass http://localhost:3000;
}
location /api/live {
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;
}
location /influxdb/ {
access_log /var/log/nginx/influx.access.log;
error_log /var/log/nginx/influx.error.log;
rewrite ^/influxdb$ /influxdb/ permanent;
rewrite ^/influxdb/(.*)$ /$1 break;
proxy_cookie_path ~*^/api /influxdb/api;
proxy_connect_timeout 600s;
proxy_http_version 1.1;
proxy_pass http://localhost:8086;
proxy_read_timeout 600s;
proxy_send_timeout 600s;
proxy_set_header Authorization $http_authorization;
proxy_set_header Connection "upgrade";
proxy_set_header Host $http_host;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto https;
proxy_set_header X-Real-IP $remote_addr;
sub_filter '<base href="/">' '<base href="/influxdb/">';
sub_filter 'src="/' 'src="/influxdb/';
sub_filter 'href="/' 'href="/influxdb/';
sub_filter 'data-basepath="' 'data-basepath="/influxdb/';
sub_filter 'n.p="/"' 'n.p="/influxdb/"';
sub_filter 'o.p="/"' 'o.p="/influxdb/"';
sub_filter '/api/' '/influxdb/api/';
sub_filter 'api/v2/query' 'influxdb/api/v2/query';
sub_filter '/health`' '/influxdb/health`';
sub_filter_types text/css text/javascript application/javascript application/json;
sub_filter_once off;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name grafana.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 deine Nginx-Konfiguration.
$ sudo nginx -t
Starte den Nginx-Server neu.
$ sudo systemctl restart nginx
Telegraf für HTTPS konfigurieren
Öffne die Datei /etc/telegraf/telegraf.conf zum Bearbeiten.
$ sudo nano /etc/telegraf/telegraf.conf
Suche nach dem Abschnitt [[outputs.influxdb_v2]] und ändere den Wert der URL in https://grafana.nspeaks.com/influxdb, damit die Daten zwischen InfluxDB und Telegraf gesichert sind.
urls = ["https://grafana.example.com/influxdb"]
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den Telegraf-Dienst neu.
$ sudo systemctl restart telegraf
Grafana für HTTPS konfigurieren
Als Nächstes müssen wir Grafana für den HTTPS-Zugang konfigurieren. Öffne die Datei /etc/grafana/grafana.ini zum Bearbeiten.
$ sudo nano /etc/grafana/grafana.ini
Suche den Abschnitt [server] und ändere die Variablen domain und root_url wie folgt.
# The public facing domain name used to access grafana from a browser ;domain = localhost domain = grafana.example.com # Redirect to correct domain if host header does not match domain # Prevents DNS rebinding attacks ;enforce_domain = true # The full public facing url you use in browser, used for redirects and emails # If you use reverse proxy and sub path specify full url (with sub path) ;root_url = %(protocol)s://%(domain)s:%(http_port)s/ root_url = %(protocol)s://%(domain)s
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den Grafana Server neu.
$ sudo systemctl restart grafana-server
Firewall Ports für InfluxDB und Grafana schließen
Du solltest auch die Ports von InfluxDB und Grafana schließen.
$ sudo ufw delete allow 8086 $ sudo ufw delete allow 3000
Grafana sollte unter https://grafana.example.com erreichbar sein und InfluxDB UI und API sollten beide unter der URL https://grafana.example.com/influxdb erreichbar sein.
Fazit
Damit ist die Anleitung zur Installation und Konfiguration des TIG Stack auf einem Debian 12 Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.