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

# Kapitel 11 – RTMP (Free)

## Einleitung

Mit der **Open Media Engine (OME)** richtest du deinen eigenen Streaming-Server ein, der als zentrale Verteilstation für Livestreams dient.  
Er empfängt das Signal direkt aus **OBS** oder einer anderen Streaming-Software und leitet es an beliebige Plattformen weiter – etwa **Twitch**, **YouTube**, **Kick** oder interne Aufzeichnungs-Server.  
Damit hast du die volle Kontrolle über deinen Stream-Output, unabhängig von Drittanbietern wie Restream.io oder kostenpflichtigen Cloud-Diensten.

OME ist ein leistungsfähiger, quelloffener RTMP-Server, der mehrere Protokolle unterstützt (RTMP, SRT, WebRTC, LL-HLS) und für niedrige Latenzen optimiert ist.  
In Kombination mit **Oven Studio**, der offiziellen Weboberfläche von OvenMediaEngine, erhältst du eine minimalistische, browserbasierte GUI zur **Überwachung** und **Grundsteuerung** deiner Streams.  
Damit kannst du jederzeit sehen, welche Inputs und Outputs aktiv sind, Bitraten und Sitzungen prüfen oder einzelne Sessions gezielt trennen – ohne die Gefahr, Konfigurationen zu beschädigen.

> [!NOTE]  
> Oven Studio ist optional, aber für die Überwachung im Alltag sehr praktisch.  
> Es bietet dir eine einfache grafische Ansicht aller laufenden Streams, ist ressourcenschonend und läuft direkt über den integrierten Webserver von OME.

Das Ziel dieses Kapitels ist es, dir eine stabile RTMP-Infrastruktur aufzubauen, die dauerhaft im Hintergrund läuft und ohne Wartung auskommt.  
Du lernst:
- die Installation und Grundkonfiguration von OME in einem dedizierten LXC-Container,  
- die Einrichtung der Weboberfläche **Oven Studio**,  
- die Einbindung über den **Nginx Proxy Manager** mit eigener Subdomain und HTTPS,  
- und die erste erfolgreiche Verbindung aus **OBS** zu deinem Server.  

Damit legst du die Grundlage, um deine Streams selbst zu verteilen oder auf mehreren Plattformen gleichzeitig zu senden – unabhängig, sicher und vollständig lokal.  
Dieses Kapitel bleibt bei den Grundlagen und beschränkt sich auf den Free-Teil: Aufbau, Installation und Überwachung.  
Erweiterte Themen wie **Simulcast-Routing**, **automatische Aufzeichnung**, **n8n-Integration** oder **Plattformsteuerung** folgen später im Premium-Kapitel.

> [!TIP]  
> Dieses Setup funktioniert vollständig autark.  
> Wenn du OME nur lokal oder intern für Testzwecke betreibst, kannst du den Zugriff auch auf dein LAN beschränken.  
> Die Anleitung bleibt identisch – du musst lediglich im Proxy Manager die Domain-Regeln anpassen.

---

## Voraussetzungen & Ressourcen

Bevor du mit der Installation beginnst, stelle sicher, dass dein System korrekt vorbereitet ist.  
Dieser Abschnitt beschreibt, was du vor dem Start von OME bereitstellen oder prüfen solltest.

### Container-Ressourcen

* **CPU: 2 vCPUs**  
  Zwei virtuelle Kerne reichen für die Grundkonfiguration und erste Tests.  
  Wenn du später mehrere Streams gleichzeitig verarbeitest, kann die Anzahl problemlos erhöht werden.

* **RAM: 2 GB**  
  Für den normalen Betrieb ausreichend.  
  Bei gleichzeitiger Aufzeichnung oder mehreren Eingängen sind 4 GB sinnvoll.

* **Speicherplatz: 10 GB**  
  Genügend Platz für Installation, Logs und temporäre Daten.  
  Falls du Streams speichern möchtest, plane zusätzlichen Speicher ein.

