Installation und Überwachung von Diensten mit dem Netdata Monitoring Tool unter Debian 12

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.

Dieses Tutorial zeigt dir, wie du verschiedene Dienste mit Netdata auf einem Debian 12 Server installierst und überwachst. Außerdem wirst du damit die Metriken eines LEMP-Stacks und einer Docker-Engine überwachen.

Voraussetzungen

• Ein Server mit Debian 12.
• Ein Nicht-Root-Benutzer mit sudo-Rechten.
• Ein Fully Qualified Domain Name (FQDN) wie netdata.example.com, der auf deinen Server zeigt.
• Ein SMTP-Konto bei einem E-Mail-Dienst wie Amazon SES oder Mailgun.
• Stelle sicher, dass alles auf dem neuesten Stand ist.

  $ sudo apt update
  $ sudo apt upgrade
  

• Ein paar Pakete, die dein System braucht.

  $ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring unzip -y
  

  Einige dieser Pakete sind vielleicht schon auf deinem System installiert.

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Debian wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.

Überprüfe, ob die Firewall aktiv ist.

$ sudo ufw status

Du wirst die folgende Ausgabe erhalten.

Status: inactive

Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.

$ sudo ufw allow OpenSSH

Lasse auch HTTP- und HTTPS-Ports zu.

$ sudo ufw allow http
$ sudo ufw allow https

Aktiviere die Firewall

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Überprüfe den Status der Firewall erneut.

$ sudo ufw status

Du solltest eine ähnliche Ausgabe sehen.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Schritt 2 – NetData installieren

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

$ wget -O /tmp/netdata-kickstart.sh https://my-netdata.io/kickstart.sh

Führe das Installationsskript mit dem folgenden Befehl aus.

$ sudo sh /tmp/netdata-kickstart.sh --stable-channel --disable-telemetry

Mit dem Flag --stable-channel installierst du die stabile Version von Netdata. Das Flag --disable-telemetry verhindert, dass Netdata anonyme Statistiken an den Server zurückschickt. Es gibt noch weitere Flags, mit denen du dein Installationsprogramm anpassen kannst.

Gib Y ein, um das Hinzufügen des Netdata-Repositorys und die Installation auf deinem Server zu bestätigen. Bei erfolgreicher Installation solltest du die folgende Ausgabe erhalten.

Successfully installed the Netdata Agent.

Official documentation can be found online at https://learn.netdata.cloud/docs/.

Looking to monitor all of your infrastructure with Netdata? Check out Netdata Cloud at https://app.netdata.cloud.

Join our community and connect with us on:
  - GitHub: https://github.com/netdata/netdata/discussions
  - Discord: https://discord.gg/5ygS846fR6
  - Our community forums: https://community.netdata.cloud/
[/root]# rm -rf /tmp/netdata-kickstart-wH4pebXveT
 OK

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

$ sudo systemctl status netdata
? netdata.service - Real time performance monitoring
     Loaded: loaded (/lib/systemd/system/netdata.service; enabled; preset: enabled)
     Active: active (running) since Thu 2023-08-24 10:26:56 UTC; 42s ago
   Main PID: 2811 (netdata)
      Tasks: 82 (limit: 1107)
     Memory: 108.2M
        CPU: 4.271s
     CGroup: /system.slice/netdata.service
             ??2811 /usr/sbin/netdata -D -P /var/run/netdata/netdata.pid
             ??2822 /usr/sbin/netdata --special-spawn-server
             ??3127 bash /usr/libexec/netdata/plugins.d/tc-qos-helper.sh 1
             ??3137 /usr/libexec/netdata/plugins.d/go.d.plugin 1
             ??3142 /usr/libexec/netdata/plugins.d/ebpf.plugin 1
             ??3145 /usr/libexec/netdata/plugins.d/nfacct.plugin 1
             ??3149 /usr/libexec/netdata/plugins.d/systemd-journal.plugin 1
             ??3155 /usr/libexec/netdata/plugins.d/debugfs.plugin 1
             ??3159 /usr/libexec/netdata/plugins.d/apps.plugin 1

