SLS-Live-Server – SRT(LA) Server für IRL-Streams

,

Ich habe schon in anderen Anleitungen gezeigt, wie man mit Hilfe von NOALBS und einem SRT Server einen IRL-Livestream (In Real Life) zusammenbauen kann.
Um die Einrichtung etwas zu erleichtern, hat AlexanderWagnerDev einen Docker Container dafür erstellt.
Damit wir noch einen drauf setzen können, beinhaltet dieser auch alle Funktionalitäten für das „Bonding“ für SRT (SRTLA).
Wir können also unseren Videostream über mehrere Internetanbindungen zum Stream-Server schicken.
In dieser Anleitung setzen wir diesen Container auf und gehen damit LIVE!
Die Einrichtung ist mit dieser Methode recht simpel, da wir nichts mehr selbst kompilieren müssen.

Was ist SRT?
SRT steht für Secure Reliable Transport.
Das Protokoll unterstützt neben dem h265-Codec, auch direkt eine verschlüsselte – und damit sichere – Übertragung der Daten.
Ein weiterer Pluspunkt ist auch die niedrige Latenz und dass das Protokoll OpenSource ist.
Es ist gerade für Streams mit nicht ganz stabilen Internetverbindungen richtig gut.

Was ist SRTLA?
Die Abkürzung SRTLA steht für Secure Reliable Transport Link Aggregation.
SRTLA ermöglicht es, mehrere Verbindungen über z.B. mehrere Internetanbieter zum Streamserver aufzubauen, um eine zuverlässige hohe Bandbreite für den Stream zu erzielen.
Das SRTLA-Protokoll kümmert sich hierbei um alles. Wir brauchen keinen extra Router, der das kann.

Was ist Bonding?
Bonding oder auch gerne Port-Channel genannt, ist das Bündeln von mehreren Verbindungen zu einer großen.
Man nehme mehrere Internetanbindungen und fasst diese zu einer großen zusammen.
Somit hat man eine höhere Bandbreite und eine Ausfallsicherheit, falls eine Verbindung mal nicht funktionieren sollte.

Wir setzen hier in dieser Anleitung alles von Hand auf.
Es gibt auch ein Script, was alles automatisch durchführt.

Was brauchen wir?

– Einen Server (ARM oder X64-CPU)
– Linux als Betriebssystem (Debian empfohlen)
– 1 CPU Kern und 512MB RAM
– 1GB freien Speicherplatz
– Root-Rechte auf dem System
– In den Standardeinstellungen die Ports 4000, 4001, 5000, 8000 und 8789
– Docker
– Eine gute Internetanbindung (Datenrate + Puffer)
– Eine Streaming-Anwendung, die SRT unterstützt (z.B. OBS Studio oder IRL Pro)
HINWEIS: Für eine gute Anbindung unterwegs, ist ein Server in einem Rechenzentrum empfohlen. Wer einen DS-Light-Anschluss zuhause hat, kann unter Umständen die Ports nicht freigeben.

Docker installieren

Installiere Docker auf einem System.
Gehe hierzu auf die offizielle Docker Webseite und schicke die notwendigen Befehle ab.
Diese findest du hier: https://docs.docker.com/engine/install/debian/

Den Container starten

Erstelle nun einen Ordner, indem alle Daten gespeichert werden und wechsel in diesen.

mkdir -p /opt/srtla/data
cd /opt/srtla

Setze nun die Rechte auf den Ordner „data“ passend, damit der Container später darin Daten ablegen kann.

chmod 777 data/

Setzt du die Berechtigung nicht, wird später das Anlegen der Datenbank scheitern, wodurch nichts gespeichert werden kann.

Wir nutzen in dieser Anleitung den Container SRTLA Docker Server, was den SRTLA-Server inkl. Webinterface beinhaltet.

Lege nun die Docker Compose Datei an und öffne sie z.B. mit nano.

nano docker-compose.yml

Befülle die Datei mit diesem Inhalt:

services:
  srtla-server:
    image: alexanderwagnerdev/srtla-server:latest
    container_name: srtla-server
    restart: unless-stopped
    ports:
      - "8789:8080/tcp"
      - "5000:5000/udp"
      - "4001:4001/udp"
      - "4000:4000/udp"
    volumes:
      - ./data:/var/lib/sls

  slspanel:
    image: alexanderwagnerdev/slspanel:latest
    container_name: slspanel
    restart: unless-stopped
    environment:
      - LANG=en
      - TZ=UTC
      - SLS_API_URL=http://srtla-server:8080
      - SLS_API_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
      - SRT_PUBLISH_PORT=4001
      - SRT_PLAYER_PORT=4000
      - SRTLA_PUBLISH_PORT=5000
      - SLS_DOMAIN_IP=192.168.69.69
      - SLS_STATS_PORT=8789
      - REQUIRE_LOGIN=True
      - USERNAME=admin
      - PASSWORD=password
    ports:
      - "8000:8000/tcp"

Zu Editieren sind folgende Punkte:
SLS_API_KEY -> Füge hier später den API-Key ein, der dir in der Konsole gleich ausgegeben wird.
SLS_DOMAIN_IP -> Ersetze die IP gegen die IP-Adresse ODER Domain deines Servers
USERNAME -> Falls dir admin nicht gefällt, nutze ein anderen Namen. Gerade wenn der Server im Internet erreichbar ist, gibts schnell Bruteforce-Angriffe auf den Nutzer „admin“.
PASSWORD -> Setze hier ein Sicheres Passwort rein! Verzichte ggf. auf ein paar Sonderzeichen, da es YAML ist (und ich hasse YAML). Sonderzeichen wie ! § $ sind ok.

Sollten Ports bei dir in Verwendung sein, ändere diese bei ports: passend ab. Ändere aber nur die Ports VOR dem : NICHT nach dem :!
Ist z.B. Port 8000 belegt, muss das so aussehen: 8123:8000!

Jetzt können wir den Container das erste Mal starten und den API-Schlüssel abfangen.

docker compose up

Du siehst im Log irgendwann die Zeilen mit dem API-Schlüssel.
Dieser Text taucht 2x auf.
Kopiere den Schlüssel raus.
Geh aus dem Live-Log raus, indem du einfach „d“ auf der Tastatur drückst.
WICHTIG: Dieser API-Schlüssel taucht NIE MEHR auf! Speichere ihn daher irgendwo sicher ab! Hast du ihn verloren, lösche den data-Ordner und fang von vorne an.

Öffne die docker-compose.yml wieder mit nano.

nano docker-compose.yml

Editiere nun die Zeile mit SLS_API_KEY und tausche die XXXXX gegen deinen API-Schlüssel.
Speichere die Datei ab und starte den Docker Container neu.

docker compose down && docker compose up -d

4. Das Webinterface

Du kannst jetzt dich mit den Zugangsdaten aus der Docker Compose Datei im Webinterface anmelden.
Öffne dazu einen Webbrowser und gehe auf die IP / Domain deines Servers inkl. des Ports für das SLS-Panel.
Hier im Beispiel ist es http://192.168.69.69:8000
Hinweis: Es ist nur HTTP aktiv, kein HTTPS! Dein Browser könnte dich unter Umständen direkt zu HTTPS weiterleiten, wodurch die Seite nicht erreichbar ist.

Melde dich mit dem Benutzer und Passwort an.

5. Stream erstellen

Du kannst einen Stream erstellen, indem du auf den schönen grünen Knopf dazu drückst.

Der Publisher Key ist der Schlüssel für dein Stream-Programm (z.B. OBS Studio oder IRL Pro).
Der Player Key ist der Schlüssel für die Wiedergabeprogramme (z.B. VLC Player oder OBS Studio).
Bei Description kannst du einen einfachen Hinweistext eingeben, um etwas Ordnung zu halten.

Nach dem Anlegen hast du erfolgreich einen Stream-Schlüssel erstellt, welcher jetzt sofort live ist.

Drückst du diesen nun an, siehst du ganz oben den Stream-Schlüssel selbst inkl. die Beschreibung.