* **Betriebssystem: Ubuntu 24.04 LTS (64-Bit)**  
  Dieses System bietet aktuelle Pakete und eignet sich gut für die direkte Installation ohne Docker.

* **Netzwerk: Feste IP-Adresse oder DHCP-Reservierung**  
  Damit bleibt der Container dauerhaft unter derselben Adresse erreichbar und lässt sich später sauber über den Proxy einbinden.

> [!TIP]  
> Plane beim Erstellen des Containers kleine Leistungsreserven ein.  
> Ein stabiler Echtzeit-Stream benötigt konstante CPU-Leistung und reagiert empfindlich auf Engpässe.

### Technische Voraussetzungen

* **Proxmox** ist eingerichtet und erreichbar.  
  Der Container wird dort erstellt und verwaltet.

* **Grundstruktur** (Proxy Manager, Domain oder DynDNS) aus den vorangegangenen Kapiteln ist vorbereitet.  
  Sie wird im Verlauf für die Einbindung und Zertifikate benötigt.

* **OBS oder vergleichbare Streaming-Software** ist auf deinem Arbeitsplatz installiert.  
  OME empfängt und verteilt nur das Signal – es erzeugt selbst keinen Stream.

* **Zugriff auf das Container-Terminal** ist vorhanden, entweder über die Proxmox-Konsole oder per SSH.

> [!IMPORTANT]  
> Wenn du OME nur im lokalen Netzwerk verwenden möchtest, ist keine Domain erforderlich.  
> In diesem Fall kann die spätere Proxy-Einbindung übersprungen oder auf lokale Adressen angepasst werden.

---

## Schritt-für-Schritt-Anleitung

In diesem Abschnitt installierst du die **Open Media Engine (OME)** in einem eigenen Container.  
Wir richten das System so ein, dass es stabil läuft und später problemlos in den Proxy Manager eingebunden werden kann.  
Alle Befehle sind so gewählt, dass sie direkt übernommen werden können, ohne Anpassung oder Vorwissen.

### Schritt 1 – Grundsystem aktualisieren

Öffne in **Proxmox** die Shell des OME-Containers und bringe das System auf den neuesten Stand:

```bash
apt update && apt upgrade -y
reboot
```

> [!NOTE]  
> Auch bei frisch erstellten Containern unbedingt ausführen.  
> Ein aktuelles System vermeidet spätere Paket- und Abhängigkeitsprobleme.

### Schritt 2 – Basisabhängigkeiten installieren

Nach dem Neustart erneut in den Container einloggen und die benötigten Systempakete installieren.  
Diese sind erforderlich, damit OME später kompiliert und ausgeführt werden kann.

```bash
apt install -y git build-essential cmake pkg-config libssl-dev libcurl4-openssl-dev libasound2-dev
```

> [!NOTE]  
> Diese Pakete stellen sicher, dass alle Abhängigkeiten für Netzwerk, SSL und Medienverarbeitung vorhanden sind.  
> Ohne sie kann der spätere Build-Vorgang fehlschlagen.

### Schritt 3 – OvenMediaEngine herunterladen

Lade die aktuelle stabile Version direkt von GitHub herunter und entpacke sie.  
So vermeidest du unnötige Git-Abhängigkeiten und erhältst eine saubere, reproduzierbare Version.

```bash
cd /opt
curl -L https://github.com/AirenSoft/OvenMediaEngine/archive/refs/tags/v0.19.0.tar.gz -o ome.tar.gz
tar -xzf ome.tar.gz
mv OvenMediaEngine-0.19.0 ome
cd ome
```

> [!NOTE]  
> Wenn auf GitHub eine neuere Version verfügbar ist, kann die Zahl `v0.19.0` entsprechend angepasst werden.  
> Achte darauf, die gleiche Versionsnummer in allen folgenden Schritten zu verwenden.

### Schritt 4 – OME kompilieren und installieren

