Homelab--Bratonein-Kontrollzentrum--Tutorial/Kapitel 21/Premium Rohtext.md

# 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 vollständige Kachel

Diese Kachel ist das zentrale Steuerelement für deinen Container.  
Sie zeigt, ob der Dienst läuft, wie stark er arbeitet,  
und kann ihn direkt starten, stoppen, sichern und öffnen –  
alles innerhalb deines UCC.

1) Öffne in Home Assistant dein Dashboard **UCC Premium**  
   und wähle **Bearbeiten → Karte hinzufügen → Button**.  
   Gib der Karte den Namen deines Containers, z. B. **Nextcloud**.

2) Wähle im Feld **Statusquelle** den passenden Container aus.  
   Die Kachel zeigt automatisch den Zustand an:  
   Grün, wenn der Dienst läuft – Rot, wenn er gestoppt ist – Grau, wenn keine Verbindung besteht.

3) Füge zwei Leistungsanzeigen hinzu, damit du siehst, wie stark der Container gerade beansprucht wird:  
   – **CPU-Auslastung**  
   – **RAM-Nutzung**  
   Diese Werte kommen automatisch aus Netdata und aktualisieren sich regelmäßig.

4) Öffne den Abschnitt **Aktion bei Klick** und wähle **Menü anzeigen**.  
   Hier legst du fest, was passieren soll, wenn du auf die Kachel tippst.  
   Füge folgende Punkte hinzu:  
   – **Starten** – Container einschalten  
   – **Stoppen** – Container herunterfahren  
   – **Neustarten** – kurz aus und wieder an  
   – **Backup auslösen** – startet ein automatisches Backup über Duplicati  
   – **Weboberfläche öffnen** – ruft die zugehörige Seite über NPM auf  

   👉 **Screenshot geeignet:** Menü mit allen fünf Einträgen sichtbar  

5) Damit der Punkt *Backup auslösen* funktioniert, aktivierst du in Duplicati die Web-API.  
   Öffne die Duplicati-Oberfläche und gehe zu **Einstellungen → Remote-Zugriff**.  
   Setze den Haken bei **Erlaube API-Zugriff** und vergib ein starkes Passwort.  
   Danach erreichst du Duplicati lokal über die Schnittstelle:  
   ```
   https://duplicati.deinedomain.tld/api/v1/
   ```
   Jeder Backup-Job hat dort einen eigenen Namen, z. B. `Nextcloud-Daily`.  
   Du kannst ihn direkt starten, indem du in Home Assistant die folgende Adresse einträgst:  
   ```
   https://duplicati.deinedomain.tld/api/v1/backup/start?name=Nextcloud-Daily
   ```  
   Sobald du die Aktion klickst, führt Duplicati den passenden Job aus.  
   Du siehst den Fortschritt wie gewohnt in der Duplicati-Weboberfläche.  

   👉 **Screenshot geeignet:** geöffnete Duplicati-Einstellung mit aktiviertem API-Zugriff  

6) Für den Punkt *Weboberfläche öffnen* trägst du im Menü die passende URL deines Containers ein,  
   z. B.:  
   ```
   https://nextcloud.deinedomain.tld
   ```  
   Wenn du diesen Menüpunkt wählst, öffnet sich die Seite sofort in einem neuen Tab.

7) Teste die Kachel:  
   – Container starten oder stoppen  
   – Backup auslösen  
   – Weboberfläche öffnen  
   Nach wenigen Sekunden sollte sich die Farbe der Kachel anpassen,  
   und das Backup in Duplicati sichtbar starten.

> [!TIP]  
> Diese Vorlage kannst du für alle anderen Container übernehmen.  
> Ändere nur den Namen und den jeweiligen Duplicati-Job.  
> So entsteht Schritt für Schritt ein zentrales, einheitliches Kontrollzentrum für dein gesamtes UCC.

---

## UI-Erweiterung: Thematische Tabs

