Homelab--Bratonein-Kontroll…/Kapitel 11/Premium Rohtext.md

# Premium – Simulcast, Aufzeichnung & Multichat mit OvenMediaEngine

Im Free-Kapitel hast du eine funktionsfähige RTMP-Struktur aufgebaut:
OvenMediaEngine (OME) empfängt Streams, leitet sie zuverlässig an eine Plattform weiter und wird über OvenStudio überwacht.
Damit ist die technische Basis gelegt – ein stabiler Streaming-Server, der eigenständig arbeitet.

Im Premium-Teil erweitern wir dieses System zu einer vollwertigen Produktionsumgebung.
Du lernst, wie OME mehrere Plattformen gleichzeitig versorgt, Streams automatisch aufzeichnet und zentral gesteuert wird – ergänzt durch einen lokal gehosteten Multichat, der alle Plattform-Chats in einer Oberfläche zusammenführt.

Das Ziel ist nicht mehr nur „senden können“, sondern **produzieren, überwachen und interagieren** – alles lokal, ohne externe Dienste.

In diesem Kapitel behandeln wir:

1. **Simulcast-Konfiguration**
   Mehrere RTMP-Ausgänge gleichzeitig – Twitch, YouTube, Kick und weitere.
   Effiziente Struktur, Ressourcen-Optimierung und Fehlerabsicherung.

2. **Automatische Aufzeichnung**
   Parallele lokale Mitschnitte aller Streams mit automatischer Ablage und optionalem Upload in Nextcloud.
   N8n sorgt für Kontrolle, Benachrichtigung und Wiederherstellung im Fehlerfall.

3. **Integration mit n8n & Vaultwarden**
   OME-Statusüberwachung, Key-Rotation, automatische Neustarts und sichere Verwaltung aller Zugangsdaten – ohne manuelle Eingriffe.

4. **Multichat-Server (lokal gehostet)**
   Ein zentrales Chat-System bündelt Nachrichten aus Twitch, YouTube und Kick.
   Anzeige direkt in OBS (Dock oder Browserquelle) oder TouchPortal.
   Filter, Moderation und KI-Analyse lassen sich später über n8n erweitern.

> [!NOTE]
> Alle Erweiterungen basieren auf der bestehenden Installation aus dem Free-Kapitel.
> Die dort erstellte Grundkonfiguration bleibt unverändert und wird hier lediglich ergänzt.
> Stelle sicher, dass dein OME-Container betriebsbereit ist, bevor du mit diesem Abschnitt beginnst.

Mit diesen Erweiterungen wird dein RTMP-Server zu einem zentralen Baustein des gesamten UCC-Systems –
eine eigenständige Streaming-Plattform, die Senden, Interaktion und Archivierung vollständig lokal abbildet.

---

## Simulcast – mehrere Plattformen gleichzeitig streamen

Der größte Vorteil von OvenMediaEngine ist die Möglichkeit, dasselbe Eingangssignal gleichzeitig an mehrere Zielplattformen zu senden.
Damit erreichst du Twitch, YouTube, Kick oder jede andere RTMP-fähige Plattform in einem einzigen Durchlauf – ohne externe Dienste wie Restream.io und ohne zusätzliche Cloudkosten.

### Ziel des Abschnitts

Du richtest OME so ein, dass es dein eingehendes RTMP-Signal automatisch an mehrere Ausgänge verteilt.
Jede Plattform erhält denselben Stream, aber mit eigenem Schlüssel und eigener Verbindung.
Die Verteilung erfolgt intern, ohne dass OBS oder dein Encoder mehrfach senden muss.

> [!NOTE]
> Für diesen Abschnitt benötigst du dieselbe OME-Installation wie im Free-Kapitel.
> Es wird lediglich die Konfiguration erweitert.
> Keine Neuinstallation nötig.

> [!IMPORTANT]
> Dein Stream wird nur **ein einziges Mal in OBS** gerendert und anschließend von OME **dupliziert**.
> Das bedeutet: keine zusätzliche CPU- oder GPU-Belastung durch Mehrfach-Streams.
> Dein Encoder arbeitet exakt wie vorher – OME übernimmt die gesamte Verteilung im Hintergrund.

### Schritt 1 – Struktur verstehen

OME arbeitet in Blöcken:
- **Input:** nimmt den Stream von OBS an
- **Application:** verwaltet, was mit dem Signal geschieht
- **Output:** legt fest, wohin es gesendet wird

Im Free-Kapitel hattest du nur **einen Output**.
Jetzt fügst du mehrere hinzu – einen pro Plattform.

Beispielhafte Struktur:

```xml
<Application>
    <Name>live</Name>
    <Output>
        <Target>
            <Type>RTMP</Type>
            <URL>rtmp://live.twitch.tv/app/</URL>
            <StreamKey>TWITCH_KEY</StreamKey>
        </Target>
        <Target>
            <Type>RTMP</Type>
            <URL>rtmp://a.rtmp.youtube.com/live2/</URL>
            <StreamKey>YOUTUBE_KEY</StreamKey>
        </Target>
        <Target>
            <Type>RTMP</Type>
            <URL>rtmp://fa.kick.com/live/</URL>
            <StreamKey>KICK_KEY</StreamKey>
        </Target>
    </Output>
</Application>
```

Jeder dieser **Target-Blöcke** repräsentiert einen eigenen Livestream-Ausgang.
So kannst du beliebig viele Plattformen gleichzeitig bedienen – begrenzt nur durch deine Upload-Bandbreite und CPU-Leistung.

> [!TIP]
> Beginne mit zwei Zielen (z. B. Twitch + YouTube).
> Prüfe die Systemlast, bevor du weitere Ausgänge hinzufügst.
> Ein stabiler Upload ist wichtiger als die Anzahl der Plattformen.

### Schritt 2 – Horizontal und vertikal gleichzeitig senden

Viele Creator streamen parallel im **Querformat (16:9)** für Plattformen wie Twitch oder YouTube und im **Hochformat (9:16)** für TikTok, Shorts oder Reels.
Damit du beide Formate gleichzeitig senden kannst, nutzt du in OBS ein Plugin, das mehrere unabhängige RTMP-Streams erzeugt.

Das empfohlene Plugin heißt **Multiple RTMP Outputs Plugin**.
Es erweitert OBS um zusätzliche Sendeziele, die jeweils eine eigene Szene, Auflösung und Bitrate nutzen können.
So kannst du gleichzeitig horizontal und vertikal streamen – mit nur einer laufenden OBS-Instanz.

#### Einrichtung in OBS

1) Öffne OBS und installiere das Plugin „Multiple RTMP Outputs“.
2) In den Einstellungen erscheint ein neuer Reiter **Multiple Output**.
3) Klicke auf **Add new target**.
4) Gib einen Namen ein, z. B. `Vertical`.
5) Trage folgende Werte ein:
   - **Server:** `rtmp://<IP-deines-OME-Servers>/vertical`
   - **Streamkey:** frei wählbar (z. B. `tiktok`)
   - **Resolution:** 720×1280
   - **FPS:** 30
   - **Bitrate:** 3500–5000 kbps (abhängig von deiner Uploadrate)
6) Wähle im Feld **Video Source** deine vertikale Szene oder dein Hochkant-Layout.
   Du kannst für diesen Stream ein eigenes Szenen-Setup nutzen, unabhängig von der Hauptszene.

In deiner OME-Konfiguration ergänzt du dazu eine zweite Application:

```xml
<Application>
    <Name>vertical</Name>
    <Output>
        <Target>
            <Type>RTMP</Type>
            <URL>rtmp://a.rtmp.tiktok.com/live/</URL>
            <StreamKey>TIKTOK_KEY</StreamKey>
        </Target>
    </Output>
</Application>
```

Damit empfängt OME zwei getrennte Signale:
- `/live` für den klassischen 16:9-Stream
- `/vertical` für den Hochkant-Stream

Beide laufen parallel, werden unabhängig verarbeitet und können an unterschiedliche Plattformen weitergegeben werden.

> [!TIP]
> Wenn du Platz sparen willst, kannst du die vertikale Szene mit geringerer Bitrate streamen.
> Mobile Plattformen benötigen deutlich weniger Bandbreite als YouTube oder Twitch.

---

## Automatische Aufzeichnung (Recording)

Neben der gleichzeitigen Übertragung an mehrere Plattformen kann OvenMediaEngine Streams auch lokal mitschneiden.
Das ist besonders nützlich, wenn du VODs sichern, Highlights schneiden oder Material für Shorts und Reels archivieren willst.
Die Aufnahme erfolgt direkt im OME-Container, ohne dass OBS zusätzlich aufzeichnen muss.

### Ziel des Abschnitts

Du richtest OME so ein, dass alle eingehenden Streams automatisch auf der Server-Seite gespeichert werden.
Jeder Streamlauf erzeugt eine eigenständige Videodatei im gewünschten Format.
So bleibt jedes Live-Event vollständig erhalten, unabhängig von Plattformen oder VOD-Beschränkungen.