Wechsle in den Ordner mit dem entpackten Programm und starte den Aufbau von OME.  
Das dauert ein paar Minuten, je nach Leistung deines Servers.

```bash
cd /opt/ome
mkdir build
cd build
cmake ..
make -j$(nproc)
make install
```

> [!NOTE]  
> Während der Installation erscheinen viele Zeilen im Terminal – das ist normal.  
> Sobald keine Fehlermeldung mehr ausgegeben wird und der Cursor wieder frei ist, wurde OME erfolgreich installiert.

### Schritt 5 – Dienst einrichten

Damit OME automatisch startet, sobald der Container hochfährt, legen wir einen eigenen Systemdienst an.

```bash
nano /etc/systemd/system/ome.service
```

Füge folgenden Inhalt ein:

```
[Unit]
Description=OvenMediaEngine
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/OvenMediaEngine -c /usr/local/etc/OvenMediaEngine
Restart=on-failure
User=root
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
```

Datei speichern (**Strg + O**, **Enter**, **Strg + X**) und aktivieren:

```bash
systemctl daemon-reload
systemctl enable ome
systemctl start ome
```

> [!TIP]  
> Den aktuellen Status kannst du mit `systemctl status ome` prüfen.  
> Wenn dort „active (running)“ steht, läuft der Dienst korrekt.

### Schritt 6 – Weboberfläche (OvenStudio) aktivieren

OME bringt eine eigene schlanke Weboberfläche namens **OvenStudio** mit.  
Damit kannst du Streams und Ausgaben direkt im Browser überwachen.

1) Öffne die Konfigurationsdatei:
   ```bash
   nano /usr/local/etc/OvenMediaEngine/Server.xml
   ```

2) Suche den Abschnitt `<WebRTC>` und aktiviere dort den Eintrag für das **Dashboard**.  
   In neueren Versionen ist er standardmäßig vorhanden, muss aber auf „enabled“ gesetzt werden:

   ```xml
   <Dashboard>
       <Enable>true</Enable>
       <Port>8081</Port>
   </Dashboard>
   ```

3) Datei speichern und OME neu starten:
   ```bash
   systemctl restart ome
   ```

> [!NOTE]  
> Nach dem Neustart kannst du im Browser `http://<IP-des-Containers>:8081` öffnen.  
> Wenn die Oberfläche erscheint, ist OvenStudio aktiv und bereit für die Proxy-Einbindung im nächsten Schritt.

### Schritt 7 – Einbindung in Nginx Proxy Manager

Damit du die Oberfläche und Streams sicher über HTTPS erreichst, wird OME jetzt in den **Nginx Proxy Manager** eingebunden.

1) Öffne das NPM-Dashboard.  
2) Klicke auf **Add Proxy Host**.  
3) Trage folgende Werte ein:

| Feld | Wert |
|------|------|
| **Domain Names** | `stream.deinedomain.tld` |
| **Scheme** | `http` |
| **Forward Hostname / IP** | IP-Adresse des OME-Containers |
| **Forward Port** | `8081` |
| **Block Common Exploits** | aktivieren |
| **Websockets Support** | aktivieren |

4) Wechsle zum Reiter **SSL** und setze:  
   - **Request a new SSL Certificate** → aktivieren  
   - **Force SSL** → aktivieren  
   - **HTTP/2 Support** → aktivieren

5) **Save** klicken.  
   Nach kurzer Zeit ist OME unter `https://stream.deinedomain.tld` erreichbar.

> [!TIP]  
> Wenn du OME nur im Heimnetz nutzt, kannst du diesen Schritt überspringen und die Oberfläche direkt über `http://<IP>:8081` öffnen.

### Schritt 8 – Funktionstest

Zum Abschluss prüfen wir, ob der Server korrekt läuft und Streams entgegennimmt.

1) **Browser öffnen**  
   Rufe deine Subdomain oder lokale Adresse auf, z. B.  
   `https://stream.deinedomain.tld`  
   oder  
   `http://<IP-des-Containers>:8081`