Das zentrale Dashboard aus dem Free-Teil zeigt bereits alle LXC-Container übersichtlich auf einer Seite.  
Im Premium-Teil erweitern wir diese Oberfläche um **thematische Tabs**, die deine Infrastruktur logisch gliedern.

Jeder Tab bündelt zusammengehörige Dienste – beispielsweise alle Netzwerk-Tools oder alle Automatisierungen –  
und macht so aus deiner Container-Liste eine strukturierte Kommandozentrale.

> [!NOTE]  
> Diese Tabs basieren auf den bisherigen Kapiteln 1 bis 21.  
> Clipper (Kapitel 22) ist nicht enthalten, da es sich nicht um einen steuerbaren Dienst handelt.

👉 **Screenshot geeignet:** Tab-Leiste mit markiertem aktivem Bereich „Daten & Dateien“

### Tab-Übersicht

| **Tab**                         | **Dienste / LXC-Container**                            | **Beschreibung**                                      |
|----------------------------------|---------------------------------------------------------|--------------------------------------------------------|
| **Übersicht** *(Startseite)*     | Alle LXC-Container                                     | Übersicht aller Dienste mit Status und Grundfunktionen |
| **System & Infrastruktur**       | Proxmox, Netdata, Archiv, Webspace, Asset-LXC          | Basis-VMs, Ressourcen, Backup, Serververwaltung         |
| **Netzwerk & Sicherheit**        | Pi-hole, Nginx Proxy Manager, WireGuard, Vaultwarden, WAHA | DNS, Reverse Proxy, VPN, Passwortsafe, API-Gateways    |
| **Dateien & Dienste**            | Nextcloud, Paperless, Tandoor                          | Dateiablage, Dokumentenmanagement, Rezeptverwaltung     |
| **Automation & Integration**     | n8n, Ollama, Asset-LXC, Gitea                          | Workflows, KI, Code, Hintergrunddienste                |
| **Kommunikation & Information**  | Wiki, Postiz, Affine                                   | Wissensdatenbank, Notizen, Kommunikationsdienste       |
| **Medien & Streaming**           | RTMP                                                   | Streaming-Infrastruktur                                |
| **Smart Home & Visualisierung**  | Home Assistant                                         | Steuerung, Visualisierung, Hausautomatisierung         |
Jeder Tab enthält interaktive Kacheln mit Statusanzeige, Ressourcenwerten und Direktaktionen.

👉 **Screenshot geeignet:** geöffneter Tab „Automation & Dienste“ mit mehreren Kacheln sichtbar

## Tabs anlegen

Damit dein Dashboard übersichtlich bleibt, gliedern wir die Oberfläche in einzelne Tabs.  
Jeder Tab bildet ein Thema ab – z. B. **Netzwerk & Sicherheit** oder **Automation & Dienste** –  
und enthält die zugehörigen Kacheln.

Tabs lassen sich direkt über die Oberfläche von Home Assistant anlegen.

### Ersten Tab erstellen

1. Öffne in Home Assistant dein Dashboard **UCC Premium**  
2. Klicke oben rechts auf das Drei-Punkte-Menü und wähle **„Dashboard bearbeiten“**  
3. Wähle unten **„Ansicht hinzufügen“**  
4. Vergib einen Namen für den Tab, z. B. `Netzwerk & Sicherheit`  
5. Wähle ein passendes Symbol, z. B. `mdi:shield-outline`  
6. Aktiviere die Option **„Panel anzeigen“**, damit mehrere Kacheln nebeneinander dargestellt werden können  
7. Speichern

Wiederhole diesen Vorgang für alle weiteren Bereiche:

- System & Infrastruktur  
- Daten & Dateien  
- Automation & Dienste  
- Wissen & Kommunikation  
- Smart Home & Visualisierung  

> [!TIP]  
> Du musst nicht alle Tabs sofort befüllen. Beginne mit den Bereichen, die für dich am wichtigsten sind.

👉 **Screenshot geeignet:** Tab-Leiste mit aktivem Tab „Netzwerk & Sicherheit“

