Installation und Überwachung von Diensten mit dem Netdata Monitoring Tool unter Rocky Linux 8

Netdata ist ein Open-Source-Überwachungssystem für Linux-basierte Betriebssysteme. Es bietet Echtzeit-Leistung und -Überwachung mit schönen und detaillierten Dashboards. Es bietet Hunderte von Tools zur Überwachung von Servern, CPU, Speichernutzung, Systemprozessen, Festplattennutzung, IPv4- und IPv6-Netzwerken, Systemfirewall und Anwendungen wie Nginx, MySQL, MongoDB, Redis, ElasticSearch, PostgreSQL, PHP-FPM usw. Es lässt sich mit anderen Monitoring-Tools wie Prometheus, Graphite, Kafka, Grafana und anderen integrieren.

In diesem Lernprogramm lernst du, wie du verschiedene Dienste mit dem Netdata Tool auf einem Rocky Linux 8 Server installierst und überwachst. Wir werden Netdata nutzen, um die Metriken eines LEMP-Stacks und einer Docker-Engine zu überwachen.

Voraussetzungen

• Ein Server mit Rocky Linux 8.
• Ein Nicht-Root-Benutzer mit sudo-Rechten.
• Ein Fully Qualified Domain Name (FQDN) wie netdata.example.com, der auf deinen Server zeigt.
• Ein Slack-Konto und einen Arbeitsbereich für den Empfang von Benachrichtigungen.
• Ein SMTP-Konto bei einem E-Mail-Dienst wie Amazon SES oder Mailgun.
• Deaktiviere SELinux.

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.

$ sudo firewall-cmd --permanent --list-services

Es sollte die folgende Ausgabe angezeigt werden.

cockpit dhcpv6-client ssh

Lasse HTTP- und HTTPS-Ports zu.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Überprüfe erneut den Status der Firewall.

$ sudo firewall-cmd --permanent --list-services

Du solltest eine ähnliche Ausgabe sehen.

cockpit dhcpv6-client http https ssh

Lade die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Schritt 2 – NetData installieren

Netdata wird mit einem Installationsskript geliefert, das auf jeder Linux-Distribution funktioniert. Führe den folgenden Befehl aus, um das Installationsskript herunterzuladen und auszuführen.

