Eigenen RTMP-Server für IRL-Streamingunter Linux einrichten

Inhalt

• Automatische Installation
• 1. Server vorbereiten
• 2. Stream-Key erstellen
• 3. Konfiguration sichern
• 4. Nginx konfigurieren
• 5. Statusseite installieren
• 6. Konfiguration testen
• 7. Firewall absichern
• 8. Ports kontrollieren
• 9. OBS konfigurieren
• 10. Moblin konfigurieren
• 11. Stream empfangen
• 12. Authentifizierung testen
• 13. Logs prüfen
• 14. Autostart
• 15. Sicherheitsübersicht

Automatische Installation des RTMP-Servers

Praxisvideo: RTMP und SRTLA in PuTTY installieren

Im Video siehst du beide Auto-Installer im Ablauf: zuerst den SRTLA-Server, ab etwa Minute 2 den RTMP-Server. Die echte Videoübertragung über beide Wege wurde anschließend ebenfalls erfolgreich getestet.

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

▶ Praxisvideo ansehen

Der zweite im Video gezeigte Weg steht in der eigenen Anleitung: SRTLA-Server mit Docker automatisch installieren.

Für die Einrichtung reicht nach der SSH-Anmeldung ein Installationsbefehl. Werde zuerst Root: unter Ubuntu mit sudo -i, unter Debian ohne sudo mit su -. Der Installer aktualisiert das System, installiert Nginx samt RTMP-Modul und Fail2Ban, fragt den persönlichen Stream-Key verdeckt in der Konsole ab und richtet die Dienste ein. Der Key wird nicht in ein Formular dieser Webseite geschickt. Bei längeren Updates und Paketinstallationen zeigen Punkte den Fortschritt; die ausführlichen Ausgaben stehen im nur für Root lesbaren Protokoll /var/log/irl4you-rtmp-install.log. Bei einem Fehler nennt der Installer den betroffenen Schritt und die letzten Protokollzeilen.

Den folgenden Installationsbefehl vollständig in PuTTY oder ein Terminal einfügen:

bash -c 'set -Eeuo pipefail; [ "$(id -u)" -eq 0 ] || { printf "Bitte zuerst Root werden: sudo -i oder su -.\n" >&2; exit 1; }; . /etc/os-release; case "$ID:$VERSION_ID" in ubuntu:26.04|debian:13) ;; *) printf "Nur Ubuntu 26.04 oder Debian 13 unterstützt.\n" >&2; exit 1;; esac; export PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:$PATH" DEBIAN_FRONTEND=noninteractive; umask 077; log=/var/log/irl4you-rtmp-install.log; : >> "$log"; chmod 0600 "$log"; if ! command -v curl >/dev/null 2>&1 || [ ! -s /etc/ssl/certs/ca-certificates.crt ]; then printf "Downloadwerkzeuge installieren (Details im Protokoll) ...\n"; if { apt-get update && apt-get install -y ca-certificates curl; } >> "$log" 2>&1; then printf "[OK] Downloadwerkzeuge bereit.\n"; else printf "[FEHLER] Downloadwerkzeuge konnten nicht installiert werden.\n" >&2; tail -n 12 "$log" >&2; exit 1; fi; fi; f=$(mktemp); trap "rm -f -- \"$f\"" EXIT; curl -fsSL --retry 3 "https://irl4you.de/downloads/install-rtmp-nginx-v15.sh" -o "$f"; printf "%s  %s\n" "132ba610ecdcd85741e7cce9db7e610b952f46a3414b8396f673c328bc079749" "$f" | sha256sum -c -; bash "$f"'

Installer zum Prüfen herunterladen Die Prüfsumme im Befehl stellt sicher, dass exakt die geprüfte Version ausgeführt wird.

So sieht die automatische Installation in der Konsole aus:

Du kannst einen eigenen 64-stelligen Hex-Key eingeben oder mit Enter einen neuen erzeugen lassen. Ein erzeugter Key wird nur für Root lesbar unter /root/irl4you-rtmp-stream-key gespeichert und nicht öffentlich ausgegeben. Fehlt auf Ubuntu das RTMP-Modul, aktiviert der Installer die offizielle Paketquelle universe automatisch und prüft die Verfügbarkeit erneut. Danach wählst du, ob die NOALBS-Statistik nur lokal, für eine feste IPv4-Adresse oder ausdrücklich öffentlich erreichbar sein soll. Bei der optionalen UFW-Einrichtung wird der tatsächliche SSH-Port vor der Aktivierung bestätigt. Sprache und Zeitzone bleiben unverändert.

Zum Schluss gibst du die öffentliche Server-IP oder Domain ein und entscheidest, ob der geheime Stream-Key einmal sichtbar sein darf. Die Ausgabe zeigt dann zwei Varianten untereinander:

Variante 1: Alles in einem Link

Vollständige RTMP-Adresse: rtmp://DEINE-SERVER-IP:1935/live/DEIN-STREAM-KEY

Diese Variante ist für Sende-Apps mit einem einzigen Feld für die komplette RTMP-Adresse gedacht, etwa IRL Pro.

Variante 2: Server und Key getrennt

Server / URL: rtmp://DEINE-SERVER-IP:1935/live
Stream-Key:  DEIN-STREAM-KEY

Diese Variante nutzt du, wenn die Sende-App zwei Felder anbietet, zum Beispiel OBS oder Moblin. Port 1935 und Pfad /live gehören zu diesem Server; /publish/live/ wird hier nicht verwendet. Beide Varianten enthalten denselben Key. Zeige ihn bei Bildschirmaufnahmen nicht an und veröffentliche weder den Key noch die vollständige Adresse. Auf einem bereits installierten Server zeigt derselbe aktuelle Befehl nach der Statusprüfung diese Angaben erneut, ohne Nginx oder den Key neu einzurichten.

Statistikseite nach der Installation öffnen

So sieht die Statistikseite bei einem laufenden Teststream aus: Sie zeigt unter anderem Eingangs- und Ausgangsbandbreite, aktive Streams und Videodaten. Die Grafik stellt die eigene Statistikvorlage mit Beispielwerten dar; der Stream-Key wurde für die Veröffentlichung ausgeblendet. Nginx- und Modulversionen erscheinen in der HTML-Ansicht nicht mehr; der Hinweis auf die automatische Aktualisierung alle 10 Sekunden bleibt erhalten.

Ist der RTMP-Server bereits mit dem IRL4YOU-Installer eingerichtet, prüft ein erneuter Aufruf den Status. Nur eine unveränderte IRL4YOU-Statistikvorlage kann dabei aktualisiert werden; Stream-Key und Nginx-Konfiguration bleiben erhalten.

Der Auto-Installer gibt am Ende zusätzlich die passende Statistikadresse aus. Wenn du die öffentliche Server-IP oder Domain angegeben hast, erscheint bei Freigabe für eine feste IP oder für alle der direkte Link http://DEINE-SERVER-IP:8081/stat. Die NOALBS-Daten liegen unter /stat.xml. Ein Link mit Platzhalter wird erst nutzbar, wenn du die echte Serveradresse einsetzt.

NOALBS direkt aus der PuTTY-Ausgabe einrichten: Der Abschluss nennt jetzt die drei Werte einzeln: Stats-URL mit /stat.xml, Application: live und Key mit deinem 64-stelligen Stream-Key. Wählst du bei der Key-Abfrage Ja, steht der echte Key kopierfertig dort; bei Nein bleibt er auch in diesem Block verborgen. Unter NOALBS: Stream-Server auswählen findest du die passenden streamServer-Felder.

