Kapitel 21/Premium Rohtext.md hinzugefügt

Kapitel 21/Premium Rohtext.md

@@ -0,0 +1,262 @@
+# Kapitel 21 – Home Assistant (Premium)
+
+Home Assistant wird im Premium-Kapitel nicht als klassisches Smart-Home-System betrachtet,  
+sondern als erweiterte Steuer- und Beobachtungsoberfläche für dein UCC.  
+Ziel ist, die vorhandenen Systeme – Nextcloud, Vaultwarden, n8n, Kopia und Streaming-Dienste –  
+direkt aus einem zentralen Dashboard bedienen und überwachen zu können.
+
+Der Fokus liegt auf **praktischen UCC-Funktionen**, nicht auf privater Hausautomatisierung.  
+Alles bleibt lokal, nachvollziehbar und datensouverän.  
+Du lernst, wie du Home Assistant als grafisches Kontrollzentrum erweiterst und automatisierst,  
+ohne zusätzliche Cloud-Dienste oder externe Konten zu benötigen.
+
+Im Premium-Teil werden folgende Themen umgesetzt:
+
+- Erweiterte Integrationen zu bestehenden UCC-Diensten  
+- Anpassung und Branding der Oberfläche im Bratonien-Stil  
+- Automatische Backups über Kopia oder n8n  
+- Erweiterte Authentifizierung und Fernzugriff  
+- Streaming-Anbindung mit Status-Anzeige und Aktionen
+
+👉 **Screenshot geeignet:** Premium-Dashboard mit Bratonien-Farben, System-Kacheln und Aktions-Buttons
+
+> [!NOTE]  
+> Dieser Teil baut auf der bestehenden Installation aus dem Free-Kapitel auf.  
+> Wenn Home Assistant dort noch nicht vollständig läuft oder der Zugriff über NPM fehlt,  
+> schließe zuerst das Free-Kapitel vollständig ab, bevor du hier weitermachst.
+
+---
+
+## Erweiterte Integrationen – Premium Dashboard
+
+Im Premium-Teil wird Home Assistant zu deiner echten Schaltzentrale.  
+Nicht mehr nur zum Anzeigen von Werten – sondern als vollwertiges Kontrollzentrum,  
+das jeden Container im UCC erkennt, anzeigt und direkt steuern kann.  
+
+Ziel ist ein übersichtliches Dashboard, das **auf einen Blick** zeigt,  
+welche Systeme aktiv sind, wie stark sie ausgelastet sind  
+und über das du mit einem Klick reagieren kannst – ohne dich in Proxmox oder n8n einzuloggen.  
+
+👉 **Screenshot geeignet:** Premium-Dashboard mit allen LXC-Kacheln und sichtbaren Statusanzeigen  
+
+> [!NOTE]  
+> Dieses Dashboard ersetzt kein Monitoring wie Netdata –  
+> es ist die Oberfläche für Entscheidungen und schnelle Eingriffe.  
+> Alles bleibt lokal, transparent und nachvollziehbar.
+
+### Funktionsprinzip
+
+Jeder Container im UCC wird als eigene Kachel dargestellt.  
+Ob Nextcloud, Vaultwarden oder Kopia – jeder Dienst bekommt seinen festen Platz.  
+Die Oberfläche ist einheitlich aufgebaut: oben eine **Status-Ampel**,  
+darunter die wichtigsten Leistungsdaten (CPU, RAM, Netzlast).  
+
+Die Ampel zeigt den Zustand des Containers an:  
+- **Grün:** läuft und antwortet auf Abfragen  
+- **Gelb:** aktiv, aber Antwort verzögert  
+- **Rot:** gestoppt oder nicht erreichbar  
+
+Ein Klick auf die Kachel öffnet ein Menü mit einfachen, klaren Aktionen:  
+**Starten, Stoppen, Neustarten, Backup auslösen oder Weboberfläche öffnen.**
+
+👉 **Screenshot geeignet:** Beispielkachel mit Ampelindikator, Leistungswerten und geöffnetem Menü
+
+> [!TIP]  
+> Das Ziel ist keine technische Tiefe, sondern Übersicht und Kontrolle.  
+> Du siehst, was läuft – und kannst sofort handeln, ohne Terminal oder SSH.
+
+### Live-Daten und Verhalten
+
+Das Dashboard arbeitet in Echtzeit.  
+Home Assistant fragt alle relevanten Daten direkt über die Proxmox-API ab  
+und kombiniert sie mit den Leistungswerten aus Netdata.  
+So erkennst du sofort, wenn ein Container startet, stoppt oder überlastet ist.
+
+Die Aktualisierung erfolgt im 30-Sekunden-Takt –  
+kurz genug für reaktive Anzeige, aber ressourcenschonend für Host und API.  
+Bei jeder Aktualisierung prüft das System den Status jedes Containers  
+und aktualisiert die Ampel sowie die Leistungsdaten automatisch.
+
+👉 **Screenshot geeignet:** Kachel mit sichtbarer CPU-Last und sich änderndem Statusindikator
+
+> [!NOTE]  
+> Alle Werte stammen aus deinen eigenen Systemen.  
+> Es gibt keine Cloud-Abhängigkeit und keine externe Datensammlung.
+
+### Aktionen und Interaktion
+
+Ein Klick auf eine Kachel öffnet das **Aktionen-Menü**.  
+Hier steuerst du den jeweiligen Container direkt, ohne Umweg über Proxmox.  
+Jede Aktion löst im Hintergrund einen API-Aufruf aus und zeigt sofort das Ergebnis an.  
+
+**Verfügbare Aktionen:**
+
+- **Starten** – Container wird direkt über die Proxmox-API eingeschaltet  
+- **Stoppen** – kontrollierter Shutdown des Containers  
+- **Neustarten** – schneller Reboot, nützlich nach Updates  
+- **Backup auslösen** – startet den hinterlegten Backup-Job in Proxmox  
+- **Weboberfläche öffnen** – ruft die NPM-URL des Containers in neuem Tab auf  
+
+Die Buttons reagieren sofort:  
+Nach einer Aktion aktualisiert sich die Kachel automatisch.  
+Ein grüner Rahmen zeigt erfolgreiche Ausführung, ein roter kurzzeitigen Fehler.  
+
+👉 **Screenshot geeignet:** geöffnete Menüansicht mit den fünf Aktionspunkten  
+
+> [!TIP]  
+> Home Assistant merkt sich den letzten ausgeführten Befehl.  
+> So kannst du nachvollziehen, wann ein Container zuletzt manuell gesteuert wurde.
+
+### Sicherheit und Kontrolle
+
+Da das Dashboard direkten Zugriff auf deine Container hat,  
+wird der Zugriff ausschließlich aus deinem internen Netz erlaubt.  
+Der Benutzer `ha@pve` hat zwar volle Rechte auf Proxmox,  
+ist aber ausschließlich für Home Assistant vorgesehen  
+und wird außerhalb des Dashboards nicht verwendet.
+
+Zugriffe von außen sind über den Nginx Proxy Manager geschützt.  
+Nur authentifizierte Benutzer:innen mit gültiger Session können Aktionen ausführen.  
+Jede Steuerung – Start, Stop, Backup – wird zusätzlich in Home Assistant geloggt,  
+damit du jederzeit nachvollziehen kannst, wer wann was getan hat.
+
+👉 **Screenshot geeignet:** Home-Assistant-Protokoll mit Eintrag „LXC 103 neu gestartet über Dashboard“
+
+> [!CAUTION]  
+> Gib den Home-Assistant-Zugang niemals weiter.  
+> Das Dashboard ist kein „Viewer“, sondern ein Werkzeug mit Systemrechten.
+
+### Technische Basis
+
+Damit die Steuerung funktioniert, nutzt Home Assistant zwei Datenquellen:  
+die **Proxmox-API** für Status und Aktionen sowie die **Netdata-API** für Leistungswerte.  
+Beide Systeme laufen lokal im UCC, wodurch keine externen Abfragen notwendig sind.  
+
+**Ablauf pro Container:**
+
+1. Home Assistant fragt den Proxmox-Status (`running`, `stopped`, `paused`) ab.  
+2. Parallel werden CPU-, RAM- und Disk-Werte von Netdata abgerufen.  
+3. Das Dashboard kombiniert beide Ergebnisse und aktualisiert die Kachel.  
+4. Wird eine Aktion ausgelöst, führt Home Assistant den passenden API-Call an Proxmox aus.  
+5. Nach Ausführung folgt automatisch eine Aktualisierung des Status.
+
+👉 **Screenshot geeignet:** vereinfachte Ablaufgrafik zwischen Home Assistant, Proxmox und Netdata
+
+> [!NOTE]  
+> Alle Verbindungen laufen über HTTPS innerhalb deines internen Netzwerks.  
+> Externe APIs, Tokens oder n8n-Flows sind nicht beteiligt.
+
+### Umsetzung – Vorbereitung der Entitäten
+
+Bevor du mit dem Dashboard startest, braucht Home Assistant Daten, die es anzeigen kann.  
+Das bedeutet: dein System muss wissen, ob ein Container läuft, wie stark er arbeitet  
+und wie viel Speicher er gerade nutzt.  
+
+Diese Informationen kommen aus zwei Quellen: **Proxmox** (Status und Steuerung)  
+und **Netdata** (Leistungswerte).  
+
+1) **Proxmox verbinden**  
+   Öffne in Home Assistant den Bereich **Einstellungen → Geräte & Dienste**  
+   und prüfe, ob dein Proxmox-Server bereits eingebunden ist.  
+   Wenn du im Free-Kapitel alles richtig gemacht hast,  
+   sollte dort dein Server mit allen Containern erscheinen.  
+
+   👉 **Screenshot geeignet:** Liste der Proxmox-Container in Home Assistant  
+
+   Falls du keinen Zugriff siehst, überprüfe kurz den API-Benutzer `ha@pve`.  
+   Er sollte die Berechtigung haben, den Systemzustand zu lesen und Aktionen auszuführen.  
+
+2) **Container-Status sichtbar machen**  
+   In der Proxmox-Integration findest du zu jedem Container eine kleine Statusanzeige.  
+   Wenn der Container läuft, steht dort „running“, sonst „stopped“.  
+   Das ist die Grundlage für deine Ampelanzeige im Dashboard.  
+
+   👉 **Screenshot geeignet:** Entitätenliste mit sichtbaren LXC-Statusanzeigen  
+
+3) **Leistungswerte aktivieren**  
+   Damit du später auch CPU- und RAM-Werte siehst, werden diese Daten aus Netdata übernommen.  
+   Öffne dafür **Einstellungen → Geräte & Dienste → Integration hinzufügen**  
+   und suche nach **REST**.  
+   Darüber bindest du Netdata ein – Home Assistant fragt die Daten regelmäßig ab  
+   und hält sie automatisch aktuell.  
+
+   👉 **Screenshot geeignet:** REST-Integration mit sichtbaren CPU- und RAM-Werten  
+
+> [!TIP]  
+> Du musst das nur einmal einrichten.  
+> Wenn die Verbindung steht, erscheinen die Werte für alle Container automatisch im System.
+
+### Erste Kachel erstellen
+
+Damit dein Dashboard etwas anzeigt, braucht es eine erste „Kachel“.  
+Sie ist wie eine kleine Infotafel für einen einzelnen Container –  
+zum Beispiel für deine Nextcloud oder deinen Nginx Proxy Manager.  
+Sie zeigt an, ob der Dienst läuft und wie stark er gerade arbeitet.
+
+1) Öffne in Home Assistant links den Punkt **Übersicht**.  
+   Klicke unten auf **+ Neues Dashboard** und gib ihm den Namen **UCC Premium**.  
+   Du siehst jetzt eine leere Fläche – hier erscheinen später alle deine Systeme.
+
+2) Klicke oben rechts auf **Bearbeiten → Karte hinzufügen**.  
+   Wähle als Typ **Button** (Schaltfläche).  
+   In diesem Fenster bestimmst du, was die Kachel zeigen soll.
+
+3) Im Feld **Name** trägst du ein, was sie darstellen soll –  
+   z. B. „Nextcloud“.  
+   Darunter gibt es ein Feld für den **Status**:  
+   Dort wählst du den Eintrag, der anzeigt, ob der Container läuft.  
+   (Wenn du das Free-Kapitel gemacht hast, findest du in der Liste schon deine Container.)
+
+4) Jetzt kommen die Leistungswerte.  
+   Scrolle etwas nach unten und füge unter „Zusätzliche Informationen“ zwei Werte hinzu:  
+   – **CPU-Auslastung** – zeigt, wie beschäftigt der Container gerade ist  
+   – **Arbeitsspeicher** – zeigt, wie viel Speicher er nutzt  
+   Diese Werte aktualisieren sich automatisch – du musst nichts manuell eingeben.
+
+5) Damit du den Zustand sofort erkennst, legst du Farben fest:  
+   – Grün, wenn der Dienst läuft  
+   – Rot, wenn er gestoppt ist  
+   – Grau, wenn er nicht erreichbar ist
+
+   👉 **Screenshot geeignet:** Erste Kachel mit Name, Status, CPU und RAM
+
+6) Klicke auf **Speichern**.  
+   Deine erste Kachel erscheint jetzt im Dashboard.  
+   Wenn du den Container in Proxmox kurz stoppst oder startest,  
+   sollte sich die Anzeige nach ein paar Sekunden ändern.
+
+> [!TIP]  
+> Wenn diese erste Kachel funktioniert, dupliziere sie einfach  
+> und ändere nur den Namen und den zugehörigen Container.  
+> So baust du dein gesamtes Dashboard Schritt für Schritt auf.
+### Mehrere Kacheln anlegen
+
+Jetzt, wo deine erste Kachel funktioniert, baust du das komplette Dashboard auf.  
+Jeder Container bekommt seine eigene Fläche – gleich groß, gleich aufgebaut,  
+damit du sofort siehst, wo etwas nicht stimmt.
+
+1) Öffne dein **UCC Premium Dashboard** und klicke oben rechts auf **Bearbeiten**.  
+   Danach auf **Karte duplizieren** – so behältst du das gleiche Design.  
+
+2) In der neuen Kachel änderst du nur drei Dinge:  
+   – den **Namen** (z. B. „Vaultwarden“ statt „Nextcloud“)  
+   – den **Status-Eintrag** (dein anderer Container)  
+   – die beiden Leistungswerte für CPU und RAM  
+
+   👉 **Screenshot geeignet:** mehrere gleichartige Kacheln mit unterschiedlichen Namen  
+
+3) Wiederhole das für alle Systeme, die du im Dashboard haben willst.  
+   Am Ende siehst du eine Übersicht mit farbigen Ampeln,  
+   die dir sofort zeigt, was läuft, was stoppt und was Probleme hat.
+
+4) Wenn du möchtest, kannst du die Kacheln sortieren:  
+   Ziehe sie einfach mit der Maus in Reihen oder Spalten,  
+   z. B. **Core-Dienste oben**, **Daten unten**, **Streaming rechts**.  
+   Das sorgt für klare Struktur, ohne dass du etwas konfigurieren musst.
+
+> [!TIP]  
+> Eine grüne Wand bedeutet: alles läuft.  
+> Sobald irgendwo Rot erscheint, weißt du sofort, welcher Container betroffen ist.  
+> Das ist die schnellste Art, dein UCC visuell zu überwachen.
+
+