$ bash <(curl -Ss https://my-netdata.io/kickstart.sh)

Du wirst nach deinem sudo-Passwort gefragt, um die sudo-Rechte zu aktivieren. Gib Y ein, um das Hinzufügen des Netdata-Repositorys und die Installation auf deinem Server zu bestätigen.

Das Netdata-Installationsprogramm aktiviert und startet den Dienst automatisch. Überprüfe den Status des Dienstes.

$ sudo systemctl status netdata
? netdata.service - Real time performance monitoring
   Loaded: loaded (/usr/lib/systemd/system/netdata.service; enabled; vendor preset: disabled)
   Active: active (running) since Mon 2022-04-11 12:09:12 UTC; 13s ago
 Main PID: 19443 (netdata)
    Tasks: 32 (limit: 11412)
   Memory: 52.0M
   CGroup: /system.slice/netdata.service
           ??19443 /usr/sbin/netdata -P /var/run/netdata/netdata.pid -D
           ??19448 /usr/sbin/netdata --special-spawn-server
           ??19937 /usr/libexec/netdata/plugins.d/apps.plugin 1
           ??19944 /usr/libexec/netdata/plugins.d/go.d.plugin 1

Apr 11 12:09:12 netdata systemd[1]: Started Real time performance monitoring.
.......

Wenn dein Dienst nicht gestartet oder aktiviert ist, kannst du dies mit dem folgenden Befehl nachholen.

$ sudo systemctl enable netdata --now

Führe den folgenden Befehl aus, um die offenen Ports und den Prozess, der sie benutzt, zu überprüfen.

$ sudo ss -plnt

Du solltest eine ähnliche Ausgabe erhalten. Netdata verwendet Port 19999 für sein Dashboard, wie in der folgenden Ausgabe zu sehen ist. Netdata verwendet Port 8125, um Statistiken von anderen Anwendungen zu empfangen.

State            Recv-Q           Send-Q                     Local Address:Port                      Peer Address:Port           Process
LISTEN           0                128                            127.0.0.1:8125                           0.0.0.0:*               users:(("netdata",pid=22496,fd=29))
LISTEN           0                128                              0.0.0.0:19999                          0.0.0.0:*               users:(("netdata",pid=22496,fd=6))
......
LISTEN           0                128                                [::1]:8125                              [::]:*               users:(("netdata",pid=22496,fd=28))
LISTEN           0                128                                 [::]:19999                             [::]:*               users:(("netdata",pid=22496,fd=7))

Schritt 3 – SSL installieren

Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren.

Als erstes musst du das EPEL-Repository herunterladen und installieren.

$ sudo dnf install epel-release

Führe die folgenden Befehle aus, um Certbot zu installieren.

$ sudo dnf install certbot

Erstelle das SSL-Zertifikat.

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

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

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Erstelle ein Challenge-Web-Root-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.

$ sudo nano /etc/cron.daily/certbot-renew

Füge den folgenden Code ein.

#!/bin/sh
certbot renew --cert-name netdata.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"

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

Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.

$ sudo chmod +x /etc/cron.daily/certbot-renew

Schritt 4 – Nginx installieren und konfigurieren

Wir werden die neueste Version von Nginx installieren. Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.

$ sudo nano /etc/yum.repos.d/nginx.repo

Füge die folgenden Zeilen in die Datei ein.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

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

Installiere Nginx und die HTTPD-Tools.

$ sudo dnf install nginx httpd-tools

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.20.2

Aktiviere und starte den Nginx-Dienst.

$ sudo systemctl enable nginx --now

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

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

Füge den folgenden Code in die Datei ein.

# Define netdata upstream
upstream netdata {
    server 127.0.0.1:19999;
    keepalive 64;
}

# Redirect all non-encrypted to encrypted
server {
    listen 80;
    listen [::]:80;
    server_name netdata.example.com;
    return 301 https://netdata.example.com$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    
    server_name netdata.example.com;

    ssl_certificate     /etc/letsencrypt/live/netdata.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/netdata.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/netdata.example.com/chain.pem;
    ssl_session_timeout 1d;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_prefer_server_ciphers off;
    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] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
    resolver_timeout 2s;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    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;

    access_log /var/log/nginx/netdata.example.com.access.log main;
    error_log  /var/log/nginx/netdata.example.com.error.log;

    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Server $host;
    	proxy_pass http://netdata;
    	proxy_http_version 1.1;
        proxy_pass_request_headers on;
        proxy_set_header Connection "keep-alive";
        proxy_store off;
        auth_basic "NetData Private Area";
	    auth_basic_user_file /etc/nginx/.htpasswd;
    }
}

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Öffne die Datei /etc/nginx/nginx.conf und bearbeite sie.

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

Führe den folgenden Befehl aus, um eine Passwortdatei für die HTTP-Authentifizierung zu erstellen.

$ sudo htpasswd -c /etc/nginx/.htpasswd netadmin
New password: 
Re-type new password: 
Adding password for user netadmin

Ü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, um die neue Konfiguration zu aktivieren.

$ sudo systemctl restart nginx

Schritt 5 – Zugriff und Nutzung des Netdata Dashboards

Du solltest in der Lage sein, über die URL https://netdata.example.com auf Netdata zuzugreifen. Wenn du das erste Mal darauf zugreifst, wirst du aufgefordert, deine HTTP-Authentifizierungsdaten einzugeben.

Du erhältst dann das folgende Dashboard.

Aktiviere das Kontrollkästchen Meine Auswahl speichern und klicke auf die Schaltfläche Später auf dem Agenten-Dashboard bleiben, um das Popup zu schließen.

Du kannst die Überwachung jederzeit anhalten, stoppen und starten, indem du auf die Schaltfläche Play auf dem Dashboard klickst.

Du kannst auf verschiedene Dashboards zugreifen, indem du auf die Optionen in der rechten Seitenleiste klickst. Klicke auf die Schaltfläche UTC und wähle die richtige Zeitzone aus, um sie zu ändern.

Schritt 6 – NetData konfigurieren

Netdata speichert seine Hauptkonfiguration in der Datei /etc/netdata/netdata.conf. Du kannst diese Einstellungen einsehen, indem du die URL https://netdata.example.com/netdata.conf in deinem Browser aufrufst.