Sicherer Standard: Ist „nur dieser Server“ ausgewählt, bleibt Port 8081 von außen gesperrt. Dann öffnest du die formatierte Statistik am eigenen Computer über einen PuTTY-SSH-Tunnel:

1. In PuTTY unter Connection → SSH → Tunnels den Source port 18081 und als Destination 127.0.0.1:8081 eintragen, auf Add klicken und die SSH-Verbindung neu öffnen.
2. Im Browser auf deinem Computer http://127.0.0.1:18081/stat öffnen. Ohne den Tunnel funktioniert dieser Link nicht.

Bei Freigabe für eine feste NOALBS-IP funktioniert der direkte Server-Link nur von dieser IP; der SSH-Tunnel bleibt eine Alternative. Stelle Port 8081 nicht allein für eine bequemere Ansicht öffentlich: Während eines Streams kann die Statistik den Stream-Key zeigen.

Der Installer stoppt mit einer Fehlermeldung, wenn ein fremdes Nginx bereits eingerichtet ist, eine Prüfsumme nicht stimmt oder die Konfiguration den Nginx-Test nicht besteht. Einen eindeutig erkannten, nach der Nginx-Einrichtung unterbrochenen IRL4YOU-Testlauf kann er ab Schritt 6 fortsetzen, ohne den Key neu anzulegen. Falls Systemupdates erst einen Neustart benötigen, stoppt er vor der Nginx-Einrichtung; nach dem Neustart lässt sich derselbe Befehl erneut ausführen. Die installierte Nginx-Standardkonfiguration wird vor dem Ersetzen gesichert. Nach der Einrichtung kannst du den Status auch nach einem Neustart prüfen:

/usr/local/sbin/irl4you-rtmp-status

Die ausführlichen Schritte unten bleiben als nachvollziehbare manuelle Alternative erhalten. Kontrolliere auf deinem eigenen Server anschließend den richtigen und einen falschen Key, einen echten Stream von außen und die erneute SSH-Anmeldung nach Aktivierung der Firewall.

1. Linux-Server vorbereiten

Manuelle Alternative: Die folgenden Schritte sind für die Einrichtung von Hand gedacht. Wenn du den Auto-Installer verwendest, führe diese Befehle nicht zusätzlich aus.

Die Befehle passen für Ubuntu Server und Debian. Wechsle für die Installation zuerst in eine Root-Shell: unter Ubuntu mit sudo -i, unter Debian bei einer Standardinstallation ohne sudo mit su - und dem Root-Passwort. Bist du bereits als root angemeldet, ist kein Wechsel nötig.

Ubuntu: sudo -i
Debian ohne sudo: su -

Aktualisiere das System und installiere Nginx samt RTMP-Modul, die deutschen Sprach- und Ländereinstellungen, Fail2Ban sowie curl. Einige Rechenzentren liefern sehr schlanke Server-Images aus, in denen curl noch nicht vorinstalliert ist. Es wird später für den direkten Download der stat.xsl benötigt:

apt update && \
apt upgrade -y && \
apt install nginx libnginx-mod-rtmp locales fail2ban curl openssl -y && \
systemctl enable --now nginx && \
systemctl status nginx

Der Nginx-Status sollte active (running) anzeigen.

Deutsche Sprache, UTF-8 und Ländereinstellungen aktivieren

de_DE.UTF-8 stellt die Standardsprache und landestypische Formate auf Deutsch (Deutschland) um. Dazu gehören beispielsweise Datums-, Zahlen-, Währungs- und Sortierformate. UTF-8 sorgt dafür, dass Umlaute und Sonderzeichen korrekt verarbeitet werden.

sed -i '/de_DE.UTF-8/s/^# *//' /etc/locale.gen && \
locale-gen && \
update-locale LANG=de_DE.UTF-8 LANGUAGE=de_DE:de && \
timedatectl set-timezone Europe/Berlin