Für deine Stream-Anwendungen stehen nun zwei Eingänge bereit.
SRT Publish URL -> Wenn du nur das SRT-Protokoll ohne Bonding nutzen möchtest. Beispiel-URL: srt://192.168.69.69:4001?streamid=live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
SRTLA Publish URL -> Wenn du Bonding nutzen möchtest, nutze SRTLA und nur SRT. Beispiel: srtla://192.168.69.69:5000?streamid=live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Bei Players kannst du verschiedene Schlüssel für die Wiedergabeanwendungen anlegen.
Diese Schlüssel sind nicht identisch zu deinem Stream-Schlüssel.
Es wird automatisch ein Player angelegt, was vermutlich für die meisten Fälle genügt.
Player URL -> Die URL für z.B. OBS Studio als Medienquelle. Beispiel: srt://192.168.178.121:4000?streamid=play_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Stats URL -> Die URL für z.B. NOALBS, um die Streamstatistiken abrufen zu können, damit das Bild ggf. automatisch gewechselt wird.
Stats Legacy URL -> Der gleiche Inhalt wie bei „Stats URL“, nur für ältere Anwendungen.

Tipp: Für NOALBS nutze hier die Quelle „OpenIRL„. Das klappt super.

  "streamServer": {
    "type": "OpenIRL",
    "statsUrl": "http://192.168.69.69:8789/stats/play_xxxxxxxxxxxxxxxxxxxxxxxxx",
  },

Du kannst jetzt auch weitere Streams erstellen, sofern du mit mehreren Kameras unterwegs bist.
Du musst nur genügend Bandbreite an deinem Server haben, damit dieser die Streams sauber empfangen und weiterleiten kann.

WICHTIG: Jeder mit dem Stream-Schlüssel und Zugang zum Server kann ohne weitere Authentifizierung sofort über dein Konto streamen! Behalte daher die Schlüssel vertraulich und gewähre nur vertrauenswürdigen Quellen Zugriff auf dein Server.

6. LIVE!

Streame jetzt mit deiner Anwendung zum Server.
Die Stream-URL ist entweder srt://192.168.69.69:4001 ODER srtla://192.168.69.69:5000 und dein Stream-Schlüssel ist dein live_KEY.

Die Android App „IRL Pro“ erkennt bei der Eingabe der srtla-URL automatisch, dass hier Bonding genutzt werden kann.
Wenn du kein Bonding nutzen möchtest, nutze die srt-URL.
OBS Studio kann (Stand August 2026) kein SRTLA, weshalb die URL dort nicht funktioniert.

Sobald du deine Stream-Software gestartet hast, solltest du im Webinterface die aktuellen Statistiken sehen können.
Falls nicht, drück mal F5 um die Seite neu zu laden.

7. Sicherheit

Um deine Instanz besser zu schützen, kannst du folgendes tun.
Diese Anpassungen setzen allerdings ein paar Kenntnisse voraus und unter Umständen fähige Hardware.
Ich kann nur Vorschläge geben, um deine Instanz sicher zu machen.

1. Nur die Ports veröffentlichen, die absolut notwendig sind!
-> Gebe ins Internet nur den Stream-Port frei. In unserem Fall Port 4001 und / oder 5000.
-> Den Player-Port 4000 musst du nicht freigeben, wenn du alles bei dir Zuhause betreibst.
-> Der API-Port (8789:8080) muss nicht veröffentlicht werden, sofern du NOALBS nicht nutzt oder alles bei dir Zuhause läuft.
-> Betreibst du den SRT-Server im Rechenzentrum, brauchst du den API-Port 8789 für NOALBS und solltest ihn über ein HTTPS-Proxy leiten.

