Eigenen SRTLA-Servermit Docker einrichten

Inhalt

• Automatische Installation
• 1. Voraussetzungen
• 2. Docker installieren
• 3. Compose-Datei erstellen
• 4. Container starten
• 5. Ports freigeben
• 6. Sender konfigurieren
• 7. OBS verbinden
• 8. Statistik prüfen
• 9. NOALBS vorbereiten
• 10. Wartung und Fehlerdiagnose
• 11. Videoanleitung von A bis Z

Automatische Installation deines SRTLA-Servers

Aktuelles Praxisvideo: beide Auto-Installer im Einsatz

In 4:18 Minuten siehst du die Installation von SRTLA und RTMP im Terminal. Die Videoübertragung wurde anschließend auf beiden Wegen erfolgreich getestet. Für den vollständigen Aufbau mit BELABOX und OBS bleibt die ausführliche SRTLA-Videoanleitung von A bis Z weiter unten erhalten.

Aktuelles Praxisvideo auf YouTube öffnen (4:18 Min.)

▶ Praxisvideo ansehen

Die zweite im Video gezeigte Installation erklärt die RTMP-Auto-Installer-Anleitung.

Für einen frischen Server mit Debian 12/13 oder Ubuntu 22.04/24.04/26.04 auf amd64 oder arm64. Melde dich über PuTTY oder ein Terminal per SSH an und wechsle zuerst zu Root: unter Ubuntu meist mit sudo -i, bei einer Debian-Minimalinstallation ohne sudo mit su - und dem Root-Passwort. Danach fügst du den folgenden Installationsbefehl einmal vollständig ein.

bash -c 'set -Eeuo pipefail; export PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:$PATH"; apt-get update; apt-get install -y ca-certificates curl; f=$(mktemp); curl -fsSL --retry 3 -o "$f" "https://irl4you.de/downloads/install-srtla-docker-v2.sh"; printf "%s  %s\n" "9c714fed41b5752333ad99b4f186365b4e4953fa3cec4b1d12c8402475fa4f12" "$f" | sha256sum -c -; bash "$f"'

Die Prüfsumme schützt davor, versehentlich eine andere Dateiversion auszuführen. Der Installer erkennt das Betriebssystem, wählt die passende Docker-Paketquelle und das Receiver-Image und zeigt seine elf Schritte einzeln an. Er fragt unter anderem nach Updates, deutscher Systemsprache, Serverstandort/Zeitzone und der lokalen Firewall. Bei Ja/Nein-Fragen ist eine ausdrückliche Eingabe von j oder n nötig. Bei einem Fehler stoppt er mit einer Meldung; bereits installierte Pakete werden dabei nicht automatisch zurückgenommen. Eine vorhandene SRTLA-Konfiguration bleibt erhalten.

Für eine vollständige lokale Firewall-Einrichtung wählst du bei UFW j. Vor der Aktivierung zeigt der Installer den erkannten SSH-Port und lässt ihn bestätigen oder korrigieren. Danach werden 8181/TCP, 8282/UDP und 8383/UDP freigegeben. Wählst du n, brauchst du eine anderweitig passende Firewall-Konfiguration.

Nach erfolgreicher Installation starte den Server selbst mit reboot neu. Melde dich erneut per SSH als Root an und prüfe Docker, Receiver, Fail2ban und Firewall mit:

/usr/local/sbin/irl4you-srtla-status

Wenn die Paketupdates zuerst einen Neustart verlangen, starte den Server neu und führe anschließend denselben Installationsbefehl erneut aus. Danach richtest du Sender und Stream-ID sowie OBS ein. Die Abschnitte darunter beschreiben weiterhin die manuelle Ubuntu-Variante und helfen bei der Fehlerdiagnose.

So sieht der Ablauf aus

Die Screenshots stammen aus den praktischen Tests mit Ubuntu 26.04 und Debian 13. Du kannst sie für die volle Größe öffnen.

1. Voraussetzungen und Architektur prüfen

Benötigt werden ein Server mit öffentlicher IP oder passenden Routerfreigaben und Root-Rechte. Die folgenden manuellen Installationsschritte verwenden die Ubuntu-Paketquelle; auf Debian nimm die getestete automatische Installation oben. Für die manuelle Ubuntu-Variante wechsle zuerst in eine Root-Shell:

sudo -i

Prüfe anschließend die Architektur:

dpkg --print-architecture

Bei amd64 verwendest du die Compose-Datei dieser Anleitung. Für ARM64 muss der Image-Tag zu v1.9-arm64 geändert werden.

Passende Stelle im Video: Ubuntu-Server vorbereiten ab 8:15

2. Docker Engine und Compose installieren