2) **Dashboard prüfen**  
   Es sollte die OvenStudio-Oberfläche erscheinen.  
   Dort siehst du aktive Eingänge, Ausgänge und grundlegende Statusinformationen.

3) **Teststream senden**  
   Öffne in **OBS** die Einstellungen → **Stream**  
   - **Server:** `rtmp://<deine-domain-oder-ip>/app`  
   - **Stream Key:** frei wählbar (z. B. `test`)  

   Starte den Stream in OBS.  
   Wenn alles korrekt eingerichtet ist, erscheint er wenige Sekunden später im OvenStudio-Dashboard.

> [!NOTE]  
> Sollte kein Bild erscheinen, prüfe zuerst die RTMP-URL und ob die Firewall im Container deaktiviert ist.  
> Nach erfolgreichem Test kannst du den Stream beenden und OME für dein Projekt konfigurieren.

---

## OME konfigurieren

Nach der Installation läuft OME bereits im Hintergrund und kann Streams entgegennehmen,  
leitet sie aber noch nicht weiter. In diesem Abschnitt lernst du,  
wie du eigene Anwendungen und Ausgänge definierst – also festlegst,  
**woher** OME das Signal bekommt und **wohin** es gesendet werden soll.

### Grundprinzip

OME arbeitet nach einem klaren Schema:

```
Application → Input → Output
```

Das bedeutet:
- Eine **Application** ist dein logischer Kanal – z. B. „live“, „event“ oder „studio“.  
- Ein **Input** legt fest, wie das Signal zu OME gelangt (RTMP, SRT usw.).  
- Ein **Output** bestimmt, wohin OME den Stream weiterleitet (z. B. Twitch, YouTube, Kick).

### Oberfläche vs. Konfiguration

Die **Weboberfläche OvenStudio** dient ausschließlich der **Überwachung**.  
Du kannst dort sehen:
- welche Streams aktiv sind,  
- welche Plattformen verbunden sind,  
- und ob Daten ankommen bzw. gesendet werden.

Du kannst dort jedoch **nichts ändern oder hinzufügen**.  
OvenStudio schreibt keine Dateien und hat keinen Editor für Einstellungen.  
Alle Verbindungen und Plattformen werden ausschließlich über die Konfigurationsdatei **`Server.xml`** verwaltet.

> [!IMPORTANT]  
> OvenStudio zeigt dir nur an, was in der `Server.xml` hinterlegt ist.  
> Wenn du eine neue Plattform hinzufügen willst, musst du diese Datei manuell bearbeiten.  
> Nach einem Neustart liest OME die Änderungen automatisch ein und zeigt sie im Dashboard an.

### Aufbau der Konfiguration

Die zentrale Datei findest du hier:

```bash
/usr/local/etc/OvenMediaEngine/Server.xml
```

Darin sind alle Programme und Ziele in sogenannten *Virtual Hosts* angelegt.  
Ein einzelner Host kann mehrere Anwendungen enthalten – zum Beispiel eine für dein Live-Programm und eine für Tests.

Öffne die Datei mit einem Texteditor (z. B. `nano` oder `vim`)  
oder übertrage sie per SFTP, wenn du sie lieber lokal bearbeiten möchtest.

### Beispielkonfiguration

Das folgende Beispiel zeigt eine einfache Standard-Umgebung,  
die RTMP-Signale aus OBS annimmt und an Twitch weiterleitet.

```xml
<VirtualHost>
    <Name>default</Name>

    <Applications>
        <Application>
            <Name>live</Name>            <!-- App-Name: Wird in OBS verwendet -->
            <Input>
                <Profile>rtmp</Profile>  <!-- Eingang: RTMP-Streams -->
            </Input>

            <Outputs>
                <Output>
                    <Type>RTMP</Type>    <!-- Ausgangsprotokoll -->
                    <URL>rtmp://live.twitch.tv/app/</URL>  <!-- Twitch-Ingest -->
                    <StreamKey>DEIN_TWITCH_KEY</StreamKey> <!-- Twitch-Streamkey -->
                </Output>
            </Outputs>
        </Application>
    </Applications>
</VirtualHost>
```