Im nächsten Schritt fügen wir die Kacheln in diese Tabs ein und kümmern uns anschließend um besondere Funktionen,  
die über den Standard hinausgehen.

## Erste vollständige Kachel anlegen

Jetzt gestaltest du deine erste funktionsfähige Steuerkachel im Premium-Dashboard.  
Diese Kachel zeigt dir, ob ein Dienst läuft, wie stark er arbeitet –  
und ermöglicht dir, ihn direkt zu starten, zu stoppen oder neu zu starten.  
Ganz ohne Umweg über Proxmox oder Terminal.

Wir beginnen mit dem Container **Proxmox** (also dem LXC, der dein Proxmox-Webinterface enthält).

> [!NOTE]  
> Alle weiteren Kacheln kannst du später einfach duplizieren  
> und an den jeweiligen Dienst anpassen – z. B. Nextcloud, Vaultwarden, n8n, etc.

### Schritt 1 – Kachel erstellen

Für deine Steuerkacheln nutzt du die `custom:button-card`.  
Damit kannst du nicht nur den Status eines Containers anzeigen,  
sondern auch CPU- und RAM-Auslastung sichtbar machen –  
alles in einer einzigen Kachel.

> [!NOTE]  
> Wenn du die `custom:button-card` noch nicht installiert hast:  
> Öffne den **Home Assistant Community Store (HACS)**,  
> gehe zu **Frontend → Button Card** und installiere sie dort.  
> Danach Home Assistant neu starten.

#### Kachel anlegen

1. Öffne dein **Premium-Dashboard**  
2. Klicke auf **„Bearbeiten“**, dann auf **„Karte hinzufügen“**
3. Wähle den Typ **„Benutzerdefiniert → Button Card“**

Im folgenden Editor gibst du folgenden YAML-Block ein:

```yaml
type: custom:button-card
entity: sensor.lxc_proxmox_status
name: Proxmox
icon: mdi:server
show_state: true
show_icon: true
show_name: true
custom_fields:
  cpu: >
    [[[
      return states['sensor.netdata_proxmox_cpu']?.state + '%' || '–';
    ]]]
  ram: >
    [[[
      return states['sensor.netdata_proxmox_ram']?.state + '%' || '–';
    ]]]
styles:
  grid:
    - grid-template-areas: '"i n" "cpu cpu" "ram ram" "s s"'
    - grid-template-columns: 1fr 1fr
    - grid-template-rows: auto
  custom_fields:
    cpu:
      - font-size: 12px
      - color: gray
    ram:
      - font-size: 12px
      - color: gray
state:
  - value: 'running'
    color: green
  - value: 'stopped'
    color: red
  - value: 'paused'
    color: orange
tap_action:
  action: toggle
```

> [!NOTE]  
> Die Statusanzeige basiert auf dem Sensor `sensor.lxc_proxmox_status`.  
> CPU- und RAM-Werte stammen aus Netdata und müssen in deinem System  
> z. B. als `sensor.netdata_proxmox_cpu` und `sensor.netdata_proxmox_ram` verfügbar sein.  
> Diese Sensoren werden im Free-Kapitel automatisch angelegt,  
> wenn du Netdata korrekt integriert hast.

> [!TIP]  
> Wenn du nicht sicher bist, wie deine Sensoren heißen,  
> schau unter **Einstellungen → Geräte & Dienste → Entitäten**  
> und suche nach `proxmox` oder `netdata`.

Diese Kachel zeigt dir nun:
- ob der Container läuft (grün), gestoppt ist (rot) oder pausiert (orange)  
- die aktuelle CPU-Auslastung  
- die aktuelle RAM-Nutzung

### Schritt 2 – Steuerung einbauen

Deine Kachel zeigt bereits den aktuellen Zustand und Leistungsdaten –  
jetzt soll sie auch **direkt steuerbar** sein.

Du hinterlegst dafür drei Aktionen:
- **Einfacher Klick:** Container starten  
- **Doppelklick:** Container stoppen  
- **Halten:** Container neustarten