> [!NOTE]
> Die Aufzeichnung geschieht serverseitig.
> Dein Encoder sendet weiterhin nur einen Stream – OME übernimmt die Speicherung automatisch.
> Damit wird dein System weniger belastet als bei gleichzeitiger Aufnahme in OBS.

### Schritt 1 – Aufnahme aktivieren

Die Funktion wird in der **Server.xml** innerhalb der jeweiligen Application definiert.
Unterhalb deines `<Application>`-Blocks fügst du einen Recording-Abschnitt ein:

```xml
<Application>
    <Name>live</Name>
    <Recording>
        <Path>/data/recordings/</Path>
        <Format>mp4</Format>
        <SegmentDuration>3600</SegmentDuration>
        <AutoStart>true</AutoStart>
    </Recording>
    <Output>
        ...
    </Output>
</Application>
```

**Erläuterung:**
- **Path** – Zielordner für alle Aufnahmen (muss existieren und Schreibrechte haben)
- **Format** – Containerformat der Datei (`mp4`, `mkv` oder `flv`)
- **SegmentDuration** – Dauer eines Abschnitts in Sekunden (3600 = 1 Stunde)
- **AutoStart** – startet die Aufnahme automatisch, sobald der Stream eingeht

> [!TIP]
> Wenn du lieber manuell startest, setze `AutoStart` auf `false`.
> Du kannst die Aufnahme dann über OvenStudio per Klick aktivieren.

### Schritt 2 – Speicherort und Rechte prüfen

Standardmäßig ist `/data/recordings/` ein interner Ordner im Container.
Du kannst ihn über eine gemountete Proxmox-Disk oder ein NFS-Share mit größerem Speicherplatz verbinden.
Prüfe anschließend, ob Schreibrechte vorhanden sind:

```bash
ls -ld /data/recordings/
```

Die Ausgabe sollte `drwxrwxr-x` oder ähnlich zeigen.
Wenn nicht, Rechte anpassen:

```bash
chmod 775 /data/recordings/
```

> [!NOTE]
> Für produktive Systeme empfiehlt sich ein separater Datenträger oder ein Mount-Punkt auf deinem Storage-Server.
> So verhinderst du, dass dein Container durch Aufnahmen vollläuft.

### Schritt 3 – Aufnahme testen

1) Starte einen Test-Stream über OBS an deinen OME-Input (`/live`).
2) Warte 10–20 Sekunden, bis OME die Session registriert.
3) Öffne den Aufnahmeordner und prüfe, ob dort eine Datei erstellt wird, z. B.
   ```
   /data/recordings/live_2025-10-13_20-00-00.mp4
   ```
4) Stoppe den Stream – OME schließt die Datei automatisch sauber ab.

Wenn die Datei korrekt abgespielt werden kann, funktioniert die Aufzeichnung.

> [!TIP]
> Kontrolliere regelmäßig die Speicherbelegung.
> OME löscht alte Aufnahmen nicht automatisch.

### Schritt 4 – Automatische Verwaltung mit n8n

Ziel dieses Abschnitts:
Aufnahmen aus dem OvenMediaEngine-Container automatisch sichern, übertragen und anschließend löschen.
Die Automatisierung erfolgt mit n8n über SFTP, da OME und n8n in getrennten LXC-Containern laufen.
So bleibt der Aufnahme-Container schlank und deine VODs landen automatisch im Archiv (z. B. Nextcloud oder Storage-LXC).

> [!NOTE]
> Dieser Abschnitt setzt kein Admin-Wissen voraus.
> Du kannst alle Befehle exakt so kopieren und im Container ausführen.
> Wir verwenden den Benutzer `transfer` und Port 22.

### Vorbereitung – SFTP-Verbindung zwischen OME und n8n herstellen

#### 1. SSH und Benutzer im OME-Container aktivieren

```bash
pct enter <ID_OME>
apt install openssh-server -y
adduser transfer
systemctl enable --now ssh
```

Passwort vergeben und bestätigen.
IP ermitteln:

```bash
ip a
```

Beispiel: `10.0.0.152`
Testen:

```bash
sftp transfer@10.0.0.152
```

Wenn das Login funktioniert, ist die Verbindung aktiv.

> [!TIP]
> Falls SSH nicht installiert ist: `apt install openssh-server -y`

#### 2. Aufnahme-Ordner freigeben

```bash
chown -R transfer:transfer /data/recordings
chmod 755 /data/recordings
```

Der Benutzer *transfer* darf lesen und schreiben, aber keine Systemänderungen vornehmen.

#### 3. SFTP-Credential in n8n anlegen