#### Bedeutung der einzelnen Bereiche

| Abschnitt | Beschreibung |
|------------|--------------|
| `<VirtualHost>` | Oberste Ebene. Enthält alle Apps und Ausgänge. |
| `<Application>` | Definiert einen Stream-Kanal. Der Name muss zu dem passen, was du in OBS angibst (z. B. `rtmp://ip/live`). |
| `<Input>` | Bestimmt, welche Art von Stream angenommen wird (z. B. RTMP). |
| `<Outputs>` | Legt fest, wohin das Signal gesendet wird. Hier kannst du mehrere Ziele hintereinander definieren. |
| `<URL>` | Zieladresse der Plattform (Twitch, YouTube usw.). |
| `<StreamKey>` | Dein persönlicher Sendeschlüssel, wie in OBS. |

> [!NOTE]  
> Die Datei kann beliebig viele `<Output>`-Blöcke enthalten, wenn du an mehrere Plattformen gleichzeitig streamen willst.

### Konfiguration aktivieren

Nach dem Speichern (Strg + O, Enter, Strg + X) muss OME neu gestartet werden,  
damit die Änderungen übernommen werden.

#### Über die Oberfläche (empfohlen)

1) Öffne die Weboberfläche `http://<IP-des-Containers>:8081`  
2) Klicke oben rechts auf **Server → Restart**  
3) Nach etwa 10 Sekunden lädt OME neu und liest die geänderte Konfiguration ein.  
   Das Dashboard ist danach wieder verfügbar.

#### Alternativ über Konsole

```bash
systemctl restart ome
```

> [!TIP]  
> Beide Varianten führen zum gleichen Ergebnis.  
> Die Oberfläche eignet sich, wenn du kein Terminal verwenden möchtest.

### Kontrolle in der GUI

Nach dem Neustart öffne das **OvenStudio-Dashboard** erneut.  
Unter **Applications** siehst du jetzt deinen neuen Kanal („live“).  
Wenn du in **OBS** einen Stream mit `rtmp://<IP>/live` startest,  
erscheint dort automatisch ein Eintrag unter **Inputs**.  
Sobald OME das Signal weiterleitet, erscheinen zusätzlich deine **Outputs**,  
z. B. *Twitch*, *YouTube* oder *Kick*, mit Status, Bitrate und Verbindung.

Damit ist OME konfiguriert und betriebsbereit.  
Du sendest wie gewohnt über OBS – OME empfängt das Signal,  
und verteilt es automatisch an alle in der Konfiguration hinterlegten Plattformen.

#### Streamkeys der Plattformen abrufen

Damit OME sich bei den Plattformen authentifizieren kann,  
benötigst du für jeden Ausgang den passenden **Streamkey**.  
Dieser Schlüssel ist für jedes Konto eindeutig und darf niemals veröffentlicht werden.

##### Twitch
1) Gehe zu [https://dashboard.twitch.tv/](https://dashboard.twitch.tv/)  
2) Öffne **Einstellungen → Stream**  
3) Unter **Primärer Streamschlüssel** auf **Kopieren** klicken  
4) Den Key in der `Server.xml` im Feld `<StreamKey>` einfügen

> [!TIP]  
> Wenn du auf mehreren Twitch-Kanälen streamst, kannst du pro Account einen eigenen `<Output>`-Block mit unterschiedlichem Key anlegen.

##### YouTube
1) Öffne [https://studio.youtube.com/](https://studio.youtube.com/)  
2) Klicke links auf **Stream → Livestream erstellen**  
3) Unter **Streamschlüssel** auf **Kopieren**  
4) In der `Server.xml` als `<StreamKey>` hinterlegen  
   (z. B. zusammen mit `rtmp://a.rtmp.youtube.com/live2/` als URL)