Diese Befehle werden über `rest_command`s ausgelöst,  
die du im nächsten Schritt definierst.

#### Aktionen in der Kachel eintragen

Öffne deine bestehende `custom:button-card`  
und **ersetze den Block `tap_action: action: toggle`**  
durch die folgenden drei Einträge:

```yaml
tap_action:
  action: call-service
  service: rest_command.proxmox_lxc_start_proxmox

double_tap_action:
  action: call-service
  service: rest_command.proxmox_lxc_stop_proxmox

hold_action:
  action: call-service
  service: rest_command.proxmox_lxc_restart_proxmox
```

> [!NOTE]  
> Diese drei Befehle existieren noch nicht in deinem System.  
> Du wirst sie im nächsten Schritt in deiner `configuration.yaml` selbst anlegen.

### Schritt 3 – Steuerbefehle in Home Assistant anlegen

Damit dein Button wirklich **Start**, **Stop** und **Neustart** ausführen kann,  
muss Home Assistant wissen, **wie** es mit deinem Proxmox-Server sprechen soll.

Dazu legst du drei sogenannte `rest_command`s an –  
**für jeden einzelnen Container**, den du steuern möchtest.

> [!CAUTION]  
> Es reicht **nicht**, diese Befehle einmalig zu erstellen.  
> Du brauchst **pro Container** ein eigenes Befehls-Set:  
> jeweils einen für Start, Stop und Neustart.

> [!NOTE]  
> Speichere zuerst deinen Button im Dashboard, bevor du Home Assistant verlässt.  
> Die Änderungen im YAML wirken sich sonst nicht korrekt aus.

#### Öffne die Konfigurationsdatei

Die `configuration.yaml` ist die zentrale Datei von Home Assistant.  
Hier legst du Befehle, Sensoren und Integrationen manuell an.

So findest du sie:

1. Öffne Home Assistant im Browser  
2. Gehe zu **Einstellungen → Add-ons**  
3. Starte den **File Editor**  
   (falls nicht installiert: über HACS → Frontend nachinstallieren)  
4. Klicke links auf die Datei `configuration.yaml`

> [!TIP]  
> Alternativ kannst du auch per SFTP auf dein Home Assistant System zugreifen  
> und dort im `config`-Verzeichnis die Datei `configuration.yaml` öffnen.

#### Befehle einfügen (für einen Container)

Scrolle ans Ende der Datei und füge folgenden Block ein.  
Dieses Beispiel zeigt die Steuerung für den Container `Proxmox` mit der ID `101`.

```yaml
rest_command:
  proxmox_lxc_start_proxmox:
    url: "https://192.168.100.10:8006/api2/json/nodes/pve/lxc/101/status/start"
    method: POST
    verify_ssl: false
    headers:
      Authorization: "PVEAPIToken=ha@pve!homeassistant=DEIN_API_TOKEN"

  proxmox_lxc_stop_proxmox:
    url: "https://192.168.100.10:8006/api2/json/nodes/pve/lxc/101/status/stop"
    method: POST
    verify_ssl: false
    headers:
      Authorization: "PVEAPIToken=ha@pve!homeassistant=DEIN_API_TOKEN"

  proxmox_lxc_restart_proxmox:
    url: "https://192.168.100.10:8006/api2/json/nodes/pve/lxc/101/status/reboot"
    method: POST
    verify_ssl: false
    headers:
      Authorization: "PVEAPIToken=ha@pve!homeassistant=DEIN_API_TOKEN"
```

> [!TIP]  
> Ersetze:
> – `192.168.100.10` durch die IP-Adresse deines Proxmox-Servers  
> – oder verwende alternativ einen lokalen DNS-Namen wie `proxmox.local`  
> – `101` durch die **Container-ID** aus Proxmox  
> – `proxmox_lxc_*` durch einen eindeutigen Namen, z. B. `nextcloud`, `kopia`, etc.  
> – `DEIN_API_TOKEN` durch den API-Token für den Benutzer `ha@pve` aus dem Free-Kapitel