Die neue Standardsprache gilt vollständig nach der nächsten Anmeldung. Du kannst die Einrichtung in der bestehenden Root-Shell fortsetzen. Kontrolliere die gespeicherte System-Locale und die Zeitzone:

localectl status && \
timedatectl

Fail2Ban für SSH aktivieren

Fail2Ban beobachtet fehlgeschlagene SSH-Anmeldungen und sperrt auffällige IP-Adressen vorübergehend. Die folgende kleine Zusatzkonfiguration erlaubt fünf Fehlversuche innerhalb von zehn Minuten und sperrt die betreffende Adresse danach für eine Stunde:

Prüfe vorher den SSH-Port. Er muss mit der Portnummer deiner funktionierenden SSH-Verbindung übereinstimmen; bei abweichender Anzeige oder mehreren Ports trage den richtigen Port in SSH_PORT selbst ein. Falls SSH über eine systemd-Socket-Konfiguration gestartet wird, kontrolliere auch deren Listener.

SSH_PORT=$(/usr/sbin/sshd -T | awk '$1 == "port" {print $2; exit}')
printf 'SSH-Port laut sshd: %s\n' "$SSH_PORT"
ss -ltnp | grep -E 'sshd|ssh.socket|systemd'

tee /etc/fail2ban/jail.d/sshd.local > /dev/null <<EOF
[sshd]
enabled = true
port = $SSH_PORT
maxretry = 5
findtime = 10m
bantime = 1h
EOF

Aktiviere und starte Fail2Ban anschließend separat. Der letzte Befehl kontrolliert, ob der SSH-Schutz geladen wurde:

systemctl enable fail2ban && \
systemctl restart fail2ban && \
fail2ban-client status sshd

Die Statusausgabe zeigt unter anderem die Anzahl fehlgeschlagener Versuche und aktuell gesperrte IP-Adressen. Fail2Ban ist ein zusätzlicher Schutz; am sichersten bleibt SSH mit Schlüsselanmeldung statt Passwort.

2. Zufälligen Stream-Key erstellen

Erzeuge einen zufälligen 64-stelligen Schlüssel. Verwende keine einfachen Werte wie test, stream oder 12345.

openssl rand -hex 32

Beispiel: 8e71c20a29593b84f31ed8c4ae365318bd720490114565168c526f018847162a

3. Original-Konfiguration sichern

cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup

Bei Bedarf stellst du sie so wieder her:

cp /etc/nginx/nginx.conf.backup /etc/nginx/nginx.conf

4. Nginx mit Publish-Authentifizierung konfigurieren

Fertige nginx.conf herunterladen

Lade die vorbereitete Konfiguration direkt vom IRL4YOU-Server an den vorgesehenen Ort. Die zuvor erstellte Sicherung bleibt unter /etc/nginx/nginx.conf.backup erhalten:

curl -fsSL --retry 3 https://irl4you.de/downloads/nginx.conf -o /etc/nginx/nginx.conf && \
chown root:root /etc/nginx/nginx.conf && \
chmod 0600 /etc/nginx/nginx.conf

Öffne die heruntergeladene Datei anschließend und ersetze HIER_DEINEN_STREAM_KEY_EINTRAGEN durch deinen zuvor erzeugten persönlichen Stream-Key:

user www-data;
worker_processes 1;
pid /run/nginx.pid;