Die Datei ist in verschiedene Abschnitte unterteilt, wie [global], [web], [registry] und mehr. Die Standardkonfiguration reicht aus, um loszulegen. Netdata sammelt Daten mithilfe von zwei Arten von Plugins:

1. Interne Plugins sind in C geschrieben und laufen als Threads innerhalb des netdata Daemons.
2. Externe Plugins sind in verschiedenen Sprachen geschrieben, z. B. Python, Go usw., und werden vom netdata Daemon als langlaufende, unabhängige Prozesse gestartet. Sie kommunizieren mit dem Netdata-Daemon über pipes.

Konfigurieren der NetData-Speicherverwendung

Der Speicherverbrauch von NetData richtet sich nach der Zeit, die du die aufgezeichneten Diagrammdaten behalten willst, bevor sie verloren gehen.

• 3600 Sekunden oder 1 Stunde Speicherung von Diagrammdaten verbrauchen 15 MB RAM.
• 7200 Sekunden oder 2 Stunden Speicherung von Kartendaten benötigen 30 MB RAM.
• 14400 Sekunden oder 4 Stunden Kartendatenaufbewahrung verbrauchen 60 MB RAM.

Jedes Mal, wenn du die Aufbewahrungszeit der Kartendaten verdoppelst, verdoppelt sich auch der RAM-Bedarf. Diese RAM-Anforderungen basieren auf der Anzahl der Charts, die das Stock Dashboard verwendet. Wenn du weitere Charts und Anwendungen hinzufügst, ändern sich diese Schätzungen.

Öffne die Konfigurationsdatei von Netdata.

$ sudo nano /etc/netdata/netdata.conf

Gib die Zeile history = 14400 unter dem Abschnitt [global] ein.

[global]
..
        history = 14400
..

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

Telemetrie ausschalten

Standardmäßig sammelt Netdata anonyme Nutzungsdaten mit Hilfe einer Produktanalyseplattform, Posthog. Jedes Mal, wenn der Netdata-Daemon gestartet oder gestoppt wird, verwendet Netdata das anonyme Statistik-Skript, um die folgenden Systeminformationen zu sammeln und an sich selbst zu senden.

• Netdata Version
• OS-Name, Version, id, id_like
• Kernel-Name, -Version, -Architektur
• Virtualisierungstechnologie
• Containerisierungstechnologie
• Zusätzliche Informationen über Netdata Client-Ausfälle.

Glücklicherweise kannst du dies ausschließen. Erstelle eine leere Datei namens .opt-out-from-anonymous-statistics im Netdata-Verzeichnis.

$ sudo touch /etc/netdata/.opt-out-from-anonymous-statistics

Starte Netdata neu, um die Änderung zu aktivieren.

$ sudo systemctl restart netdata

Langfristige Speicherung

Netdata verwendet standardmäßig den Arbeitsspeicher und die Festplatte deines Systems, um historische Daten zu speichern. Der Standardprozess von Netdata sammelt etwa 2000 Metriken pro Sekunde, was bedeutet, dass die Standardkonfiguration die Metriken von etwa zwei Tagen auf dem Arbeitsspeicher und der Festplatte speichert.

Um mehr Metriken zu speichern, hast du die folgenden zwei Möglichkeiten:

1. Konfiguriere Netdata so, dass es mehr Arbeitsspeicher und Festplattenplatz verwendet
2. Archiviere die Metriken in einer externen Datenbank

In diesem Lernprogramm werden wir nur die erste Option besprechen. Für die zweite Option solltest du die offizielle Dokumentation von Netdata konsultieren.

Netdata so konfigurieren, dass es mehr Arbeitsspeicher und Festplattenspeicher verwendet

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

$ sudo nano /etc/netdata/netdata.conf

Füge die folgenden Zeilen unter dem Abschnitt [global] ein.

[global]
...
    memory mode = dbengine
    page cache size = 32
    dbengine disk space = 256

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

Die Größe des Seitencaches bestimmt die Menge des verwendeten Arbeitsspeichers und die dbengine disk space bestimmt die Festplattennutzung. Standardmäßig verwendet Netdata 32 MB RAM und 256 MB Festplattenplatz. Du kannst diese Werte auskommentieren und einen der beiden Werte nach deinen Wünschen ändern.

Mit dem Speicherplatzrechner von Netdata kannst du herausfinden, wie viel RAM und Festplattenplatz du brauchst.