Aug 24 10:26:58 netdata ebpf.plugin[3142]: set name of thread 3188 to EBPF SOFTIRQ
.......

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 | grep netdata

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      4096         0.0.0.0:19999      0.0.0.0:*            users:(("netdata",pid=2811,fd=8))
LISTEN 0      4096       127.0.0.1:8125       0.0.0.0:*            users:(("netdata",pid=2811,fd=47))
LISTEN 0      4096           [::1]:8125          [::]:*            users:(("netdata",pid=2811,fd=46))
LISTEN 0      4096            [::]:19999         [::]:*            users:(("netdata",pid=2811,fd=9))

Schritt 3 – 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 stabile Version von Nginx hinzu.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
    | sudo tee /etc/apt/sources.list.d/nginx.list

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx und die Apache-Hilfsprogramme. Das Paket Apache Utilities wird für das Dienstprogramm htpasswd benötigt.

$ sudo apt install nginx apache2-utils

Überprüfe die Installation. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.

$ sudo nginx -v
nginx version: nginx/1.24.0

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 Thu 2023-08-24 11:36:34 UTC; 4s ago
       Docs: https://nginx.org/en/docs/
    Process: 3657 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 3658 (nginx)
      Tasks: 2 (limit: 1107)
     Memory: 1.8M
        CPU: 12ms
     CGroup: /system.slice/nginx.service
             ??3658 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??3659 "nginx: worker process"

Schritt 4 – 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 ordnungsgemäß funktioniert.

$ certbot --version
certbot 2.6.0

Erstelle das SSL-Zertifikat.

$ sudo certbot certonly --nginx --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 -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Überprüfe den Certbot-Erneuerungszeitplanungsdienst.

$ sudo systemctl list-timers

Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.

NEXT                        LEFT          LAST                        PASSED      UNIT                         ACTIVATES
.....
Thu 2023-08-24 13:40:00 UTC 1h 59min left -                           -           snap.certbot.renew.timer     snap.certbot.renew.service
Thu 2023-08-24 18:47:23 UTC 7h left       Thu 2023-08-24 09:30:41 UTC 2h 9min ago apt-daily.timer              apt-daily.service
Fri 2023-08-25 00:00:00 UTC 12h left      -                           -           dpkg-db-backup.timer         dpkg-db-backup.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 5 – Nginx konfigurieren

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 6 – 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 das folgende Dashboard.

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

Du kannst auf verschiedene Dashboards zugreifen, indem du auf die Optionen in der rechten Seitenleiste klickst.

Netdata kann standardmäßig deine Zeitzone korrekt verfolgen. Wenn das nicht der Fall ist, klickst du auf den Timer und wählst im Popup die richtige Zeitzone aus, um sie zu ändern.

Schritt 7 – 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], [db], [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]
    run as user = netdata

    # default storage size - increase for longer data retention
    page cache size = 32
    dbengine multihost disk space = 256
    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.

Wir haben die Telemetrie während der Installation ausgeschaltet, aber wenn du das nicht getan hast, kannst du es jetzt nachholen. 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

Konfiguriere die folgenden Zeilen unter dem Abschnitt [global].

[global]
...
    page cache size = 32
    dbengine multihost 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 Variable dbengine multihost disk space bestimmt die Festplattennutzung. Standardmäßig verwendet Netdata 32 MB RAM und 256 MB Festplattenplatz. Du kannst jeden der beiden Werte nach deinen Wünschen ändern.

Mit dem Netdata Storage Metric Calculator 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 der Metriken erhöhst. In der Standardeinstellung sammelt Netdata jede Sekunde Metriken.

Um dies zu ändern, öffne die Netdata-Konfigurationsdatei zur Bearbeitung.

$ 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 8 – 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/xxxxxx/xxxxxxxxxxxxx"

# 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

Schritt 9 – 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 apt 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.

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 /etc/netdata/edit-config 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 Details 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.

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

$ sudo systemctl restart netdata

Schritt 10 – Benachrichtigungskanäle testen

Lass uns testen, ob die E-Mail-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 für die Alarmbenachrichtigung aus, um eine Testbenachrichtigung zu versenden.

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

Du wirst die folgende Ausgabe erhalten.