Die folgenden manuellen Befehle verwenden das Ubuntu-Repository. Für Debian nutze entweder die automatische Installation oben oder die offizielle Docker-Anleitung für Debian. Bitte nicht das Ubuntu-Repository auf Debian eintragen.

Benötigte Pakete installieren

apt update && \
apt install ca-certificates curl -y

Docker-Schlüssel hinterlegen

install -m 0755 -d /etc/apt/keyrings && \
curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc && \
chmod a+r /etc/apt/keyrings/docker.asc

Offizielle Docker-Paketquelle eintragen

tee /etc/apt/sources.list.d/docker.sources > /dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

Docker installieren und prüfen

apt update && \
apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y && \
systemctl enable --now docker && \
docker run --rm hello-world

Quelle: Docker Engine unter Ubuntu installieren.

Passende Stelle im Video: Pakete und Docker ab 11:51

3. SRTLA-Projekt und Compose-Datei erstellen

Fertige compose.yaml herunterladen

Lade die vorbereitete Compose-Datei direkt vom IRL4YOU-Server an den vorgesehenen Ort:

install -d -m 0755 /opt/srtla-receiver && \
curl -fsSL --retry 3 https://irl4you.de/downloads/compose-srtla.yaml -o /opt/srtla-receiver/compose.yaml && \
chown root:root /opt/srtla-receiver/compose.yaml && \
chmod 0644 /opt/srtla-receiver/compose.yaml

Bei amd64 ist die Datei sofort verwendbar. Wenn die Architekturprüfung arm64 ausgegeben hat, öffne sie und ersetze den Image-Tag v1.9-amd64 durch v1.9-arm64:

nano /opt/srtla-receiver/compose.yaml

services:
  srtla-receiver:
    image: glowf1sh/srtla-receiver:v1.9-amd64
    container_name: srtla-receiver
    restart: always
    environment:
      NOALBS_STARTUP: "false"
      LUSTATSBOT_STARTUP: "false"
      SRTLA_REC_STARTUP: "true"
      SLS_STARTUP: "true"
    ports:
      - "8181:8181/tcp"
      - "8282:8282/udp"
      - "8383:8383/udp"
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

NOALBS und der LiveU-Bot bleiben beim ersten Test deaktiviert. Dadurch lässt sich die eigentliche SRTLA-Strecke isoliert prüfen.

Passende Stelle im Video: SRTLA-Container ab 14:05

4. Container herunterladen und starten

cd /opt/srtla-receiver && \
docker compose pull && \
docker compose up -d && \
docker compose ps && \
docker compose logs --tail=100

5. Ports und Firewall

Installiere zunächst UFW:

apt install ufw -y

Erlaube anschließend zuerst SSH und danach die drei benötigten Dienste. Die folgende manuelle Beispielregel OpenSSH passt zum Standardport 22. Nutzt dein Server einen anderen SSH-Port, verwende die automatische Installation oben: Sie erkennt und bestätigt den tatsächlich verwendeten Port vor dem Einschalten von UFW. Aktiviere die Firewall erst, wenn alle Freigaben erfolgreich angelegt wurden:

ufw allow OpenSSH && \
ufw allow 8181/tcp && \
ufw allow 8282/udp && \
ufw allow 8383/udp && \
ufw --force enable && \
ufw status verbose

Bei einem Server hinter einem Router müssen dieselben Ports zum Ubuntu-Server weitergeleitet werden. Achte besonders auf UDP: Eine TCP-Freigabe für 8282 oder 8383 funktioniert nicht.

Firewall und Serverports im Video ab 17:48Oracle-Netzwerkregeln im Video ab 19:47

6. Sender und Stream-ID konfigurieren

Ersetze DEIN_LANGER_KEY durch einen schwer erratbaren Wert. Der Container besitzt in diesem Aufbau keine eigene Publish-Key-Datenbank; der Streamname sollte deshalb nicht trivial sein.

Erzeuge dafür beispielsweise einen zufälligen 64-stelligen Wert und bewahre ihn wie ein Passwort auf:

openssl rand -hex 32

Normales SRT über eine Verbindung

Server:    srt://DEINE-SERVER-IP:8282
Stream-ID: publish/live/DEIN_LANGER_KEY

SRTLA über mehrere Verbindungen

Server:    srt://DEINE-SERVER-IP:8383
Stream-ID: publish/live/DEIN_LANGER_KEY

Einige Apps, darunter bestimmte IRL-Pro-Konfigurationen, verwenden laut Image-Dokumentation stattdessen eine Adresse im Format srtla://DEINE-SERVER-IP:8282. Entscheidend ist die vom jeweiligen Sender erwartete SRTLA-Betriebsart.

Passende Stelle im Video: BELABOX verbinden ab 21:35