Reduziere die Abholfrequenz

Du kannst die Leistung von Netdata optimieren, indem du die Zeit zwischen den Erhebungen von Metriken erhöhst. In der Standardeinstellung sammelt Netdata jede Sekunde Metriken.

Um das zu ändern, öffne die Netdata-Konfigurationsdatei zum Bearbeiten.

$ sudo nano /etc/netdata/netdata.conf

Gib die folgende Zeile unter dem Abschnitt [global] ein. Damit wird die Häufigkeit auf 5 Sekunden erhöht.

[global]
...
    update every = 5

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

Schritt 7 – Slack-Benachrichtigungen konfigurieren

Der erste Schritt besteht darin, eine Slack-Anwendung zu erstellen und sie mit einem bestimmten Kanal in deinem Arbeitsbereich zu verbinden, um Slack-Benachrichtigungen zu konfigurieren.

Besuche die Slack API Seite und klicke auf die Schaltfläche App erstellen, um eine Anwendung zu erstellen.

Klicke auf den Link Von Grund auf neu, um die App zu erstellen.

Wähle einen Namen für deine App und wähle den Arbeitsbereich, in dem deine App erscheinen soll. Wenn du deine App nicht mit dem bestehenden Arbeitsbereich verknüpfen möchtest, kannst du einen anderen erstellen und zu diesem Schritt zurückkehren.

Öffne die Seite Eingehender Webhook, indem du die Option im Menü Funktionen in der linken Seitenleiste auswählst, und aktiviere dann den Webhook.

Klicke unten auf der Seite auf die Schaltfläche Neuen Webhook zum Arbeitsbereich hinzufügen und wähle deinen Arbeitsbereich und den Zielkanal für Benachrichtigungen aus.

Klicke auf die Schaltfläche Zulassen, um fortzufahren. Kehre zur Seite Eingehende Webhooks zurück und kopiere die Webhook-URL.

Kehr zum Terminal zurück und wechsle in das Verzeichnis /etc/netdata.

$ cd /etc/netdata

Netdata stellt ein edit-config Skript zur Verfügung, um Netdata-Konfigurationsdateien zu bearbeiten und zu erstellen. Führe die folgende Datei aus, um die Datei health_alarm_notify.conf zu erstellen und öffne sie mit dem Standardeditor deines Systems.

$ sudo ./edit-config health_alarm_notify.conf

Scrolle nach unten zum folgenden Abschnitt.

# Enable slack notification
SEND_SLACK="YES"

# Select the slack webhook
SLACK_WEBHOOK_URL="https://hooks.slack.com/services/xxxxxxx"

# Default channel for notification
DEFAULT_RECIPIENT_SLACK="notifications"

Stelle sicher, dass die Variable SEND_SLACK auf yes gesetzt ist. Füge die kopierte Webhook-URL in die Variable SLACK_WEBHOOK_URL ein. Gib den Namen deines Kanals in die Variable DEFAULT_RECIPIENT_SLACK ein.

Wenn dein Editor Vim ist, drücke die Escape-Taste, um die Bearbeitung zu beenden, gib 😡 ein und drücke die Enter-Taste, um die Datei zu speichern und den Editor zu beenden.

Wenn dein Editor Nano ist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starte Netdata neu, um die Änderungen zu übernehmen.

$ sudo systemctl restart netdata

E-Mail-Benachrichtigungen konfigurieren

Netdata verwendet standardmäßig sendmail, um E-Mail-Benachrichtigungen zu versenden, aber die Verwaltung eines E-Mail-Servers ist nicht einfach. Netdata unterstützt kein SMTP, aber du kannst ein Paket namens msmtp client installieren. Damit kannst du E-Mails an einen SMTP-Server senden.

Installiere msmtp.

$ sudo dnf install msmtp

Erstelle und öffne die Konfigurationsdatei für msmtp.

$ sudo nano /etc/msmtprc

Füge den folgenden Code in die Datei ein.

# Set default values for all following accounts.
defaults

# Use the mail submission port 587 instead of the SMTP port 25.
port 587

# Always use TLS.
tls on

# The SMTP server of your ISP
account ses
host email-smtp.<location>.amazonaws.com
from name@example.com
auth on
user <yoursesusername>
password <yoursespassword>

# Set default account to isp
account default: ses

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