# SENDING TEST WARNING ALARM TO ROLE: sysadmin
2023-08-24 12:56:00: alarm-notify.sh: INFO: sent email notification for: netdata test.chart.test_alarm is WARNING to 'notify@example.com'
# OK

# SENDING TEST CRITICAL ALARM TO ROLE: sysadmin
2023-08-24 12:56:03: alarm-notify.sh: INFO: sent email notification for: netdata test.chart.test_alarm is CRITICAL to 'notify@example.com'
# OK

# SENDING TEST CLEAR ALARM TO ROLE: sysadmin
2023-08-24 12:56:06: alarm-notify.sh: INFO: sent email notification for: netdata test.chart.test_alarm is CLEAR to 'notify@example.com'
# OK

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 11 – 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.

$ sudo /etc/netdata/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 apt 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 CPU-Wiederherstellungsmeldung auf Slack.

Schritt 12 – 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 überprüfen, ob das Modul vorhanden ist. Auf dem Debian-System wird das sudo für den Befehl benötigt.

$ sudo 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 go.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 die Berechtigung, auf das Verzeichnis zuzugreifen. 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 13 – MySQL/MariaDB-Überwachung konfigurieren

Für unser Tutorial werden wir MariaDB installieren. Hierfür verwenden wir das MariaDB Repository.

Importiere den MariaDB GPG-Schlüssel.

$ sudo curl -o /usr/share/keyrings/mariadb-keyring.pgp 'https://mariadb.org/mariadb_release_signing_key.pgp'

Erstelle und öffne die Datei des MariaDB-Repositorys.

$ sudo nano /etc/apt/sources.list.d/mariadb.sources

Füge den folgenden Code in die Datei ein.

# MariaDB 10.11 repository list - created 2023-09-05 11:18 UTC
# https://mariadb.org/download/
X-Repolib-Name: MariaDB
Types: deb
# deb.mariadb.org is a dynamic mirror if your preferred mirror goes offline. See https://mariadb.org/mirrorbits/ for details.
# URIs: https://deb.mariadb.org/10.11/debian
URIs: https://mirrors.aliyun.com/mariadb/repo/10.11/debian
Suites: bookworm
Components: main
Signed-By: /usr/share/keyrings/mariadb-keyring.pgp

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

Aktualisiere die Liste der System-Repositories.

$ sudo apt update

Installiere den MariaDB-Server.

$ sudo apt install mariadb-server

MariaDB ist aktiviert und läuft. Überprüfe den Status des Dienstes.

$ sudo systemctl status mariadb
? mariadb.service - MariaDB 10.11.5 database server
     Loaded: loaded (/lib/systemd/system/mariadb.service; enabled; preset: enabled)
    Drop-In: /etc/systemd/system/mariadb.service.d
             ??migrated-from-my.cnf-settings.conf
     Active: active (running) since Tue 2023-09-05 11:44:17 UTC; 20s ago
       Docs: man:mariadbd(8)
             https://mariadb.com/kb/en/library/systemd/
    Process: 9396 ExecStartPre=/usr/bin/install -m 755 -o mysql -g root -d /var/run/mysqld (code=exited, status=0/SUCCESS)
    Process: 9397 ExecStartPre=/bin/sh -c systemctl unset-environment _WSREP_START_POSITION (code=exited, status=0/SUCCESS)
    Process: 9399 ExecStartPre=/bin/sh -c [ ! -e /usr/bin/galera_recovery ] && VAR= ||   VAR=`cd /usr/bin/..; /usr/bin/galera_recovery`; [ $? -eq 0 ]   && systemctl set-environment _WSREP_START_POSITION=$VAR >
    Process: 9440 ExecStartPost=/bin/sh -c systemctl unset-environment _WSREP_START_POSITION (code=exited, status=0/SUCCESS)
    Process: 9442 ExecStartPost=/etc/mysql/debian-start (code=exited, status=0/SUCCESS)
   Main PID: 9428 (mariadbd)
     Status: "Taking your SQL requests now..."
      Tasks: 13 (limit: 1107)
     Memory: 111.8M
        CPU: 663ms
     CGroup: /system.slice/mariadb.service
             ??9428 /usr/sbin/mariadbd