> [!NOTE]  
> Der Aufruf funktioniert **nur innerhalb deines Heimnetzwerks**.  
> Der Proxmox-Server ist nicht öffentlich erreichbar – und das ist gut so.

#### Konfiguration prüfen und übernehmen

1. Klicke im File Editor auf **„Speichern“**  
2. Gehe zu **Einstellungen → System → Steuerung**  
3. Klicke auf **„Konfiguration prüfen“**  
4. Wenn keine Fehler angezeigt werden, klicke auf **„Neu starten“**,  
   damit Home Assistant die neuen Befehle lädt

> [!CAUTION]  
> Wenn ein YAML-Fehler erscheint:  
> Prüfe Einrückungen, Anführungszeichen und doppelte `rest_command:`-Einträge.

Wenn alles korrekt eingetragen ist, funktioniert dein Button jetzt wie geplant.  
**Start**, **Stop** und **Neustart** können direkt über das Dashboard ausgelöst werden.

### Schritt 4 – Weboberfläche öffnen

Damit du direkt aus dem Dashboard die Benutzeroberfläche deines Containers öffnen kannst,  
fügst du einen vierten Befehl hinzu: **„Weboberfläche aufrufen“**.  
Anders als bei Start/Stopp ist das kein `rest_command`, sondern einfach ein Link,  
der beim Klicken einen neuen Tab im Browser öffnet.

#### Web-Link in die Kachel einbauen

Ergänze deine bestehende Kachel um folgenden zusätzlichen Block:  
**füge ihn direkt hinter den drei bisherigen Aktionsblöcken ein.**

```yaml
show_icon: true
show_name: true

custom_fields:
  web:
    card:
      type: custom:button-card
      icon: mdi:open-in-new
      tap_action:
        action: url
        url_path: "https://nextcloud.deinedomain.tld"
      styles:
        card:
          - background-color: "#64D4E8"
          - border-radius: 12px
          - padding: 8px
          - height: 40px
          - width: 40px
```

> [!TIP]  
> Du kannst die URL direkt anpassen – z. B. für Vaultwarden, n8n oder Kopia.  
> Die Adresse muss aus Sicht deines **Browsers** erreichbar sein,  
> also z. B. über den Nginx Proxy Manager veröffentlicht sein.

> [!NOTE]  
> Der Link öffnet sich **nicht im Home Assistant-Fenster**,  
> sondern startet einen neuen Browser-Tab mit der Zielseite.

Wenn du willst, kannst du das Icon auch durch einen Text oder anderen Button ersetzen –  
wir bleiben hier beim Symbol „open-in-new“ für Klarheit.

### Schritt 5 – Optische Korrektur bei gestopptem Container

Wenn ein Container gestoppt ist (`sensor.lxc_proxmox_status = stopped`),  
liefern die CPU- und RAM-Werte entweder `0`, `null` oder gar keine Anzeige.  
Damit das im Dashboard klarer und sauberer aussieht,  
setzen wir in diesem Fall eine Platzhalteranzeige – z. B. `–`.

#### Umsetzung:

Du passt den Anzeige-Text für CPU und RAM direkt in der Kachel an:  
Wenn der Container gestoppt ist, erscheint **nicht „0 %“**, sondern z. B. **„–“ oder „aus“**.

Füge dazu diesen Block in die Kachel unterhalb von `custom_fields:` ein  
(bzw. passe vorhandene Felder an):

```yaml
custom_fields:
  cpu: >
    [[[ return states['sensor.lxc_proxmox_status'].state === 'running'
         ? states['sensor.netdata_proxmox_cpu'].state + ' %'
         : '–'; ]]]
  ram: >
    [[[ return states['sensor.lxc_proxmox_status'].state === 'running'
         ? states['sensor.netdata_proxmox_ram'].state + ' %'
         : '–'; ]]]
```

> [!NOTE]  
> Diese Werte werden automatisch aktualisiert.  
> Wenn der Container startet oder stoppt, passen sich beide Felder direkt an.

