Kapitel 15/Free Rohtext.md hinzugefügt

2025-10-18 12:54:26 +00:00
parent 5d30625bea
commit 57b3395f85
1 changed files with 690 additions and 0 deletions
--- a/Rohtext.md
+++ b/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@<IP-des-Containers>
+  ```
+  Ersetze `<IP-des-Containers>` 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@<IP-des-Containers>`).
+
+> [!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://<IP-des-Containers>: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://<IP-des-Containers>: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 <IP-des-NPM-Containers> 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://<IP-des-Containers>: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** | `<IP-des-Netdata-Containers>` |
+| **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 = <IP-des-Netdata-Parent>:19999
+    api key = <EIGENER-STREAM-KEY>
+    hostname = <NAME-DES-CONTAINERS>
+```
+
+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 <CTID>
+   ```
+   Wenn der Status „stopped“ lautet:
+   ```bash
+   pct start <CTID>
+   ```
+   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.
+
+
+