| Feld | Wert |
|------|------|
| Host | 10.0.0.152 |
| Port | 22 |
| Username | transfer |
| Password | (dein Passwort) |
| Protocol | SFTP |
| Host Fingerprint Check | deaktiviert (optional) |

Speichern → **Test Connection** → Success.

> [!NOTE]
> Optional kannst du stattdessen SSH-Keys nutzen
> (`/home/transfer/.ssh/authorized_keys`).

### Workflow-Überblick

1. Schedule Trigger – Startzeit definieren
2. SFTP – List – Dateien anzeigen
3. SFTP – Download – Datei holen
4. Nextcloud – Upload File – Archivierung
5. If Node – Upload-Erfolg prüfen
6. SFTP – Delete – Original löschen
7. Discord – Send Message – Benachrichtigung

👉 Screenshot geeignet: *n8n-Workflow mit 7 Nodes, beginnend bei Schedule Trigger.*

### Schritt 1 – Schedule Trigger

| Feld | Wert |
|------|------|
| Trigger | Every day |
| Time | 03:00 |
| Timezone | Europe/Berlin |

Dieser Node startet den Workflow einmal pro Nacht.

### Schritt 2 – SFTP (List Files)

| Feld | Wert |
|------|------|
| Operation | List |
| Remote Path | `/data/recordings` |
| Recursive | false |
| Return All | true |
| Credential | `sftp_ome` |

> [!NOTE]
> Dieser Node liefert `name`, `path`, `size`, `modifiedAt`.

### Schritt 3 – SFTP (Download File)

| Feld | Wert |
|------|------|
| Operation | Download |
| Remote Path | `={{ $json.path }}` |
| Binary Property | `data` |
| Credential | `sftp_ome` |

Der Node speichert die Datei als Binary-Objekt `binary.data`.

### Schritt 4 – Nextcloud (Upload File)

| Feld | Wert |
|------|------|
| Resource | File |
| Operation | Upload |
| Use Binary Data | true |
| Binary Property | `data` |
| Folder Path | `/UCC/Recordings/` |
| File Name | `={{ $json.name }}` |
| Credential | `nextcloud_main` |

> [!TIP]
> Dynamische Unterordner: `/UCC/Recordings/{{ $json.path.split('/').slice(-2, -1)[0] }}/`

### Schritt 5 – If (Upload erfolgreich?)

| Feld | Wert |
|------|------|
| Mode | All rules must match |
| Value 1 | `={{ $json.fileId || $json.id }}` |
| Operation | Is empty |
| Negate | true |

**TRUE** = Upload ok → weiter zu Delete
**FALSE** = Fehler → stoppt Workflow

### Schritt 6 – SFTP (Delete File) (optional)

| Feld | Wert |
|------|------|
| Operation | Delete |
| Remote Path | `={{ $json.path }}` |
| Credential | `sftp_ome` |

> [!TIP]
> Falls der Delete-Node keinen Pfad sieht, verwende einen Merge-Node (Mode: Pass-Through) zwischen Download und Upload, damit Metadaten erhalten bleiben.

### Schritt 7 – Discord (Send Message) (optional)

| Feld | Wert |
|------|------|
| Resource | Message |
| Operation | Create |
| Channel ID | `123456789012345678` |
| Text | `=🎥 Upload abgeschlossen: {{$json.name}} → /Recordings` |
| Credential | `discord_bot_main` |

### Troubleshooting & Tipps

> [!NOTE]
> **Keine Dateien gefunden:** Pfad im SFTP-Node prüfen, Benutzerrechte kontrollieren (`ls -la /data/recordings`).
> **Upload fehlschlägt:** „Use Binary Data“ aktiv, Zielordner in Nextcloud existiert.
> **Delete funktioniert nicht:** Pfad fehlt → Merge Node zwischen Download und Upload setzen.
> **SFTP-Verbindung scheitert:** Port 22 offen, SSH-Dienst aktiv, Credential testen.
> **Laufende Aufnahmen:** Filter im SFTP-List-Node verwenden (`Modified Before = Now – 10 min`).

Mit dieser Automatisierung werden alle neuen Aufnahmen nachts gesichert, optional gelöscht und du wirst über Discord benachrichtigt.
Der gesamte Prozess läuft serverseitig und vollständig autonom.

---

## Multichat – Social Stream Ninja

Im Gegensatz zu vielen anderen unserer Systeme gibt es aktuell keine Lösung, mit der sich eine vollwertige Multichat-Plattform vollständig lokal (headless) hosten lässt.
Bis unsere eigene Umgebung fertig ist, setzen wir bewusst auf **Social Stream Ninja (SSN)**. SSN bündelt Chats mehrerer Plattformen in einer Oberfläche, bietet Moderation und stellt Links bereit, die wir in OBS als Dock einbinden können.