include /etc/nginx/modules-enabled/*.conf;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
    sendfile on;
    keepalive_timeout 65;

    map $arg_name $rtmp_publish_allowed {
        default 0;
        "HIER_DEINEN_STREAM_KEY_EINTRAGEN" 1;
    }

    server {
        listen 127.0.0.1:8080;
        server_name localhost;

        access_log off;
        error_log /var/log/nginx/rtmp-auth-error.log;

        location = /publish-auth {
            if ($rtmp_publish_allowed = 0) {
                return 403;
            }
            return 200;
        }
    }

    server {
        listen 8081;
        server_name _;

        access_log /var/log/nginx/rtmp-stat-access.log;
        error_log /var/log/nginx/rtmp-stat-error.log;

        location = / { return 302 /stat; }

        location = /stat {
            rtmp_stat all;
            rtmp_stat_stylesheet stat.xsl;
            add_header Cache-Control "no-store" always;
        }

        location = /stat.xml {
            rtmp_stat all;
            add_header Cache-Control "no-store" always;
        }

        location = /stat.xsl {
            root /usr/share/nginx/html;
        }
    }
}

rtmp {
    server {
        listen 1935;
        chunk_size 4096;

        application live {
            live on;
            record off;
            notify_method get;
            on_publish http://127.0.0.1:8080/publish-auth;
            allow publish all;
            allow play all;
        }
    }
}

on_publish übergibt den Streamnamen als Parameter name. Die map erlaubt nur den eingetragenen Key; alle anderen Werte erhalten 403 Forbidden. worker_processes 1; ist für diesen Aufbau entscheidend: Bei mehreren Workern können Publisher, OBS und Statistik in unterschiedlichen Prozessen landen und den aktiven Stream nicht finden.

In Nano speicherst du mit Strg+O, Enter und beendest mit Strg+X.

5. Formatierte RTMP-Statusseite installieren

Die Statusseite zeigt Server-Uptime, Bandbreite, Bytes In/Out, Streamname, Publisher, Clients, Video- und Audiodaten sowie die Stream-Laufzeit.

Fertige stat.xsl herunterladen

Lade die Datei direkt vom IRL4YOU-Server in das vorgesehene Nginx-Verzeichnis. Sie wird dadurch nicht erst unter /root gespeichert oder anschließend von Hand kopiert:

curl -fsSL https://irl4you.de/downloads/stat.xsl -o /usr/share/nginx/html/stat.xsl && \
chown root:www-data /usr/share/nginx/html/stat.xsl && \
chmod 0640 /usr/share/nginx/html/stat.xsl && \
stat -c '%A %U %G %n' /usr/share/nginx/html/stat.xsl && \
nginx -t && \
systemctl restart nginx

Formatierte Übersicht: http://DEINE-SERVER-IP:8081/stat
Rohe XML-Daten für NOALBS: http://DEINE-SERVER-IP:8081/stat.xml

6. Konfiguration prüfen und Nginx neu starten

nginx -t

Starte Nginx nur neu, wenn syntax is ok und test is successful erscheinen:

systemctl restart nginx && \
systemctl status nginx

7. Firewall absichern

Installiere zunächst ausschließlich die Firewall:

apt install ufw -y

Lege anschließend die Standardregeln fest, erlaube zuerst den bestätigten SSH-Port sowie danach RTMP und die für NOALBS nötige Statusseite. Aktiviere UFW erst, nachdem diese Freigaben erfolgreich angelegt wurden:

test -n "${SSH_PORT:-}" && \
ufw default deny incoming && \
ufw default allow outgoing && \
ufw allow "${SSH_PORT}/tcp" && \
ufw allow 1935/tcp && \
ufw allow 8081/tcp && \
ufw --force enable && \
ufw status verbose

Öffne Port 8080 nicht. Port 8081 wird mit dieser Regel zunächst für alle Quelladressen freigegeben, damit NOALBS extern die Statistik abrufen kann. Bei einem festen NOALBS-Endpunkt lässt sich die Regel später gezielt auf dessen öffentliche IP-Adresse beschränken. Prüfe nach dem Aktivieren der Firewall in einem zweiten Terminal, ob SSH weiterhin funktioniert, bevor du die erste Verbindung schließt.

8. Listener und Bindings kontrollieren

ss -tulpn | grep -E ':1935|:8080|:8081'

RTMP darf auf 0.0.0.0:1935 lauschen. Für die Authentifizierung muss ausdrücklich 127.0.0.1:8080 erscheinen. Die Statusseite lauscht öffentlich auf Port 8081.

9. OBS als Sender konfigurieren

Öffne Einstellungen → Stream und wähle den Dienst Benutzerdefiniert.

Server:     rtmp://DEINE-SERVER-IP:1935/live
Stream-Key: DEIN_STREAM_KEY

Die vollständige Adresse ergibt sich als rtmp://DEINE-SERVER-IP:1935/live/DEIN_STREAM_KEY.

10. Moblin konfigurieren

Lege in Moblin ein benutzerdefiniertes RTMP-Ziel an:

RTMP-Adresse: rtmp://DEINE-SERVER-IP:1935/live
Stream-Key:   DEIN_STREAM_KEY

Der Datenweg lautet dann: iPhone → Moblin → Linux-RTMP-Server → OBS.

IRL Pro als Sender

Wenn du in IRL Pro eine vollständige RTMP-Zieladresse in einem Feld eingibst, nutze rtmp://DEINE-SERVER-IP:1935/live/DEIN_STREAM_KEY. Ersetze IP und Key durch deine eigenen Werte. Die Adresse enthält den geheimen Stream-Key und gehört nicht in öffentliche Screenshots.

11. Stream in OBS empfangen

Füge auf dem Empfangs-PC eine Medienquelle oder eine FFmpeg-kompatible Quelle hinzu und verwende:

rtmp://DEINE-SERVER-IP:1935/live/DEIN_STREAM_KEY

Von dort kann OBS das Signal weiterverarbeiten und beispielsweise an Twitch, YouTube oder Kick senden.

12. Richtigen und falschen Stream-Key testen

1. Starte einen Test mit einem absichtlich falschen Key wie falscherkey. Publishing muss scheitern.
2. Wiederhole den Test mit deinem echten Key. Die Verbindung muss funktionieren.
3. Prüfe zusätzlich, dass Port 8080 aus dem Internet nicht erreichbar ist.

13. Logs und Fehlerdiagnose

Beobachte bei Verbindungsproblemen entweder das Nginx-Fehlerprotokoll oder das systemd-Journal live. Beende die jeweilige Ansicht mit Strg+C:

Nginx-Fehlerprotokoll

tail -f /var/log/nginx/error.log

Nginx-Journal

journalctl -u nginx -f

Kontrolliere außerdem Tippfehler im Key, die öffentliche Server-IP, die UFW-Regel und ob dein Hosting-Anbieter TCP 1935 zusätzlich in einer externen Firewall freigeben muss.

14. Autostart nach einem Neustart prüfen

systemctl enable nginx && \
reboot

Der Neustart beendet die Root-Shell. Melde dich danach erneut per SSH an und öffne für die abschließende Kontrolle wieder eine Root-Shell:

Nutze erneut sudo -i oder su -, je nach System und eingerichtetem Benutzerkonto.

systemctl status nginx && \
ss -tulpn | grep 1935

15. Sicherheitsübersicht

Internet
  ├── SSH-Port → SSH
  ├── TCP 1935 → RTMP → on_publish → Key-Prüfung
  ├── TCP 8081 → Statistik für NOALBS (enthält möglicherweise den Key)
  └── TCP 8080 ✕ blockiert
                       └→ nur intern: 127.0.0.1:8080

Ein unbekannter Key verhindert zunächst einen fremden Publish-Versuch. Solange die Statistik öffentlich ist, kann ein laufender Stream den Key aber verraten; betrachte diese Variante daher nicht als vollständig zugriffsgeschützt. Außerdem schützt allow play all; den Abruf nicht. Für private Wiedergabe benötigst du zusätzlich eine Play-Authentifizierung oder einen separaten privaten Transportweg.

Root-Shell nach der Einrichtung verlassen

Wenn alle Prüfungen abgeschlossen sind, wechselst du mit folgendem Befehl zurück zum normalen Benutzer:

exit