2. Setze das Weninterface hinter einen HTTPS-Proxy
-> Ändere die Portkonfiguration von 8000:8000/tcp auf 127.0.0.1:8000:8000/tcp ab.
-> Installiere z.B. nginx und richte diese als HTTPS-Proxy ein, der dann auf den Container selbst zeigt.
-> Optional kannst du einen weiteren Login per HTTPS-Proxy einbauen, um Bruteforce-Attaken noch schwerer zu machen.
-> Der Zugriff findet nur per HTTP statt, also komplett unverschlüsselt. Diese Seite sollte niemals so im Internet erreichbar sein. In deinem Heimnetzwerk ist das noch vertretbar.
Einfache nginx Beispiel-Konfiguration:

server {
    listen 443 ssl;
    server_name 192.168.69.69 mein-cooler-stream-server.local;

    ssl_certificate                 /etc/ssl/certs/selfsigned.crt;
    ssl_certificate_key             /etc/ssl/private/selfsigned.key;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

server {
    listen 1443 ssl;
    server_name 192.168.69.69 api-mein-cooler-stream-server.local;

    ssl_certificate                 /etc/ssl/certs/selfsigned.crt;
    ssl_certificate_key             /etc/ssl/private/selfsigned.key;

    location / {
        proxy_pass http://127.0.0.1:8789;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

3. Erlaube nur bestimmte Netzwerke, eine Verbindung aufbauen zu dürfen
-> Hast du eine Firewall vor dem Server sitzen, erlaube nur bestimmte Netzwerke eine Verbindung auf Port 4000 und / oder 5000 aufbauen zu dürfen.
-> Erlaube z.B. nur Deutschland oder deine genutzten Provider (Telekom, O2, Vodafone, 1&1,….).
-> Das schützt vor Angriffen aus der ganzen Welt. Ein Angreifer muss sich dann schon in bestimmten Netzen befinden. Das Risiko ist dadurch überschaubarer.
-> Alle IP-Adressbereiche (IPv4 + IPv6) sind online auffindbar.

F A Q

Gibt es ein Limit bei der Auflösung?
– Nein, es gibt keine Limits bei der Auflösung, Bilder pro Sekunde oder Datenrate.

Muss der SRT(LA) Server etwas kodieren?
– Nein, er leitet nur die Daten weiter.

Wie viel Bandbreite brauche ich?
– Im Download Minimum die gestreamte Bitrate + 10% Puffer. Bei einem 8Mbits Stream sollten min. 10Mbits zur Verfügung stehen. Beim Upload kommt es darauf an, wie viel Abnehmer du anbindest. Bei einer OBS Instanz sind es dann auch 10Mbits, bei zwei Instanzen sind es dann schon 20Mbits.

Kann ich das auch auf Windows umsetzen?
– Du kannst alles in einer virtuellen Maschine umsetzen. Eine gute Software ist hierbei „VirtualBox“. Docker läuft aber nur unter Unix-Systemen, also kein Windows.
– Versuche dich ohnehin mit Linux vertraut zu machen. Nimm dir doch als Aufgabe, ein paar Streams mit einem Linux-System zu machen, um damit warm zu werden und von Windows weg zu kommen 🙂

Ich habe einen DS-Light-Anschluss und möchte es trotzdem gerne Zuhause betreiben. Geht das?
– Jaein. Am besten mietest du dir einen kleinen vServer bei einem Anbieter. Es gibt bereits angebote ab 1€ pro Monat. Das ist der einfachste Ausweg.
– Du kannst versuchen alles auf IPv6-Basis aufzusetzen und damit versuchen eine Verbindung herzustellen. Je nach Internetanbieter kann das funktionieren, muss aber nicht.
– VPNs sind auch eine Methode, diese Unterstützen aber dann kein Bonding, wodurch du effektiv auf SRT limitiert bist.

Kann ich den SRT-Stream auch über nginx leiten?
– Mach das lieber nicht. SRT ist bereits verschlüsselt und nginx ist für TCP-Verbindungen optimiert, keine UDP-Verbindungen. Du kannst zwar das Stream-Modul nutzen, aber es könnte hier zu Problemen kommen. Der nginx-Proxy ist nur für die Absicherung des Webinterface und der API-Schnittstelle notwendig, sofern diese im Internet erreichbar sein müssen.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre, wie deine Kommentardaten verarbeitet werden.