> [!NOTE]
> SSN ist eine Desktop-App (Windows, macOS, Linux). Unter Linux ist eine grafische Umgebung nötig. Ein Betrieb in einem LXC ohne GUI ist nicht sinnvoll.

## Installation

1. Lade die aktuelle Version von SSN:
   https://github.com/steveseguin/ssn_app/releases
2. Installiere die Anwendung oder entpacke das Archiv.
3. Starte **Social Stream Ninja**.
4. Verbinde in der Oberfläche die benötigten Plattformen (z. B. Twitch, YouTube, Kick, Facebook – je nach Verfügbarkeit).
5. Nach erfolgreicher Anmeldung erscheinen eingehende Nachrichten gesammelt im Hauptfenster.

> [!TIP]
> SSN speichert deine Verbindungen. Beim nächsten Start sind die Plattformen wieder aktiv, bis du sie trennst.

## Integration in OBS und TouchPortal

Für unser Setup nutzen wir primär das **Dock** in OBS (Moderation/Lesen in OBS). Das Overlay (reine Anzeige) ist optional.

### OBS – Multichat als Dock einbinden

1. Öffne in SSN die **Dock / Moderator View**.
2. Kopiere die **Dock-URL** (Beispiel):
   ```
   http://localhost:8090/dock
   ```
3. In **OBS**: **Ansicht → Docks → Benutzerdefiniertes Browser-Dock**.
4. Namen vergeben (z. B. `Multichat`) und die Dock-URL einfügen.
5. Mit **OK** bestätigen und das Dock andocken/platzieren.
6. Neue Nachrichten erscheinen nun direkt im OBS-Dock.

> [!NOTE]
> SSN muss im Hintergrund aktiv bleiben, sonst aktualisiert sich das Dock nicht. Dein Videostream wird weiterhin **nur einmal** in OBS gerendert; das Dock ist reine Chat-UI.

> [!TIP]
> Du kannst mehrere Docks anlegen (z. B. `Alle`, `Twitch`, `YouTube`) – SSN bietet dafür Filter/Parameter in der URL (falls vorhanden).

### TouchPortal – Chat mobil anzeigen

TouchPortal kann keine OBS-Browserquelle übernehmen. Zwei praktikable Varianten:

**Variante A – Einfach (Browser auf dem Tablet/Phone)**
1. Tablet/Phone im selben Netzwerk wie der SSN-Rechner.
2. Im mobilen Browser die **Dock- oder Overlay-URL** öffnen:
   ```
   http://<deine-ip>:8090/dock
   ```
3. Seite im Vordergrund lassen (Bildschirmsperre deaktivieren).

**Variante B – TouchPortal mit WebView**
1. In TouchPortal ein **WebView-Plugin** installieren (Community-Plugin).
2. Eine Seite anlegen und ein **WebView-Element** hinzufügen.
3. SSN-URL eintragen (z. B. `http://<deine-ip>:8090/dock`) und speichern.

> [!NOTE]
> Je nach TouchPortal-Version/Plugin können Emojis/Animationen eingeschränkt sein. Wenn es ruckelt, nutze Variante A (Browser).

## Betrieb und Leistung

- SSN basiert auf Electron und benötigt RAM/CPU. Parallel zu OBS sind **8 GB RAM** Gesamtsystem als Untergrenze sinnvoll.
- Halte Emote-Animationen und visuelle Effekte moderat, wenn das System knapp ist.
- Lege das Moderations-Dock idealerweise auf ein Zweitgerät (Tablet/Notebook), um den Streaming-PC zu entlasten.

## Fehlerbehebung (kurz)

- **Dock leer:** SSN nicht aktiv oder Plattform abgemeldet → SSN öffnen, Verbindungen prüfen, Dock in OBS neu laden.
- **TouchPortal zeigt nichts:** IP prüfen, gleiches Netz sicherstellen, `localhost` durch lokale IP ersetzen.
- **Zäh/träge:** Effekte/Emotes in SSN reduzieren; nur ein Dock auf dem Streaming-PC offen halten.
- **HTTPS-Warnung:** Lokal mit `http://<ip>:port` arbeiten oder ein gültiges Zertifikat bereitstellen, wenn du per Domain zugreifst.

## Zusammenfassung

- SSN vereint mehrere Chats in einer Oberfläche und liefert eine Dock-URL für OBS.
- TouchPortal zeigt dieselbe URL im Browser oder per WebView.
- Der Stream wird weiterhin nur in OBS gerendert; SSN ist reine Chat-Bedienung/Anzeige.