Öffne die Datei /etc/netdata/health_alarm_notify.conf zum Bearbeiten.

$ sudo nano /etc/netdata/health_alarm_notify.conf

Scrolle nach unten zum folgenden Abschnitt und gib den Pfad zu msmtp ein.

# external commands

# The full path to the sendmail command.
# If empty, the system $PATH will be searched for it.
# If not found, email notifications will be disabled (silently).
sendmail="/usr/bin/msmtp"

Suche den folgenden Abschnitt und gib die Daten des Absenders und des Empfängers ein und stelle sicher, dass der E-Mail-Versand aktiviert ist.

# email global notification options

# multiple recipients can be given like this:
#              "admin1@example.com admin2@example.com ..."

# the email address sending email notifications
# the default is the system user netdata runs as (usually: netdata)
# The following formats are supported:
# EMAIL_SENDER="user@domain"
# EMAIL_SENDER="User Name <user@domain>"
# EMAIL_SENDER="'User Name' <user@domain>"
# EMAIL_SENDER="\"User Name\" <user@domain>"
EMAIL_SENDER="Server Admin <admin@example.com>"

# enable/disable sending emails
SEND_EMAIL="YES"

# if a role recipient is not configured, an email will be send to:
DEFAULT_RECIPIENT_EMAIL="name@example.com"
# to receive only critical alarms, set it to "root|critical"

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

Schritt 8 – Benachrichtigungskanäle testen

Lass uns testen, ob die Slack-Benachrichtigungen funktionieren.

Melde dich als der Systembenutzer netdata an, der während der Installation erstellt wurde.

$ sudo su -s /bin/bash netdata

Führe das Skript Alarmbenachrichtigung aus, um eine Testbenachrichtigung zu senden.

$ /usr/libexec/netdata/plugins.d/alarm-notify.sh test

Beende den Benutzer.

$ exit.

Öffne deine Slack-Anwendung und du solltest die folgenden Benachrichtigungen erhalten haben.

Außerdem solltest du drei E-Mails über die Testwarnungen erhalten.

Schritt 9 – Systemüberwachung konfigurieren

Nachdem wir nun die Benachrichtigungen konfiguriert und getestet haben, wollen wir nun die Benachrichtigungen für das System konfigurieren und testen, z. B. die CPU-Auslastung.

Führe die folgenden Befehle aus, um die CPU-Konfigurationsdatei zu erstellen und zu öffnen.

$ cd /etc/netdata
$ sudo ./edit-config health.d/cpu.conf

Ändere die Werte für die Optionen warn und crit unter 10min_cpu_usage wie unten gezeigt.

warn: $this > (($status >= $WARNING)  ? (60) : (70))
crit: $this > (($status == $CRITICAL) ? (75) : (85))

Speichere die Datei und beende den Editor.

Mit der obigen Einstellung wird eine Warnung gesendet, wenn die CPU-Auslastung zwischen 60 und 70 % liegt, und eine kritische Warnung, wenn die CPU-Auslastung zwischen 75 und 85 % liegt.

Starte den Netdata-Dienst neu.

$ sudo systemctl restart netdata

Testen wir die Einstellung, indem wir die Anwendung Stress installieren.

$ sudo dnf install stress

Führe den folgenden Befehl aus, um die CPU-Auslastung deines Servers zu messen.

$ stress --cpu 2

Lass den Befehl für 5-10 Minuten laufen und du wirst Meldungen über eine hohe CPU-Auslastung erhalten. Sobald du diese Meldungen erhältst, kehrst du zum Terminal zurück und beendest den Befehl mit der Tastenkombination Strg + Z.

Nachdem du den Dienst gestoppt hast, erhältst du eine Benachrichtigung über die wiederhergestellte CPU-Auslastung auf Slack.

Schritt 10 – Nginx-Überwachung konfigurieren

Eine der am häufigsten überwachten Anwendungen mit Netdata sind die Server- und SQL-Pakete. Lass uns den Nginx-Server mit Netdata überwachen.

Um die Überwachung des Nginx-Servers zu aktivieren, müssen wir das Modul ngx_http_stub_status_module verwenden. Es wird normalerweise mit Nginx vorinstalliert. Du kannst mit grep überprüfen, ob das Modul vorhanden ist.

$ nginx -V 2>&1 | grep -o with-http_stub_status_module
with-http_stub_status_module