> [!TIP]  
> Du kannst statt `–` auch `aus`, `n.v.` oder ein Icon wie `mdi:power-off` anzeigen lassen,  
> je nachdem, was optisch besser zu deinem Dashboard passt.

### Komplettes Beispiel – Grundkachel mit allen Funktionen

Du kannst diese YAML-Vorlage 1:1 in dein Dashboard übernehmen  
und anschließend die Platzhalter (`DEIN_...`) durch deine echten Werte ersetzen.

```yaml
type: custom:button-card
entity: sensor.lxc_DEINCONTAINER_status
name: DEINCONTAINER
icon: mdi:server

show_icon: true
show_name: true

tap_action:
  action: call-service
  service: rest_command.proxmox_lxc_start_DEINCONTAINER

hold_action:
  action: call-service
  service: rest_command.proxmox_lxc_restart_DEINCONTAINER

double_tap_action:
  action: call-service
  service: rest_command.proxmox_lxc_stop_DEINCONTAINER

styles:
  card:
    - border-radius: 12px
    - padding: 12px
    - background-color: >
        [[[ return entity.state === 'running' ? '#64D4E8' : '#999999'; ]]]
    - color: black
  name:
    - font-weight: bold
    - font-size: 16px
  icon:
    - width: 32px
    - height: 32px

custom_fields:
  cpu: >
    [[[ return entity.state === 'running'
         ? states['sensor.netdata_DEINCONTAINER_cpu'].state + ' %'
         : '–'; ]]]
  ram: >
    [[[ return entity.state === 'running'
         ? states['sensor.netdata_DEINCONTAINER_ram'].state + ' %'
         : '–'; ]]]
  web:
    card:
      type: custom:button-card
      icon: mdi:open-in-new
      tap_action:
        action: url
        url_path: "https://DEINCONTAINER.deinedomain.tld"
      styles:
        card:
          - background-color: "#73A1EF"
          - border-radius: 8px
          - padding: 6px
          - height: 36px
          - width: 36px
```

#### Platzhalter zum Ersetzen

| Platzhalter                     | Bedeutung                                          |
|---------------------------------|----------------------------------------------------|
| `DEINCONTAINER`                 | z. B. `nextcloud`, `vaultwarden`, `n8n`, …        |
| `sensor.lxc_DEINCONTAINER_status` | Sensor für Container-Status (aus Free-Kapitel)     |
| `sensor.netdata_DEINCONTAINER_cpu` | Sensor für CPU-Wert aus Netdata                   |
| `sensor.netdata_DEINCONTAINER_ram` | Sensor für RAM-Wert aus Netdata                   |
| `rest_command.proxmox_lxc_start_DEINCONTAINER` | API-Befehl zum Starten (siehe Konfigurations-Teil) |
| `rest_command.proxmox_lxc_stop_DEINCONTAINER` | API-Befehl zum Stoppen                            |
| `rest_command.proxmox_lxc_restart_DEINCONTAINER` | API-Befehl zum Neustarten                         |
| `https://DEINCONTAINER.deinedomain.tld` | URL zur Weboberfläche über Nginx Proxy Manager   |

> [!NOTE]  
> Diese Kachel enthält bereits alle empfohlenen Funktionen.  
> Du kannst sie jetzt für jeden weiteren Dienst duplizieren und nur die Platzhalter anpassen.

### Schritt 6 – Kachel duplizieren und anpassen

Jetzt musst du nicht jede Kachel komplett neu bauen.  
Du nutzt einfach die fertige Kachel von oben als Vorlage,  
duplizierst sie und passt nur die individuellen Werte an.

#### So duplizierst du eine Kachel:

1. Öffne dein **UCC Premium Dashboard** in Home Assistant  
2. Klicke oben rechts auf **Bearbeiten**  
3. Suche die fertige Kachel (z. B. `Nextcloud`)  
4. Klicke auf das **Drei-Punkte-Menü** oben rechts in der Kachel  
5. Wähle **Duplizieren**  
6. Klicke auf das neue Duplikat  
7. Ersetze dort alle Platzhalter durch die Werte deines neuen Containers:

| Bereich      | Was du änderst (Beispiel für `Vaultwarden`)                    |
|--------------|----------------------------------------------------------------|
| `name:`      | `Vaultwarden`                                                  |
| `entity:`    | `sensor.lxc_vaultwarden_status`                                |
| `cpu:`       | `sensor.netdata_vaultwarden_cpu`                               |
| `ram:`       | `sensor.netdata_vaultwarden_ram`                               |
| `rest_command.start`   | `rest_command.proxmox_lxc_start_vaultwarden`         |
| `rest_command.stop`    | `rest_command.proxmox_lxc_stop_vaultwarden`          |
| `rest_command.restart` | `rest_command.proxmox_lxc_restart_vaultwarden`       |
| `url_path:`  | `https://vaultwarden.deinedomain.tld`                          |

#### Wiederhole das für jeden weiteren Container:

- n8n  
- Kopia  
- Home Assistant  
- Pi-hole  
- Affine  
- …und alle anderen UCC-Dienste

> [!TIP]  
> Du musst nur die **Bezeichnungen und Befehle anpassen** –  
> das Grundlayout bleibt gleich. So baust du dein Kontrollzentrum in Minuten fertig.

### Erweiterung einzelner Kacheln

Du hast jetzt eine funktionierende Grundkachel gebaut  
und sie für alle deine Container dupliziert.

Einige Dienste brauchen aber **zusätzliche Funktionen** oder **spezielle Einstellungen**,  
damit du sie optimal über das Dashboard bedienen kannst.

Wir gehen jetzt **Kachel für Kachel** durch  
und zeigen dir **nur die zusätzlichen YAML-Blöcke**,  
die du in der jeweiligen Kachel **ergänzen oder anpassen musst.**

> [!NOTE]  
> Wenn ein Dienst keine Sonderfunktionen hat,  
> bleibt seine Kachel wie du sie vorher dupliziert hast – ganz ohne Änderungen.
und zeigen dir **nur die zusätzlichen YAML-Blöcke**,  
die du in der jeweiligen Kachel **ergänzen oder anpassen musst.**

> [!NOTE]  
> Wenn ein Dienst keine Sonderfunktionen hat,  
> bleibt seine Kachel wie du sie vorher dupliziert hast – ganz ohne Änderungen.

#### Kachel: Proxmox

> [!CAUTION]  
> Diese Kachel ist ein **Spezialfall** und darf **nicht** aus der Grundkachel dupliziert werden!  
> Du verwendest hier **keine API-Steuerung** (starten, stoppen etc.),  
> da sonst die Gefahr besteht, dass du dir versehentlich den Host selbst ausschaltest.

Die Proxmox-Kachel zeigt nur CPU- und RAM-Werte an  
und öffnet bei Klick das Proxmox-Webinterface.  
Sie hat **keine Aktionen zur Steuerung**.

> [!NOTE]  
> Proxmox ist **nicht öffentlich erreichbar**.  
> Du musst eine **lokale IP-Adresse** verwenden, z. B.:

```yaml
tap_action:
  action: url
  url_path: "https://192.168.1.10:8006"
```

#### So passt du die Kachel an:

1. Ersetze in der YAML der Proxmox-Kachel den gesamten Block:
```yaml
tap_action:
  action: call-service
  service: rest_command.proxmox_lxc_start_*
```
durch den lokalen URL-Aufruf oben.

2. Entferne ggf. vorhandene `hold_action` und `double_tap_action`,  
   oder setze sie auf:
```yaml
hold_action:
  action: none
double_tap_action:
  action: none
```

3. Ersetze den `custom_fields:`-Block für CPU und RAM durch:
```yaml
custom_fields:
  cpu: >
    [[[ return states['sensor.netdata_proxmox_cpu'].state + ' %'; ]]]
  ram: >
    [[[ return states['sensor.netdata_proxmox_ram'].state + ' %'; ]]]
```