Starte das Skript für die sichere Installation von MySQL. Der Dateiname ist im Falle 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/mysql/mariadb.conf.d/50-server.cnf zum Bearbeiten.

$ sudo nano /etc/mysql/mariadb.conf.d/50-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 auf MariaDB und nicht auf dem MySQL-Server.

[mariadb]
userstat = 1

Melde dich in der MySQL-Shell an.

$ sudo mysql

Führe die folgenden Befehle aus, um einen Netdata-SQL-Benutzer zu erstellen und ihm die Berechtigung zu geben, MySQL-Statistiken zu verfolgen.

MariaDB> create user 'netdata'@'localhost';
MariaDB> GRANT USAGE, REPLICATION CLIENT, PROCESS ON *.* TO 'netdata'@'localhost';
MariaDB> FLUSH PRIVILEGES;
MariaDB> exit

Erstelle die MySQL-Konfigurationsdatei für Netdata.

$ sudo /etc/netdata/edit-config go.d/mysql.conf

Es wird eine Datei geöffnet, die alle möglichen Optionen anzeigt. Wenn du zufrieden bist, speichere und schließe die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starte den MariaDB-Server neu.

$ sudo systemctl restart mariadb

Starte den Netdata-Dienst neu.

$ sudo systemctl restart netdata

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

Schritt 14 – PHP-FPM-Überwachung konfigurieren

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

Debian 12 wird standardmäßig mit PHP 8.2 ausgeliefert. Um aber immer auf der neuesten PHP-Version zu bleiben, werden wir Ondrejs PHP-Repository verwenden.

Importiere zunächst den PHP-GPG-Schlüssel aus Surys Repository.

$ sudo curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg https://packages.sury.org/php/apt.gpg

Füge das PHP-Repository von Ondrej Sury hinzu.

$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/deb.sury.org-php.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/php.list'

Aktualisiere die Liste der System-Repositorys.

$ sudo apt update	

Jetzt kannst du eine beliebige PHP-Version installieren.

$ sudo apt install php8.2-fpm php8.2-cli php8.2-mbstring

Überprüfe die Installation.

$ php --version
PHP 8.2.10 (cli) (built: Sep  4 2023 08:12:29) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.2.10, Copyright (c) Zend Technologies
    with Zend OPcache v8.2.10, Copyright (c), by Zend Technologies

PHP konfigurieren

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

$ sudo nano /etc/php/8.2/fpm/pool.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 the child processes. This can be used only if the master
; process running user is root. It is set after the child process is created.
; The user and group can be specified either by their name or by their numeric
; IDs.
; Note: If the user is root, the executable needs to be started with
;       --allow-to-run-as-root option to work.
; Default Values: The user is set to master process running user by default.
;                 If the group is not set, the user's group is used.
user = nginx
group = nginx
....

Finde auch die Zeilen listen.owner=www-data und listen.group=www-data in der Datei und ändere sie in nginx.

listen.owner = nginx
listen.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: /usr/share/php/8.2/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.

Starte den PHP-fpm-Prozess neu.

$ sudo systemctl restart php8.2-fpm

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 in den Server-Block 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/php8.2-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 15 – 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.

$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
$ echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
$ sudo apt update
$ sudo apt install docker-ce docker-ce-cli containerd.io
$ sudo usermod -aG docker ${USER}
$ su - ${USER}

Der Docker-Dienst ist aktiviert und gestartet. Du kannst den Status des Dienstes überprüfen.

$ sudo systemctl status docker

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. Diese URL wird von Prometheus verwendet, um die Statistiken der Docker-Engine zu verfolgen.

Erstelle eine Konfigurationsdatei für den Docker-Kollektor.

$ sudo /etc/netdata/edit-config go.d/docker.conf

Erstelle eine weitere Konfigurationsdatei für die Docker-Engine für Prometheus.

$ sudo /etc/netdata/edit-config go.d/docker_engine.conf

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, weil 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
9d6cde479224   nginx     "/docker-entrypoint.…"   7 seconds ago   Up 5 seconds   80/tcp    zealous_knuth

Der Name des Containers ist zealous_knuth, 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. In den Statistiken kannst du die Container-ID sehen.

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 Debian 12-Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.