From 57b3395f854cea24bc7675ecca92c836241bfd07 Mon Sep 17 00:00:00 2001 From: Thomas Dannenberg Date: Sat, 18 Oct 2025 12:54:26 +0000 Subject: [PATCH] =?UTF-8?q?Kapitel=2015/Free=20Rohtext.md=20hinzugef=C3=BC?= =?UTF-8?q?gt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Kapitel 15/Free Rohtext.md | 690 +++++++++++++++++++++++++++++++++++++ 1 file changed, 690 insertions(+) create mode 100644 Kapitel 15/Free Rohtext.md diff --git a/Kapitel 15/Free Rohtext.md b/Kapitel 15/Free Rohtext.md new file mode 100644 index 0000000..a38b7bd --- /dev/null +++ b/Kapitel 15/Free Rohtext.md @@ -0,0 +1,690 @@ +# Kapitel 15 – Netdata (Systemmonitoring & Performanceanalyse) + +## Einleitung + +Ein **zuverlässiges Monitoring** ist das Rückgrat jedes Homelabs – besonders dann, wenn du viele LXC-Container, Dienste und Automatisierungen betreibst. +Mit **Netdata** erhältst du eine moderne, ressourcenschonende Lösung zur **Echtzeit-Überwachung** deiner Systeme. +Sie zeigt CPU-Last, RAM-Verbrauch, Netzwerkaktivität, Festplatten-I/O, Containerstatus und vieles mehr – übersichtlich im Browser und ohne komplizierte Konfiguration. + +👉 **Screenshot geeignet:** Übersicht „Bratonien Kontrollzentrum“ mit hervorgehobener Netdata-Position oberhalb der Container-Cluster + +Ziel dieses Kapitels ist der Aufbau einer **zentralen Netdata-Instanz** in einem dedizierten **Debian-12-LXC**, die alle anderen Container im UCC überwacht. +Du lernst, wie du Netdata installierst, absicherst und über den **Nginx Proxy Manager** per **HTTPS** bereitstellst. + +Damit erkennst du Systemlast, Engpässe oder fehlerhafte Prozesse frühzeitig und kannst deine Infrastruktur effizient warten und optimieren. +Wenn du weitergehende **Automatisierungen, Warnmeldungen oder Integration mit n8n** nutzen willst, empfehlen wir dir die **kostenpflichtige Erweiterung zu diesem Kapitel** oder unseren **Premiumkurs**. + +> [!NOTE] +> Netdata ist kein einfacher „Task-Manager“, sondern ein vollwertiges Observability-Tool mit über 200 Metriken, visueller Darstellung und optionaler Cloud-Anbindung. +> In diesem Abschnitt konzentrieren wir uns ausschließlich auf die lokale Überwachung im Homelab. + +👉 **Screenshot geeignet:** Browseransicht mit Netdata-Dashboard (CPU-, RAM- und Netzwerkdiagramme) + +Netdata läuft dauerhaft im Hintergrund und liefert **Sekunden-genaue Telemetriedaten** zu jedem Container und Dienst. +Dadurch behältst du jederzeit die Kontrolle über den Zustand deines Systems – ohne zusätzliche Software oder externe Accounts. + +--- + +## Voraussetzungen & Ressourcen + +Bevor du mit der Einrichtung beginnst, prüfe die technischen und systemseitigen Voraussetzungen. +Netdata arbeitet sehr effizient, benötigt aber eine stabile Basis, um dauerhaft präzise Daten zu liefern. + +### Container-Ressourcen + +* **CPU:** 1 vCPU + Reicht für die kontinuierliche Überwachung mehrerer Container vollkommen aus. + +* **RAM:** 1 GB + Diese Größe deckt sowohl den Netdata-Agent als auch die Weboberfläche sicher ab. + Mehr Arbeitsspeicher bringt keinen spürbaren Vorteil, solange keine zusätzlichen Module aktiviert sind. + +* **Speicherplatz:** 8 GB + Ausreichend für System, temporäre Daten, Logs und Caching. + Netdata schreibt keine großen Datenmengen dauerhaft auf die Festplatte. + +* **Betriebssystem:** Debian 12 (Bookworm) + Debian ist für diesen Einsatzzweck optimal, da es leichtgewichtig, stabil und sehr gut dokumentiert ist. + +* **Netzwerk:** Statische IP-Adresse oder DHCP-Reservierung + Die Netdata-Instanz muss dauerhaft unter derselben IP erreichbar bleiben, + da die Einbindung in den Nginx Proxy Manager und das Dashboard darauf basieren. + +> [!TIP] +> Weise die IP-Adresse direkt beim Erstellen des Containers in Proxmox zu. +> Eine spätere Änderung verursacht meist fehlerhafte DNS-Einträge oder SSL-Probleme. + +👉 **Screenshot geeignet:** Ressourcenübersicht beim Erstellen des Netdata-LXC (vCPU 1 | RAM 1 GB | Storage 8 GB) + +### Technische Voraussetzungen + +* **Proxmox VE** ist installiert und aktiv. + Der Container wird direkt über die Proxmox-Oberfläche erstellt und verwaltet. + +* **Nginx Proxy Manager (NPM)** ist funktionsfähig. + Er stellt später das Dashboard per **HTTPS** unter einer eigenen Subdomain bereit. + +* **DNS- oder DynDNS-Eintrag** für `netdata.deinedomain.tld` ist vorhanden. + Ohne diesen Eintrag kann kein SSL-Zertifikat ausgestellt werden. + +* **Internetverbindung** im Container ist aktiv. + Netdata wird über das offizielle Repository aus dem Internet installiert. + +* **SSH-Zugriff** auf den Container ist möglich, zum Beispiel: + ```bash + # Beispiel: + ssh root@ + ``` + Ersetze `` durch die tatsächliche Adresse deines Netdata-LXC. + +> [!IMPORTANT] +> Der Netdata-Container sollte auf einem Host mit stabiler Netzwerkanbindung liegen +> und nicht auf demselben Storage wie hoch belastete Produktionscontainer. + +👉 **Screenshot geeignet:** Proxmox-Interface mit markiertem Netdata-LXC in der Containerliste + +--- + +## Schritt-für-Schritt-Anleitung + +### Schritt 1 – System aktualisieren + +Starte den frisch erstellten Netdata-Container und öffne die Konsole – entweder direkt in Proxmox oder per SSH. +Führe zunächst ein vollständiges System-Update durch, um alle Pakete auf den neuesten Stand zu bringen: + +```bash +apt update && apt upgrade -y +``` + +Sobald das Update abgeschlossen ist, führe einen Neustart durch: + +```bash +reboot +``` + +Nach dem Neustart wieder anmelden (z. B. mit `ssh root@`). + +> [!NOTE] +> Ein frisch angelegter LXC enthält meist veraltete Paketquellen. +> Ein vollständiges Update verhindert spätere Fehler bei Repository-Einbindungen oder Abhängigkeitskonflikte. + +👉 **Screenshot geeignet:** Proxmox-Konsole mit erfolgreichem Abschluss von `apt upgrade` (keine ausstehenden Pakete) + +### Schritt 2 – Grundpakete installieren + +Damit Netdata über HTTPS-Repositories installiert werden kann, müssen zunächst die grundlegenden Systempakete für Zertifikate, HTTPS-Kommunikation und GPG-Schlüsselverwaltung vorhanden sein. +Diese werden mit folgendem Befehl installiert: + +```bash +apt install -y ca-certificates curl gnupg lsb-release +``` + +> [!TIP] +> Diese Pakete sind auf den meisten Systemen bereits vorinstalliert. +> Wenn einer der Befehle einen Fehler ausgibt, überprüfe die Internetverbindung des Containers und führe den Installationsbefehl erneut aus. + +👉 **Screenshot geeignet:** Terminalausgabe nach erfolgreicher Installation der Grundpakete (`curl`, `gnupg`, `lsb-release`) + +### Schritt 3 – Netdata-Repository einbinden und installieren + +Netdata wird direkt über das offizielle Repository bereitgestellt. +Dadurch erhältst du stabile Versionen mit regelmäßigen Sicherheits- und Funktionsupdates. + +Füge das Repository über den offiziellen Installationsbefehl hinzu und installiere Netdata anschließend: + +```bash +bash <(curl -Ss https://my-netdata.io/kickstart.sh) --stable-channel --disable-telemetry +``` + +> [!NOTE] +> Der Parameter `--disable-telemetry` sorgt dafür, dass keine anonymen Diagnosedaten an Netdata gesendet werden. +> Die Installation kann je nach Systemleistung etwa 1–3 Minuten dauern. + +Nach Abschluss überprüfe, ob der Dienst aktiv ist: + +```bash +systemctl status netdata +``` + +Die Ausgabe sollte **active (running)** anzeigen. + +> [!TIP] +> Mit `q` verlässt du die Statusansicht wieder. +> Wenn der Dienst nicht läuft, starte ihn manuell: +> ```bash +> systemctl restart netdata +> ``` + +👉 **Screenshot geeignet:** Terminal mit `systemctl status netdata` und sichtbarem Status „active (running)“ + +### Schritt 4 – Firewall & Portfreigabe prüfen + +Nach der Installation lauscht Netdata standardmäßig auf **Port 19999**. +Damit das Webinterface erreichbar ist, muss dieser Port innerhalb des Containers geöffnet sein. + +Überprüfe zunächst, ob Netdata korrekt lauscht: + +```bash +ss -tulpen | grep netdata +``` + +Die Ausgabe sollte eine Zeile mit **0.0.0.0:19999** oder **[::]:19999** enthalten. +Das bedeutet, dass Netdata auf allen Interfaces erreichbar ist. + +> [!NOTE] +> Innerhalb des Containers ist keine zusätzliche Firewall-Konfiguration nötig. +> Die Kommunikation erfolgt intern im Homelab und wird später über den Nginx Proxy Manager abgesichert. + +Wenn du UFW oder eine andere Firewall im Container aktiv nutzt, erlaube den Zugriff: + +```bash +ufw allow 19999/tcp +ufw reload +``` + +Prüfe anschließend die Erreichbarkeit über den Browser: + +``` +http://:19999 +``` + +Du solltest das Netdata-Dashboard sehen. +Wenn die Seite nicht lädt, kontrolliere, ob der Dienst aktiv ist und keine Netzwerkisolation vorliegt. + +👉 **Screenshot geeignet:** Browserfenster mit Netdata-Dashboard unter `http://:19999` + +### Schritt 5 – Netdata-Zugang absichern und Proxy-Einbindung vorbereiten + +Nach der Installation ist Netdata sofort über Port **19999** im gesamten Netzwerk erreichbar. +Damit der Zugriff später über den **Nginx Proxy Manager (NPM)** funktioniert, muss Netdata im internen Netz erreichbar bleiben – aber nicht von außen. +Dazu wird die Konfiguration angepasst, sodass der Dienst auf **allen internen Interfaces** lauscht, während die Absicherung vollständig über NPM erfolgt. + +Öffne die Konfigurationsdatei: + +```bash +nano /etc/netdata/netdata.conf +``` + +Suche die Zeile: +``` +# bind to = * +``` +und ändere sie zu: +``` +bind to = 0.0.0.0 +``` + +Speichern (STRG + O, Enter) und schließen (STRG + X). + +> [!NOTE] +> Mit `bind to = 0.0.0.0` akzeptiert Netdata Verbindungen von allen internen IPs. +> Der Dienst bleibt damit für deinen Proxy-Manager erreichbar, ohne dass du zusätzliche Portweiterleitungen benötigst. + +Starte den Dienst neu, damit die Änderung aktiv wird: + +```bash +systemctl restart netdata +``` + +Prüfe anschließend, ob der Dienst korrekt auf allen Interfaces lauscht: + +```bash +ss -tulpen | grep 19999 +``` + +Die Ausgabe sollte **0.0.0.0:19999** enthalten. + +👉 **Screenshot geeignet:** Terminal mit geöffneter `netdata.conf` und hervorgehobener Zeile `bind to = 0.0.0.0` + +> [!TIP] +> Wenn du zusätzlich eine interne Firewall verwendest (z. B. UFW oder Proxmox-Regeln), +> kannst du den Zugriff auf Netdata gezielt auf die IP deines NPM-Containers beschränken. +> Beispiel: +> ```bash +> ufw allow from to any port 19999 proto tcp +> ufw reload +> ``` + +Damit ist der Container vorbereitet. +Im nächsten Schritt wird Netdata über den **Nginx Proxy Manager** sicher unter einer Subdomain wie +`https://monitor.deinedomain.tld` eingebunden. + +### Schritt 6 – Integration in Nginx Proxy Manager (NPM) + +Nachdem Netdata nun im internen Netzwerk auf **0.0.0.0:19999** lauscht, kann der Dienst sicher über den +**Nginx Proxy Manager (NPM)** veröffentlicht werden. +Dadurch erhältst du eine verschlüsselte Verbindung über **HTTPS** mit einem gültigen SSL-Zertifikat. + +> [!IMPORTANT] +> Stelle sicher, dass Netdata erreichbar ist, bevor du den Proxy anlegst: +> ``` +> http://:19999 +> ``` +> Wenn das Dashboard angezeigt wird, funktioniert der Dienst korrekt. + +#### Proxy-Host anlegen + +1. Öffne das Dashboard des **Nginx Proxy Manager**. +2. Klicke auf **Add Proxy Host**. +3. Trage folgende Werte ein: + +| Feld | Wert | +|------|------| +| **Domain Names** | `monitor.deinedomain.tld` | +| **Scheme** | `http` | +| **Forward Hostname / IP** | `` | +| **Forward Port** | `19999` | +| **Block Common Exploits** | aktivieren | +| **Websockets Support** | aktivieren | + +Wechsle danach in den Reiter **SSL** und aktiviere: + +- **Request a new SSL Certificate** +- **Force SSL** +- **HTTP/2 Support** +- **HSTS Enabled** + +Speichere anschließend mit **Save**. + +> [!NOTE] +> Der Proxy Manager erstellt automatisch ein gültiges Let’s-Encrypt-Zertifikat. +> Ab sofort ist Netdata verschlüsselt über HTTPS erreichbar. + +#### Verbindung testen + +Öffne im Browser: + +``` +https://monitor.deinedomain.tld +``` + +Wenn das Dashboard erscheint und im Browser ein **Schloss-Symbol** sichtbar ist, funktioniert die Einbindung korrekt. +Prüfe anschließend, ob sich die Diagramme in Echtzeit aktualisieren (z. B. CPU- oder Netzwerkstatistik). + +👉 **Screenshot geeignet:** Browserfenster mit Netdata-Dashboard unter `https://monitor.deinedomain.tld` (Schloss-Symbol sichtbar) + +> [!TIP] +> Wenn die Seite nicht lädt, überprüfe im NPM-Dashboard, ob die **IP-Adresse** und der **Forward Port 19999** korrekt eingetragen sind. +> Starte bei Bedarf den Netdata-Dienst neu: +> ```bash +> systemctl restart netdata +> ``` + +### Schritt 7 – Dashboard und Oberfläche verstehen + +Nach erfolgreicher Einrichtung erreichst du das Dashboard über: + +``` +https://monitor.deinedomain.tld +``` + +Beim ersten Aufruf öffnet sich automatisch die **Startübersicht von Netdata**. +Sie zeigt in Echtzeit CPU-, RAM-, Netzwerk- und I/O-Aktivität an und aktualisiert die Werte im Sekundentakt. + +👉 **Screenshot geeignet:** Browser mit geöffneter Netdata-Startseite (Live-Diagramme sichtbar) + +#### Aufbau der Oberfläche + +Die Oberfläche ist in drei Hauptbereiche gegliedert: + +1. **Linke Seitenleiste:** + Navigation zwischen Host-, System- und Container-Ansichten. + Jeder Abschnitt ist interaktiv und erweitert sich bei Klick automatisch. + +2. **Zentraler Inhaltsbereich:** + Enthält die Echtzeitdiagramme aller überwachten Ressourcen (CPU, RAM, Netzwerk, Festplatten, Prozesse). + +3. **Header-Leiste:** + Anzeige von Hostname, Uptime, Benutzer-Menü und Suchfunktion. + +> [!NOTE] +> Netdata aktualisiert alle Messwerte automatisch im Browser. +> Es ist keine manuelle Aktualisierung notwendig – die Daten stammen direkt aus dem laufenden System. + +#### Wichtige Ansichten im Überblick + +| Bereich | Beschreibung | +|----------|--------------| +| **System Overview** | Gesamtübersicht mit CPU-, RAM-, Swap- und Netzwerkbelastung. | +| **Network Interfaces** | Eingehender und ausgehender Datenverkehr pro Interface. | +| **Disks** | Lese-/Schreibaktivität sowie Speicherverfügbarkeit. | +| **Processes** | Aktive Prozesse, CPU-Last pro Prozess, Laufzeit und Status. | +| **Containers / Virtualization** | Zeigt alle LXC- oder Docker-Container mit individuellen Metriken. | + +👉 **Screenshot geeignet:** Ausschnitt der System-Overview mit hervorgehobener CPU- und Netzwerkanzeige + +> [!TIP] +> Mit einem Klick auf den Hostnamen oben links kannst du jederzeit zwischen verbundenen Nodes wechseln, +> sobald du später weitere Systeme mit Netdata-Agenten ergänzt. + +Damit bist du mit der Weboberfläche vertraut und kannst Systemzustände schnell interpretieren. +Im nächsten Schritt geht es um grundlegende **Funktionstests und Stabilitätskontrolle**. + +### Schritt 8 – Weitere LXC-Container in Netdata einbinden (Basis-Monitoring) + +Netdata kann Daten mehrerer Systeme in einem zentralen Dashboard zusammenführen. +Dadurch siehst du auf einen Blick, welche Container wie stark ausgelastet sind und kannst frühzeitig Engpässe erkennen. +Im Free-Bereich richten wir das Basis-Monitoring über das integrierte **Netdata-Streaming-System** ein. + +👉 **Screenshot geeignet:** Übersicht im Browser mit mehreren verbundenen Nodes (zentrale Ansicht) + +#### Funktionsweise + +Jede Netdata-Instanz kann entweder als **Parent (Empfänger)** oder **Child (Datenquelle)** fungieren. +- Der **Parent** sammelt und visualisiert die Daten. +- Die **Children** senden ihre Metriken regelmäßig an den Parent. + +In deinem Homelab ist der zentrale Netdata-LXC der **Parent**, +alle zu überwachenden LXC-Container (z. B. Pi-hole, NPM, Wiki.js) werden als **Children** eingerichtet. + +#### 1. Netdata auf dem Zielcontainer installieren + +Öffne den Container, den du überwachen willst (Beispiel: Pi-hole) +und installiere dort ebenfalls Netdata über das offizielle Script: + +```bash +bash <(curl -Ss https://my-netdata.io/kickstart.sh) --stable-channel --disable-telemetry +``` + +> [!NOTE] +> Netdata wird hier nur als „Sensor“ betrieben. +> Die Weboberfläche wird später abgeschaltet, um Ressourcen zu sparen. + +#### 2. Konfiguration als „Child“ anpassen + +Öffne auf dem überwachten Container die Konfigurationsdatei: + +```bash +nano /etc/netdata/stream.conf +``` + +Füge folgende Zeilen hinzu (falls nicht vorhanden) und passe die IP-Adresse an: + +``` +[stream] + enabled = yes + destination = :19999 + api key = + hostname = +``` + +Beispiel: +``` +[stream] + enabled = yes + destination = 10.0.0.15:19999 + api key = 9e5c2e64-2f1d-41c3-b9ff-913c4e0a1c42 + hostname = PiHole +``` + +> [!TIP] +> Den API-Key kannst du selbst frei wählen – er dient nur der eindeutigen Zuordnung. +> Verwende für jeden Container einen eigenen Key. + +Starte anschließend Netdata neu: + +```bash +systemctl restart netdata +``` + +#### 3. Parent konfigurieren + +Auf dem zentralen Netdata-Container öffnest du ebenfalls die Datei: + +```bash +nano /etc/netdata/stream.conf +``` + +Füge dort im Bereich `[api]` oder am Ende folgende Zeilen ein: + +``` +[stream] + enabled = yes + mode = parent + accept all = yes +``` + +> [!NOTE] +> Mit `accept all = yes` kann der Parent von allen internen Hosts Daten empfangen. +> Für produktive Umgebungen kann hier stattdessen gezielt nach API-Keys gefiltert werden. + +Starte den Parent neu: + +```bash +systemctl restart netdata +``` + +#### 4. Verbindung prüfen + +Wechsle zurück in den Browser auf dein zentrales Dashboard: + +``` +https://monitor.deinedomain.tld +``` + +Links in der Seitenleiste sollte nun ein neuer Eintrag mit dem Namen des Child-Containers erscheinen (z. B. „PiHole“). +Wenn du darauf klickst, werden dessen Metriken in Echtzeit angezeigt. + +👉 **Screenshot geeignet:** Netdata-Seitenleiste mit mehreren verbundenen Nodes (z. B. „Netdata“, „PiHole“, „NPM“) + +> [!TIP] +> Wenn der neue Container nicht auftaucht, prüfe: +> ```bash +> systemctl status netdata +> tail -n 50 /var/log/netdata/error.log +> ``` +> Häufige Ursache sind Tippfehler in der `destination`-Adresse oder fehlende Portfreigaben. + +Mit dieser Methode kannst du beliebig viele LXC-Container anbinden. +Netdata zeigt sie automatisch in der Übersicht an und aktualisiert alle Werte in Echtzeit. + +--- + +## Troubleshooting & Tipps + +Netdata ist im Alltag sehr stabil, kann aber während der Einrichtung oder beim Einbinden weiterer Container kleine Stolperfallen haben. +Die folgenden Punkte helfen dir, typische Fehler schnell zu erkennen und zu beheben. + +👉 **Screenshot geeignet:** Übersicht „Bratonien Kontrollzentrum“ mit markiertem Netdata-Dashboard + +### Netdata-Dashboard lädt nicht + +Wenn `https://monitor.deinedomain.tld` im Browser nicht reagiert oder eine Fehlermeldung zeigt, liegt das meist an einer der folgenden Ursachen. + +1. **Container läuft nicht** + + Öffne in Proxmox die Containerliste und prüfe, ob der Netdata-LXC aktiv ist. + Alternativ per Konsole: + ```bash + pct status + ``` + Wenn der Status „stopped“ lautet: + ```bash + pct start + ``` + Dadurch wird der Container wieder gestartet. + +2. **Dienst ist nicht aktiv** + + Prüfe, ob Netdata läuft: + ```bash + systemctl status netdata + ``` + In der Ausgabe muss **active (running)** stehen. + Falls nicht, starte den Dienst neu: + ```bash + systemctl restart netdata + ``` + +3. **Fehlerhafte Proxy-Weiterleitung** + + Wenn das Dashboard intern erreichbar ist, aber über HTTPS nicht lädt: + - Öffne das Dashboard des Nginx Proxy Manager. + - Kontrolliere, ob beim Proxy-Host die IP-Adresse des Netdata-Containers eingetragen ist. + - Der Forward-Port muss **19999** sein. + - Das SSL-Zertifikat muss aktiv und gültig sein (Schloss-Symbol im Browser). + +> [!TIP] +> Nach Änderungen im Proxy oder bei der SSL-Erstellung kann es bis zu einer Minute dauern, +> bis das Zertifikat aktiv verwendet wird. +> Ein Browser-Neustart hilft oft, um alte Caches zu leeren. + +👉 **Screenshot geeignet:** NPM-Dashboard mit aktivem Proxy-Host `monitor.deinedomain.tld` + +### Child-Container erscheinen nicht im Dashboard + +Wenn ein angebundener Container (z. B. Pi-hole oder Wiki.js) nicht in der Netdata-Übersicht auftaucht, gehe folgendermaßen vor: + +1. **Verbindung prüfen** + + Öffne auf dem betroffenen Container die Konsole und überprüfe den Dienst: + ```bash + systemctl status netdata + ``` + Wenn er nicht läuft: + ```bash + systemctl restart netdata + ``` + +2. **Fehlerprotokoll ansehen** + + Zeige die letzten 50 Zeilen der Netdata-Fehlerausgabe: + ```bash + tail -n 50 /var/log/netdata/error.log + ``` + Achte auf Meldungen wie `cannot connect to parent` oder `invalid API key`. + + Diese deuten meist auf eine falsche IP-Adresse oder einen Tippfehler im `api key` in der Datei `/etc/netdata/stream.conf` hin. + +3. **Parent-Einstellungen prüfen** + + Auf dem zentralen Netdata-Container: + ```bash + nano /etc/netdata/stream.conf + ``` + Stelle sicher, dass der Abschnitt wie folgt aussieht: + ``` + [stream] + enabled = yes + mode = parent + accept all = yes + ``` + Danach speichern und Netdata neu starten: + ```bash + systemctl restart netdata + ``` + +> [!NOTE] +> Wenn du gezielt einzelne Container zulassen möchtest, kannst du im Parent statt `accept all = yes` auch bestimmte API-Keys hinterlegen. +> Das ist jedoch nur im Premium-Kapitel relevant. + +👉 **Screenshot geeignet:** Netdata-Parent-Dashboard mit mehreren verbundenen Nodes + +### Dienst startet nicht automatisch nach Reboot + +Wenn Netdata nach einem Neustart des Containers nicht von selbst startet: + +```bash +systemctl enable netdata +``` + +Damit wird der automatische Start aktiviert. +Anschließend kannst du den Container neu starten, um das Verhalten zu testen: +```bash +reboot +``` + +> [!TIP] +> Wenn du mehrere Systeme gleichzeitig neu startest (z. B. nach einem Proxmox-Update), +> warte, bis der Parent-Container läuft, bevor du die Child-Container startest. +> So vermeiden sich Verbindungsfehler im Streaming-System. + +### Regelmäßige Wartung + +Halte Netdata regelmäßig aktuell, um neue Dashboards und Sicherheitsupdates zu erhalten: + +```bash +apt update && apt upgrade -y +``` + +Starte danach den Dienst neu: +```bash +systemctl restart netdata +``` + +👉 **Screenshot geeignet:** Terminal mit `apt upgrade`-Ausgabe und erfolgreichem Abschluss + +> [!TIP] +> Nach jedem Update kurz prüfen, ob das Dashboard weiter erreichbar ist. +> Alte Browser-Caches können dazu führen, dass Diagramme erst nach einem Reload (F5) wieder korrekt angezeigt werden. + +### Prüfung und Sicherung + +Damit deine Überwachung dauerhaft stabil bleibt, solltest du Netdata regelmäßig prüfen und seine Konfiguration sichern. +Dadurch lassen sich Fehler frühzeitig erkennen und im Bedarfsfall schnell beheben. + +#### 1. Funktionsprüfung + +Einmal pro Woche reicht eine kurze Kontrolle: + +```bash +systemctl status netdata +``` + +Wenn der Dienst aktiv ist (**active (running)**) und das Dashboard erreichbar bleibt, ist alles in Ordnung. +Alternativ kannst du dich einfach im Browser einloggen und prüfen, ob sich die Diagramme weiterhin live aktualisieren. + +> [!TIP] +> Wenn du n8n oder ähnliche Tools nutzt, kannst du später eine einfache Abfrage automatisieren, +> die regelmäßig den HTTP-Status von `https://monitor.deinedomain.tld` prüft. + +#### 2. Konfiguration sichern + +Alle wichtigen Netdata-Einstellungen befinden sich in `/etc/netdata/`. +Sichere dieses Verzeichnis regelmäßig mit deinem bevorzugten Backup-System (z. B. Kopia oder Nextcloud-Backup). + +```bash +tar -czf /srv/backup/netdata-config-$(date +%F).tar.gz /etc/netdata +``` + +Die erzeugte Datei enthält alle relevanten Konfigurationen (`netdata.conf`, `stream.conf`, `health_alarm.conf`, etc.). +So kannst du nach einem Update oder Neuaufsetzen deine komplette Struktur wiederherstellen. + +👉 **Screenshot geeignet:** Terminalausgabe nach erfolgreicher Archiv-Erstellung (Dateiname sichtbar) + +> [!NOTE] +> Die eigentlichen Monitoring-Daten müssen **nicht** gesichert werden. +> Netdata speichert Metriken im RAM und nutzt nur kurzzeitig Pufferdateien, +> die beim Neustart automatisch neu erzeugt werden. + +--- + +## Ergebnis + +Nach Abschluss dieses Kapitels läuft Netdata als **zentrale Monitoring-Instanz** in deinem Homelab. +Du hast ein System, das alle wichtigen Leistungsdaten deiner LXC-Container in Echtzeit anzeigt – vollständig über **HTTPS** abgesichert und jederzeit über den Browser erreichbar. + +Dein aktuelles Setup besteht aus: + +- **Netdata (Parent-Container)** – empfängt und visualisiert alle Daten. +- **Mehrere LXC-Container (Children)** – senden ihre Systemmetriken automatisch an den Parent. +- **Nginx Proxy Manager (NPM)** – stellt das Dashboard sicher über `https://monitor.deinedomain.tld` bereit. + +👉 **Screenshot geeignet:** Netdata-Dashboard mit mehreren verbundenen Nodes im Browser + +Damit hast du jetzt: +- einen klaren Überblick über CPU-, RAM-, Netzwerk- und Festplattenauslastung, +- eine funktionierende Basis für Lastanalyse und Fehlererkennung, +- und die Grundlage, um im nächsten Schritt automatisierte Reaktionen aufzubauen. + +> [!TIP] +> Wenn du erweiterte Funktionen wie Benachrichtigungen, automatisierte Reaktionen oder +> n8n-Integration nutzen möchtest, empfehlen wir dir die **kostenpflichtige Erweiterung zu diesem Kapitel** +> oder unseren **Premiumkurs**. + +Netdata ist damit fester Bestandteil des **Bratonien Kontrollzentrums** und bildet die technische Grundlage +für proaktive Wartung, Performanceoptimierung und stabile Systemüberwachung – +ideal für Content Creator, Streamer und private Homelab-Nutzer, die ihre Infrastruktur im Griff behalten wollen. + + +