7. Stream in OBS empfangen

Füge in OBS eine Medienquelle hinzu, deaktiviere „Lokale Datei“ und trage als Eingabe ein:

srt://DEINE-SERVER-IP:8282?streamid=play/live/DEIN_LANGER_KEY

• Wiedergabe neu starten, wenn die Quelle aktiv wird
• Nichts anzeigen, wenn die Wiedergabe endet
• Datei schließen, wenn die Quelle inaktiv ist
• Hardware-Decodierung aktivieren, falls verfügbar

Läuft OBS auf demselben Rechner wie der SRTLA-Receiver, kann der Netzwerkpuffer sehr klein eingestellt werden. Bei einem entfernten Server sind ein bis drei Megabyte ein sinnvoller Ausgangspunkt.

Passende Stelle im Video: SRTLA-Stream in OBS ab 23:45

8. Statusseite und Datenfluss prüfen

http://DEINE-SERVER-IP:8181/stats

Kontrolliere zunächst Containerstatus und Listener:

cd /opt/srtla-receiver && \
docker compose ps && \
ss -ltnup | grep -E ':8181|:8282|:8383'

Beobachte bei Bedarf anschließend die Live-Protokolle. Beende die Ansicht mit Strg+C:

cd /opt/srtla-receiver && \
docker compose logs -f --tail=100

Wenn der Sender verbunden ist, die Statusseite aber keinen Publisher zeigt, prüfe Stream-ID, Protokoll und UDP-Port. Wenn der Publisher sichtbar ist, OBS aber kein Bild erhält, muss die Wiedergabe-ID exakt mit play/live/DEIN_LANGER_KEY übereinstimmen.

Passende Stelle im Video: Funktionstest ab 29:09

9. NOALBS für Szenenwechsel vorbereiten

Das Image enthält NOALBS 2.11.2. Für einen ersten stabilen Test bleibt es deaktiviert. Später kannst du eine gültige Konfiguration nach /apps/noalbs/config.json einbinden und NOALBS_STARTUP auf true setzen.

"streamServer": {
  "type": "SrtLiveServer",
  "statsUrl": "http://127.0.0.1:8181/stats",
  "publisher": "publish/live/DEIN_LANGER_KEY"
}

Die Szenennamen für normalen Empfang, geringe Bitrate und Offline müssen exakt den Namen in OBS entsprechen. Da die enthaltene NOALBS-Version älter ist, sollte die Einrichtung zunächst ohne Twitch-Bot erfolgen.

Passende Stelle im Video: NOALBS konfigurieren ab 25:42

10. Wartung, Neustart und Fehlerdiagnose

Status und letzte Logs anzeigen

cd /opt/srtla-receiver && \
docker compose ps && \
docker compose logs --tail=200

Container neu starten

cd /opt/srtla-receiver && \
docker compose restart

Image aktualisieren und Container neu erstellen

cd /opt/srtla-receiver && \
docker compose pull && \
docker compose up -d

Container stoppen und Konfiguration behalten

cd /opt/srtla-receiver && \
docker compose down

Root-Shell verlassen

Wenn Installation oder Wartung abgeschlossen sind, beendest du die Root-Shell:

exit

Originalprojekt und Detailangaben: glowf1sh/srtla-receiver auf Docker Hub.

11. Videoanleitung: SRTLA-Server von A bis Z

Das Praxisvideo von Akinos01 „Akinos“ zeigt den gesamten damaligen Aufbau: vom Oracle-Cloud-Zugang und einer kostenlos nutzbaren virtuellen Ubuntu-Maschine über SSH und PuTTY bis zur Installation des SRTLA-Servers sowie der Verbindung mit BELABOX, OBS und NOALBS.

Kapitel im Video

1. 0:00Überblick und Ziel des SRTLA-Servers
2. 0:58Oracle Cloud und kostenlosen Server einrichten
3. 1:50Virtuelle Ubuntu-Maschine anlegen
4. 5:56SSH-Schlüssel für den Server
5. 6:36PuTTY einrichten und verbinden
6. 8:15Ubuntu-Server vorbereiten
7. 11:51Pakete und Docker installieren
8. 14:05SRTLA-Container einrichten
9. 17:48Firewall und Serverports
10. 19:47Oracle-Netzwerkregeln freigeben
11. 21:35BELABOX mit SRTLA verbinden
12. 23:45SRTLA-Stream in OBS empfangen
13. 25:42NOALBS konfigurieren
14. 29:09Funktionstest und Status prüfen

Schriftliche Alternative zum Video: Nutze die automatische Installation und lies die Schritte für Sender und OBS-Empfang hier auf der Seite. Die Kapitelmarken darüber helfen beim gezielten Ansehen.