# 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
live
```
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:///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
vertical
```
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 ``-Blocks fügst du einen Recording-Abschnitt ein:
```xml
live
/data/recordings/
mp4
3600
true
```
**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
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.