Wenn du keine Antwort erhältst, bedeutet das, dass deine Nginx-Installation die Funktion nicht unterstützt. In diesem Fall musst du Nginx kompilieren.

Öffne die Standardkonfigurationsdatei von Nginx /etc/nginx/conf.d/default.conf, um sie zu bearbeiten. Der Speicherort der Datei ist anders, weil wir Nginx aus dem offiziellen Repository installiert haben. Wenn du Nginx aus dem Repository des Betriebssystems installierst, lautet der Speicherort für die Datei /etc/nginx/nginx.conf.

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

Gib den folgenden Code in den Server-Block ein, bevor du die letzte geschweifte Klammer schließt.

# Enable module stub_status
location /stub_status {
	stub_status;
    allow 127.0.0.1;        #only allow requests from localhost
    deny all;               #deny all other hosts
}

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

Überprüfe die Nginx-Konfiguration.

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

$ sudo systemctl restart nginx

Starte den Netdata-Dienst neu.

$ sudo systemctl restart netdata

Du solltest die Nginx-Verbindungsdetails in deinem Netdata Dashboard sehen.

Nginx-Logs überwachen

Netdata kann auch die Nginx-Zugriffsprotokolle überwachen. Dazu wechselst du in das Netdata-Verzeichnis.

$ cd /etc/netdata

Führe den folgenden Befehl aus, um eine Konfigurationsdatei für die Überwachung der Zugriffslogs zu erstellen.

$ sudo ./edit-config python.d/web_log.conf

Scrolle zum Ende der Datei und finde den folgenden Abschnitt.

# -------------------------------------------
# nginx log on various distros

# debian, arch
nginx_log:
  name: 'nginx'
  path: '/var/log/nginx/access.log'

# gentoo
nginx_log2:
  name: 'nginx_site'
  path: '/var/log/nginx/localhost.access_log'

Ändere den Pfad, um die jeweiligen Log-Dateien zu überwachen. Du kannst beliebig viele Abschnitte hinzufügen, um so viele Hosts und deren Access Log-Dateien zu überwachen. Unsere Konfigurationsdatei sieht wie folgt aus.

# -------------------------------------------
# nginx log on various distros

# debian, arch
nginx_log:
  name: 'nginx'
  path: '/var/log/nginx/access.log'

nginx_log2:
  name: 'nginx_site1'
  path: '/var/log/nginx/site1.access_log'

nginx_log3:
  name: 'nginx_site2'
  path: '/var/log/nginx/site2.access_log'

nginx_log4:
  name: 'nginx_site3'
  path: '/var/log/nginx/site3.access_log'

Speichere und beende den Editor.

Um auf die Protokolldateien zugreifen zu können, benötigt Netdata Zugriffsrechte auf das Verzeichnis. Standardmäßig hat die Systemgruppe adm die Berechtigung, auf die Protokolldateien zuzugreifen. Um Netdata Zugriff zu gewähren, müssen wir den Benutzer netdata zur Gruppe adm hinzufügen.

$ sudo usermod -aG adm netdata

Starte Nginx und den Netdata-Dienst neu.

$ sudo systemctl restart nginx netdata

Rufe das Netdata-Dashboard erneut auf, um deine Logdateidaten zu sehen.

Schritt 11 – MySQL/MariaDB-Überwachung konfigurieren

Für unser Tutorial werden wir MariaDB installieren. Die Schritte bleiben die gleichen, wenn du einen MySQL-Server verwendest.

Füge das Repository für MariaDB 10.6 hinzu.

$ sudo nano /etc/yum.repos.d/MariaDB.repo

Füge den folgenden Code darin ein.

# MariaDB 10.6 CentOS repository list - created 2022-04-12 11:12 UTC
# https://mariadb.org/download/
[mariadb]
name = MariaDB
baseurl = https://download.nus.edu.sg/mirror/mariadb/yum/10.6/centos8-amd64
module_hotfixes=1
gpgkey=https://download.nus.edu.sg/mirror/mariadb/yum/RPM-GPG-KEY-MariaDB
gpgcheck=1

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

Installiere MariaDB.

$ sudo dnf install MariaDB-server

Aktiviere den MariaDB-Server.

$ sudo systemctl enable mariadb

Starte das Skript für die sichere Installation von MySQL. Der Dateiname ist im Fall von MariaDB anders.