> [!NOTE]  
> Bei YouTube kann der Key entweder dauerhaft oder pro Stream neu erzeugt werden.  
> Für den automatischen Betrieb empfiehlt sich ein **permanenter Schlüssel**.

##### Kick
1) Gehe zu [https://kick.com/dashboard/stream](https://kick.com/dashboard/stream)  
2) Im Bereich **Stream Key & Server URL** → **Kopieren**  
3) URL und Key in der `Server.xml` eintragen:  
   ```xml
   <URL>rtmp://fa.kick.com/live/</URL>
   <StreamKey>DEIN_KEY</StreamKey>
   ```

> [!WARNING]  
> Diese Keys sind vertraulich.  
> Wer Zugriff darauf hat, kann ohne weiteres in deinem Namen streamen.  
> Speichere die Datei daher niemals öffentlich oder in geteilten Cloud-Ordnern.

Nach dem Einfügen der Keys speichere die Datei,  
führe den Neustart wie oben beschrieben durch  
und überprüfe in OvenStudio, ob die Ausgänge korrekt erscheinen.

---

## Troubleshooting & Tipps

Auch wenn OvenMediaEngine (OME) im Normalbetrieb sehr stabil läuft, kann es nach der Erstinstallation zu kleineren Problemen kommen.  
Die häufigsten Ursachen und Lösungen sind hier zusammengefasst – klar, nachvollziehbar und ohne unnötige Komplexität.

### Oberfläche nicht erreichbar

Wenn die Weboberfläche (OvenStudio) nach dem Start nicht lädt oder der Browser keine Verbindung bekommt:

1) Im Proxmox prüfen, ob der Container läuft.  
   Falls nicht → **Start** klicken.  
2) In der Konsole prüfen, ob OME aktiv ist:  
   ```bash
   systemctl status ome
   ```  
   Wenn der Dienst „inactive“ ist, mit  
   ```bash
   systemctl restart ome
   ```  
   neu starten.  
3) Testweise direkt aufrufen:  
   `http://<Container-IP>:8081`  
   Wenn das funktioniert, liegt das Problem am Proxy-Eintrag oder am Zertifikat.  

> [!TIP]  
> Nach einem Neustart benötigt OME bis zu 15 Sekunden, bevor OvenStudio wieder erreichbar ist.  
> Geduld bewahren – es lädt nicht sofort.

### Kein Stream sichtbar

Wenn du in OBS auf „Stream starten“ klickst, aber in OvenStudio kein Signal erscheint:

1) In OBS prüfen, ob  
   - der **Server** auf `rtmp://<deine-IP>/live` steht  
   - und der **Streamkey** nicht leer ist.  
2) In der XML-Konfiguration sicherstellen, dass der App-Name exakt `live` heißt.  
3) In OvenStudio prüfen, ob der Input auftaucht, sobald OBS läuft.

> [!NOTE]  
> OME listet Streams erst, wenn tatsächlich ein Signal ankommt.  
> Ein paar Sekunden Verzögerung sind normal.

### Kein Weiterleiten zu Twitch, YouTube oder Kick

Wenn OME den Stream annimmt, aber keine Verbindung zu den Zielplattformen aufbaut:

1) Prüfe in OvenStudio, ob die Ausgänge aktiv sind.  
   Wenn sie grau bleiben, fehlen meist falsche Keys oder URLs.  
2) Öffne die `Server.xml` über SFTP oder den integrierten Editor.  
   - Kontrolliere die Einträge `<URL>` und `<StreamKey>`  
   - Vergleiche sie mit den aktuellen Angaben der Plattform.  
3) Speichere die Datei und starte OME neu über **Server → Restart** im OvenStudio-Menü.

> [!TIP]  
> Streamkeys ändern sich oft nach Passwort- oder Kontoänderungen.  
> Wenn plötzlich keine Verbindung mehr entsteht, ist das fast immer die Ursache.

