diff --git a/Kapitel 11/Free Rohtext.md b/Kapitel 11/Free Rohtext.md new file mode 100644 index 0000000..adea246 --- /dev/null +++ b/Kapitel 11/Free Rohtext.md @@ -0,0 +1,574 @@ +# 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 `` und aktiviere dort den Eintrag für das **Dashboard**. + In neueren Versionen ist er standardmäßig vorhanden, muss aber auf „enabled“ gesetzt werden: + + ```xml + + true + 8081 + + ``` + +3) Datei speichern und OME neu starten: + ```bash + systemctl restart ome + ``` + +> [!NOTE] +> Nach dem Neustart kannst du im Browser `http://: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://: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://: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:///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 + + default + + + + live + + rtmp + + + + + RTMP + rtmp://live.twitch.tv/app/ + DEIN_TWITCH_KEY + + + + + +``` + +#### Bedeutung der einzelnen Bereiche + +| Abschnitt | Beschreibung | +|------------|--------------| +| `` | Oberste Ebene. Enthält alle Apps und Ausgänge. | +| `` | Definiert einen Stream-Kanal. Der Name muss zu dem passen, was du in OBS angibst (z. B. `rtmp://ip/live`). | +| `` | Bestimmt, welche Art von Stream angenommen wird (z. B. RTMP). | +| `` | Legt fest, wohin das Signal gesendet wird. Hier kannst du mehrere Ziele hintereinander definieren. | +| `` | Zieladresse der Plattform (Twitch, YouTube usw.). | +| `` | Dein persönlicher Sendeschlüssel, wie in OBS. | + +> [!NOTE] +> Die Datei kann beliebig viele ``-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://: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:///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 `` einfügen + +> [!TIP] +> Wenn du auf mehreren Twitch-Kanälen streamst, kannst du pro Account einen eigenen ``-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 `` 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 + rtmp://fa.kick.com/live/ + DEIN_KEY + ``` + +> [!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://: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:///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 `` und `` + - 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. \ No newline at end of file