$ sudo mariadb-secure-installation
....
Enter current password for root (enter for none): (Press Enter)
....
Switch to unix_socket authentication [Y/n] Y (Type Y and Press Enter)
....
Change the root password? [Y/n] Y (Type Y and Press Enter)
New password: 
Re-enter new password: 
Password updated successfully!
....
Remove anonymous users? [Y/n] Y (Type Y and Press Enter)
....
Disallow root login remotely? [Y/n] Y (Type Y and Press Enter)
....
Remove test database and access to it? [Y/n] Y (Type Y and Press Enter)
....
Reload privilege tables now? [Y/n] Y (Type Y and Press Enter)
....
All done!  If you've completed all of the above steps, your MariaDB
installation should now be secure.

Thanks for using MariaDB!

Öffne die Datei /etc/my.cnf.d/server.cnf zum Bearbeiten.

$ sudo nano /etc/my.cnf.d/server.cnf

Suche den Abschnitt [mariadb] in der Datei und füge die folgende Zeile wie unten gezeigt ein, um das Userstats-Plugin zu aktivieren. Diese Einstellung funktioniert nur für MariaDB und nicht für den MySQL-Server.

[mariadb]
userstat = 1

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

Starten Sie den MariaDB-Server.

$ sudo systemctl start mariadb

Starte den Netdata-Dienst neu.

$ sudo systemctl restart netdata

Das MariaDB/MySQL-Dashboard sollte nun im Netdata-Dashboard angezeigt werden.

Schritt 12 – PHP-FPM-Überwachung konfigurieren

Du kannst eine oder mehrere PHP-FPM-Instanzen mit Netdata überwachen. Für unser Tutorial werden wir PHP 8.0 installieren und dann die Überwachung aktivieren.

Wir installieren PHP über das Remi-Repository. Das EPEL-Repository haben wir bereits in Schritt 3 installiert. Installiere das Remi-Repository.

$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-8.rpm

Prüfe, ob PHP-Streams verfügbar sind.

$ dnf module list php -y
Last metadata expiration check: 0:00:12 ago on Fri 03 Dec 2021 09:39:32 AM UTC.
Rocky Linux 8 - AppStream
Name                Stream                 Profiles                                 Summary
php                 7.2 [d]                common [d], devel, minimal               PHP scripting language
php                 7.3                    common [d], devel, minimal               PHP scripting language
php                 7.4                    common [d], devel, minimal               PHP scripting language

Remi's Modular repository for Enterprise Linux 8 - x86_64
Name                Stream                 Profiles                                 Summary
php                 remi-7.2               common [d], devel, minimal               PHP scripting language
php                 remi-7.3               common [d], devel, minimal               PHP scripting language
php                 remi-7.4               common [d], devel, minimal               PHP scripting language
php                 remi-8.0               common [d], devel, minimal               PHP scripting language
php                 remi-8.1               common [d], devel, minimal               PHP scripting language

Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled

Die Standardversion ist 7.2. Aktiviere das PHP 8.0 Repository von Remi.

$ sudo dnf module reset php -y
$ sudo dnf module enable php:remi-8.0

Als Nächstes installierst du PHP und die Erweiterungen, die für Firefly III benötigt werden. Das Paket php enthält mehrere Abhängigkeiten, die Firefly III benötigt, also stelle sicher, dass du sie mitinstallierst.

$ sudo dnf install php php-fpm php-mbstring php-xml php-curl php-mysqlnd php-zip php-intl php-bcmath php-gd php-ldap php-cli

Überprüfe die Installation.

$ php --version
PHP 8.0.16 (cli) (built: Feb 15 2022 21:34:32) ( NTS gcc x86_64 )
Copyright (c) The PHP Group
Zend Engine v4.0.16, Copyright (c) Zend Technologies
    with Zend OPcache v8.0.16, Copyright (c), by Zend Technologies

PHP konfigurieren

Öffne die Datei /etc/php-fpm.d/www.conf.

$ sudo nano /etc/php-fpm.d/www.conf

Wir müssen den Unix-Benutzer/die Unix-Gruppe der PHP-Prozesse auf nginx setzen. Finde die Zeilen user=www-data und group=www-data in der Datei und ändere sie in nginx.