### Kein Bild oder kein Ton

Wenn OME den Stream erkennt, aber im Dashboard kein Video oder Audio zeigt:

1) In OBS sicherstellen:  
   - **Videocodec:** H.264  
   - **Audiocodec:** AAC  
   - **Containerformat:** FLV (Standard)  
2) In OvenStudio das Signal unter **Inputs** öffnen und prüfen, ob Bitrate und Auflösung angezeigt werden.  
3) Wenn nur Ton oder nur Bild übertragen wird, kurz **Stream stoppen** und **neu starten**.

> [!NOTE]  
> OME transcodiert nicht automatisch.  
> Das heißt: Es reicht den Stream exakt so weiter, wie OBS ihn sendet.

### OvenMediaEngine reagiert nicht

Wenn das Dashboard einfriert oder keine Änderungen mehr übernimmt:

1) In OvenStudio oben rechts auf **Server → Restart** klicken.  
2) Etwa 10 Sekunden warten, dann die Seite neu laden.  
3) Wenn das Problem bleibt, den Container in Proxmox kurz neu starten.

> [!TIP]  
> Ein Neustart von OME ist unkritisch – aktive Streams werden nach wenigen Sekunden automatisch wieder erkannt.

### Konfiguration anpassen oder sichern

Wenn du Änderungen an der `Server.xml` vornehmen möchtest:

1) Per SFTP verbinden (z. B. mit FileZilla).  
2) Pfad: `/usr/local/etc/OvenMediaEngine/Server.xml`  
3) Datei herunterladen, bearbeiten und wieder hochladen.  
4) In OvenStudio über **Server → Restart** neu laden.

> [!IMPORTANT]  
> Fehlerhafte XML-Strukturen verhindern den Start von OME.  
> Wenn nach einer Änderung nichts mehr funktioniert, einfach die vorherige Version wiederherstellen.

Schnelle Sicherung der aktuellen Konfiguration:

```bash
cp /usr/local/etc/OvenMediaEngine/Server.xml /usr/local/etc/OvenMediaEngine/Server_backup.xml
```

Wiederherstellung im Notfall:

```bash
cp /usr/local/etc/OvenMediaEngine/Server_backup.xml /usr/local/etc/OvenMediaEngine/Server.xml
```

Danach Neustart wie gewohnt über OvenStudio.

---

## Abschluss

OvenMediaEngine ist ein stabiles System, das bei korrekter Einrichtung sehr zuverlässig arbeitet.  
Die meisten Fehler entstehen durch einfache Ursachen wie veraltete Streamkeys, falsche App-Namen oder nicht gespeicherte Änderungen in der Konfigurationsdatei.  
Mit den hier beschriebenen Schritten lassen sich solche Probleme schnell erkennen und beheben, ohne tief in das System eingreifen zu müssen.

Wichtig ist ein strukturiertes Vorgehen: Änderungen immer nachvollziehbar dokumentieren, nach jeder Anpassung den Dienst gezielt neu starten und das Verhalten in OvenStudio beobachten.  
So lässt sich klar unterscheiden, ob der Fehler an der Quelle (OBS), an der Weiterleitung (OME) oder an der Zielplattform liegt.

OvenStudio dient dabei als zuverlässige Kontrolloberfläche.  
Sie zeigt an, welche Streams aktiv sind, ob Ausgänge verbunden sind und ob das System ordnungsgemäß arbeitet.  
Wer diese Anzeigen regelmäßig prüft und seine Konfiguration sauber hält, wird mit einem sehr stabilen und transparenten Streaming-Server belohnt.

Selbst wenn einmal etwas nicht funktioniert, bleibt OME berechenbar:  
Ein Blick in die Logdateien oder eine kurze Kontrolle der XML genügt meist, um den Fehler zu finden.  
Damit hast du eine solide Grundlage, auf der du deinen eigenen RTMP-Server sicher und dauerhaft betreiben kannst.