Homelab--Bratonein-Kontrollzentrum--Tutorial/Kapitel 15/Free Rohtext.md

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