...
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;       will be used.
; RPM: apache user chosen to provide access to the same directories as httpd
user = nginx
; RPM: Keep a group allowed to write in log dir.
group = nginx
...

Scrolle in der Datei nach unten, um die Option ;pm.status_path = /status zu finden. Hebe die Kommentare in der Zeile auf, indem du das Semikolon vor der Zeile entfernst, wie unten gezeigt.

; Note: There is a real-time FPM status monitoring sample web page available
;       It's available in: @EXPANDED_DATADIR@/fpm/status.html
;
; Note: The value must start with a leading slash (/). The value can be
;       anything, but it may not be a good idea to use the .php extension or it
;       may conflict with a real PHP file.
; Default Value: not set
pm.status_path = /status

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

Aktiviere und starte den PHP-Dienst.

$ sudo systemctl enable php-fpm --now

PHP-Einstellungen zu Nginx hinzufügen

Öffne die Standardkonfigurationsdatei von Nginx /etc/nginx/conf.d/default.conf zum Bearbeiten.

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

Gib den folgenden Code innerhalb des Server-Blocks vor der letzten schließenden geschweiften Klammer ein.

# define PHP-FPM monitoring
location ~ ^/(status|ping)$ {
    allow 127.0.0.1;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    fastcgi_index index.php;
    include fastcgi_params;
    fastcgi_pass   unix:/run/php-fpm/.sock; # Depends on the PHP Version and OS Distro
}

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

Überprüfe die Nginx-Konfiguration.

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

$ sudo systemctl restart nginx

Starte den Netdata-Dienst neu.

$ sudo systemctl restart netdata

Rufe das Netdata-Dashboard erneut auf und du solltest die PHP-FPM-Statistiken sehen.

Schritt 13 – Docker-Engine und Container-Überwachung konfigurieren

Netdata kann sowohl die Docker-Engine als auch Docker-Container überwachen. Es kann auch Anwendungen überwachen, die in diesen Containern laufen, aber darauf gehen wir in diesem Lernprogramm nicht ein.

Installieren wir zunächst Docker.

$ sudo dnf install yum-utils
$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
$ sudo dnf install docker-ce docker-ce-cli containerd.io

Aktiviere und starte den Docker-Dienst.

$ sudo systemctl enable docker --now

Um die Docker-Engine zu überwachen, musst du die Metrik-Funktion von Docker aktivieren.

Erstelle und öffne die Datei /etc/docker/daemon.json zum Bearbeiten.

$ sudo nano /etc/docker/daemon.json

Füge den folgenden Code in die Datei ein.

{
  "metrics-addr" : "127.0.0.1:9323",
  "experimental" : true
}

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

Starte die Netdata- und Docker-Dienste neu.

$ sudo systemctl restart docker netdata

Lade das Netdata Dashboard erneut und du kannst die Docker-Statistiken sehen.

Du wirst einen weiteren Eintrag mit dem Namen Prometheus Metrics auf deinem Dashboard sehen, da die Metrik-Option für das Prometheus-Dashboard erstellt wurde.

Der nächste Schritt ist die Überwachung des Docker-Containers. Netdata verwendet Kontrollgruppen, die cgroups genannt werden, um Docker-Container zu überwachen. Kontrollgruppen sind eine Linux-Funktion, die die Ressourcennutzung einer Sammlung von Prozessen, in diesem Fall von Containern, begrenzt und verfolgt. Wenn du bei der Installation von Netdata Docker-Container laufen lässt, werden sie automatisch überwacht. Wenn du jedoch einen Container nach der Installation von Netdata laufen lässt, musst du ihn neu starten.

Starte einen Testcontainer.

$ docker container run -d nginx

Überprüfe den Status des Containers.

$ docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS     NAMES
938b2cf30927   nginx     "/docker-entrypoint.…"   3 seconds ago   Up 2 seconds   80/tcp    pensive_lovelace

Der Name des Containers ist tender_murdock, wie abgebildet. Da der Container nach der Installation von Netdata gestartet wurde, starte den Dienst neu.

$ sudo systemctl restart netdata

Lade das Dashboard und du solltest die Container-Statistiken sehen können.

Fazit

Damit ist unsere Anleitung zur Installation und Verwendung des Netdata Monitoring Systems zur Überwachung verschiedener Anwendungen wie Nginx, MySQL, PHP-FPM und Docker auf einem Rocky Linux Server abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.