Spreed - Videokonferenzserver für Nextcloud

Achtung: die nachfolgende Beschreibung wird nicht weiter gepflegt von mir!

Sie führt zwar (Stand 02/2021) zu einem grundsätzlich funktionierenden Video-Backend, allerdings musste ich bei meinen Tests feststellen, dass es ab einer Teilnehmerzahl von ca. 20 Personen nicht mehr möglich ist, das System sinnvoll zu nutzen. Ich vermute, dass dies damit zusammenhängt, dass die WebRTC-Verbindungen eines jeden Teilnehmers nicht wie bei anderen Videokonferenzlösungen zu einer Verbindung gebündelt werden. Bei der von mir beschriebenen Spreed-Installation hat man in einer Konferenz so viele gleichzeitige WebRTC-Verbindungen wie Teilnehmer in der Konferenz anwesend sind. Dies überfordert bei höheren Teilnehmerzahlen in hohem Maße die einzelnen Clients. Ich habe mich bezüglich dieses Problems an das Nextcloud-Forum gewandt. Bisher habe ich noch keine verwertbare Antwort erhalten.

Alternativ beschreibe ich die Installation einer Jitsi-Instanz samt optionaler Anbindung an den Samba-Server.

Nextcloud hat Spreed - sein High Performance Backend für die Videotelefonie - unter der AGPL-Lizenz zur Verfügung gestellt. Damit ist es in Kombination mit der Nextcloud-Talk-App möglich, neben Chats unter bestimmten Voraussetzungen (Bandbreite, Server-Kapazität) auch parallel stattfindende Videokonferenzen mit sehr vielen Teilnehmern durchzuführen.

Erfüllte Anforderungen

Diese Anforderungen erfüllt das Schulnetzkonzept:

  • Chat und Videotelefonie mit vordefinierten Gruppen oder selbst zusammengestellten Gruppen
  • Berechtigung für die Initialisierung von Videotelefonaten
  • Bildschirmfreigabe
  • Hohe Kapazität

Voraussetzungen

Um die für Spreed notwendige Bandbreite (ca. 1 MBit/s je Teilnehmer) sicherstellen zu können, empfiehlt sich die datenschutzkonforme Installation der erforderlichen Komponenten auf einer virtuellen Maschine bei einem gut angebundenen deutschen Hoster und nicht im eigenen Schulnetz. Ich habe hier (nein, ich bekomme kein Geld für diese Aussage) mit Netcup (Produktreihe: VPS - virtuelle Server) sehr gute Erfahrungen gemacht.

Die Mindestanforderungen lassen sich bei Netcup mit ca. € 10.- monatlich abdecken:

  • 4 CPUs
  • 8 GB Arbeitsspeicher
  • 32 GB Festplattenspeicher
  • Internetanbindung mit 1 Gbit/s duplex

Selbstverständlich können bei entsprechender Bandbreite und Serverinfrastruktur die erforderlichen Komponenten auch im eigenen Schulnetz installiert werden. Hier müssten dann gem. der OPNSense-Beschreibung des Schulnetzkonzepts entsprechende Einstellungen im HAProxy und für die Zertifikatsvergabe getätigt werden.

Weitere Voraussetzungen:

  • Ubuntu-Server 20.04 mit SSH-Zugriff (kann bei Netcup mit einem Klick installiert werden). Ich habe mich hier an bereits vorhandenen Anleitungen orientiert und aus diesem Grund kein Debian verwendet. Die Installation von Ubuntu-Server verläuft fast identisch zu der beschriebenen Installation von Debian.
  • Eine Subdomain für die STUN-, TURN- und Spreed-Dienste, z. B. signaling.ihre-schule.de
  • Eine Weiterleitung der Subdomain (A- oder CNAME–Record) auf den Ubuntu-Server

Installation

Installation und Konfiguration der Firewall

Da der virtuelle Server direkt beim Anbieter im Internet läuft, empfiehlt sich die Installation einer Firewall.

# Installation der Firewall:
apt install ufw -y

# Konfiguration und Aktivierung der Firewall:
ufw allow http
ufw allow https
ufw allow ssh
ufw allow 3478/tcp
ufw allow 3478/udp
ufw enable

Generierung von Schlüsseln

Im weiteren Verlauf dieser Anleitung müssen mehrere Zufallsschlüssel eingesetzt werden. Diese werden nun generiert.
Bitte speichern Sie alle generierten Schlüssel in einem gesonderten Dokument für die weitere Verwendung!

Schlüssel 1

# TURN-Key
openssl rand -hex 32

Schlüssel 2

# API-Key
openssl rand -base64 16

Schlüssel 3

# Nextcloud Secret-Key
openssl rand -hex 16

Schlüssel 4

# Block-Key
openssl rand -hex 16

Schlüssel 5

# Hash-Key
openssl rand -hex 16

Installation und Konfiguration des STUN-/TURN-Servers

Coturn ist eine Open-Source-Implementation eines STUN- und TURN-Servers.

  • Ein STUN-Server ermöglicht hinter einer Firewall befindlichen Clients die Kommunikation mit einem VoIP-Anbieter außerhalb des lokalen Netzwerks.
  • Sollte STUN in einem Netzwerk nicht genutzt werden können, übernimmt der TURN-Server die Aufgabe der Kommunikation über NAT- bzw. Firewallgrenzen hinweg.

Coturn installieren und Backup der Default-Konfiguration

apt install coturn -y

mv /etc/turnserver.conf /etc/turnserver.conf.bak

Coturn-Dienst aktivieren

vim /etc/default/coturn
# Datei /etc/default/coturn
# Kommentar-Zeichen entfernen:
TURNSERVER_ENABLED=1

Konfiguration des Coturn-Servers erzeugen

Ersetzen Sie in der nachfolgenden Konfiguration <Schlüssel 1> mit dem oben erzeugten Schlüssel.

vim /etc/turnserver.conf
Datei /etc/turnserver.conf
# Folgenden Inhalt in die Datei einfügen,
# <Schlüssel 1> und <Schlüssel 6> durch die oben erzeugten Schlüssel ersetzen
# und die Domäne anpassen:

listening-port=3478
fingerprint
use-auth-secret
static-auth-secret=<Schlüssel 1>
realm=signaling.ihre-schule.de
total-quota=0
bps-capacity=0
no-tls
no-dtls
stale-nonce
no-stdout-log
log-file=/tmp/coturn.log
no-multicast-peers

Coturn-Server neu starten und als Dienst aktivieren

systemctl restart coturn.service && systemctl enable coturn.service

Installation und Konfiguration des Janus-Servers

Janus ist ein WebRTC-Server, welcher für die Spreed-Komponente benötigt wird. Leider gibt es im Augenblick kein uneingeschränkt passendes apt-Paket, welches allen Anforderungen gerecht wird. Somit müssen die Janus-Komponenten selbst konfiguriert, erzeugt und installiert werden.

Die nachfolgende Installationsbeschreibung für Janus basiert auf der offiziellen Github-Seite des Projekts.

Installation erforderlicher Pakete

# Erforderliche Pakete für das Kompilieren und Erzeugen von Programmen
apt install meson make cmake build-essential -y

# Erforderliche Pakete für janus
apt install libmicrohttpd-dev libjansson-dev libssl-dev libsofia-sip-ua-dev libglib2.0-dev libopus-dev libogg-dev libcurl4-openssl-dev liblua5.3-dev libconfig-dev pkg-config gengetopt libtool automake

Libnice erzeugen und installieren

cd /root
git clone https://gitlab.freedesktop.org/libnice/libnice
cd libnice
meson --prefix=/usr build && ninja -C build && sudo ninja -C build install

Libsrtp erzeugen und installieren

cd /root
wget https://github.com/cisco/libsrtp/archive/v2.3.0.tar.gz
tar xfv v2.3.0.tar.gz
cd libsrtp-2.3.0
./configure --prefix=/usr --enable-openssl
make shared_library && sudo make install

Usrsctp erzeugen und installieren

cd /root
git clone https://github.com/sctplab/usrsctp
cd usrsctp
./bootstrap
./configure --prefix=/usr --disable-programs --disable-inet --disable-inet6 --libdir=/usr/lib64
make && sudo make install
libtool --finish /usr/lib64/

Libwebsockets erzeugen und installieren

cd /root
git clone https://libwebsockets.org/repo/libwebsockets
cd libwebsockets
mkdir build
cd build
cmake -DLWS_MAX_SMP=1 -DLWS_WITHOUT_EXTENSIONS=0 -DCMAKE_INSTALL_PREFIX:PATH=/usr -DCMAKE_C_FLAGS="-fpic" ..
make && sudo make install

Janus erzeugen und installieren

cd /root
git clone https://github.com/meetecho/janus-gateway.git
cd janus-gateway
sh autogen.sh
./configure --prefix=/opt/janus --disable-rabbitmq --disable-mqtt
make && sudo make install
make configs

Janus als Dienst einrichten

vim /etc/systemd/system/janus.service
Datei /etc/systemd/system/janus.service
[Unit]
Description=My Janus WebRTC Server
#Ursprünglich: After=network.target
After=coturn.service

[Service]
Restart=on-abnormal
LimitNOFILE=65536
ExecStart=/opt/janus/bin/janus

[Install]
WantedBy=multi-user.target

Janus konfigurieren

vim /opt/janus/etc/janus/janus.jcfg
Datei /opt/janus/etc/janus/janus.jcfg
# Begeben Sie sich in der Konfigurationsdatei zum Bereich "NAT".
# Suchen Sie nach den nachfolgenden Zeilen, geben Sie dort die entsprechenden
# Daten an und achten Sie darauf, dass jene Zeilen nicht auskommentiert sind.
# Ersetzen Sie <Schlüssel 2> durch den oben generierten Schlüssel.

stun_server = "signaling.ihre-schule.de"
stun_port = 3478
nice_debug = false
full_trickle = true

turn_rest_api_key = "<Schlüssel 2>"

Janus neu starten und als Dienst aktivieren

systemctl daemon-reload && systemctl restart janus.service && systemctl enable janus.service

Installation des NATS-Servers

Auch der NATS-Server ist eine für Spreed benötigte Komponente.

Installation von Docker für den NATS-Server und Aktivierung als Dienst

curl -sSL https://get.docker.com/ | CHANNEL=stable sh
systemctl enable docker.service
systemctl start docker.service

NATS als Docker-Image starten

docker run --restart=always --name=NATSSERVER -d -p 4222:4222 -ti --restart=always nats:latest

Installation und Konfiguration des Spreed-Singaling-Servers

Notwendige Pakete installieren

apt install git automake golang build-essential python3 -y

Klonen des Git-Repositorys und Erstellen des Pakets mit build

cd /opt
git clone https://github.com/strukturag/nextcloud-spreed-signaling.git
cd nextcloud-spreed-signaling/
make build

Paket Kopieren

cp /opt/nextcloud-spreed-signaling/bin/signaling /usr/bin/

Dedizierten Benutzer mit Namen signaling anlegen

useradd --system --shell /usr/sbin/nologin --comment "Standalone signaling server for Nextcloud Talk." signaling

Konfiguration erzeugen und Berechtigungen setzen

Achten Sie bei der nachfolgenden Konfigurationsdatei darauf, alle vorher generierten Schlüssel an der richtigen Stelle einzufügen und alle Domänennamen anzupassen.

mkdir /etc/signaling/
touch /etc/signaling/server.conf
chown signaling: /etc/signaling/server.conf
chmod 600 /etc/signaling/server.conf
vim /etc/signaling/server.conf
Datei /etc/signaling/server.conf
[http]
listen = 127.0.0.1:8080

[app]
debug = false

[sessions]
hashkey = <Schlüssel 5>
blockkey = <Schlüssel 4>


[backend]
# Unter backends können mit Komma getrennt mehrere Backends angegeben werden:
# z. B. backends = backend-1, backend-2, backend-3
backends = backend-1
allowall = false
timeout = 10
connectionsperhost = 8

[backend-1]
url = https://nextcloud.ihre-schule.de
secret = <Schlüssel 3>

#[backend-2]
#url = ...
#secret = ...

[nats]
url = nats://localhost:4222

[mcu]
type = janus
url = ws://127.0.0.1:8188

[turn]
apikey = <Schlüssel 2>
secret = <Schlüssel 1>
servers = turn:signaling.ihre-schule.de:3478?transport=udp,turn:signaling.ihre-schule.de:3478?transport=tcp

Den Signal-Server als Dienst konfigurieren

cp /opt/nextcloud-spreed-signaling/dist/init/systemd/signaling.service /etc/systemd/system/signaling.service

Signal-Server als Dienst aktivieren und starten

systemctl daemon-reload
systemctl enable signaling
systemctl start signaling

Installation und Konfiguration von NGINX

Der NGINX-Webserver dient als Reverse-Proxy für den Signaling-Server.

Notwendige Pakete installieren

apt install nginx python3-certbot-nginx -y

vHost-Eintrag erzeugen

vim /etc/nginx/sites-available/signaling
Datei /etc/nginx/sites-available/signaling
# Achtung: Domänennamen anpassen!
upstream signaling {
    server 127.0.0.1:8080;
}

server {
    listen 80;
    server_name signaling.ihre-schule.de;
    add_header Strict-Transport-Security "max-age=63072000; includeSubdomains; preload";

location /standalone-signaling/ {
        proxy_pass http://signaling/;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    location /standalone-signaling/spreed {
        proxy_pass http://signaling/spreed;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

}

vHost aktivieren und NGINX neu starten

ln -s /etc/nginx/sites-available/signaling /etc/nginx/sites-enabled/signaling
systemctl reload nginx

Lets-Encrypt-Zertifikat mit certbot generieren

# Achtung: Domäne anpassen!
# Bei Durchlauf der Certbot-Routine die Frage nach dem HTTP-Redirect
# mit dem Wert "2", also dem Redirect aller Anfragen auf HTTPS, beantworten.

certbot --authenticator standalone --installer nginx -d signaling.ihre-schule.de --pre-hook "service nginx stop" --post-hook "service nginx start"

NGINX neu starten

systemctl reload nginx

Abschluss der Installation

# Starten Sie zum Abschluss der Installation den Server neu
reboot

Fehlersuche

# Einen ersten Anhaltspunkt bei fehlern geben die Logdateien der Dienste
# Coturn, Janus und Signaling:

journalctl -u coturn.service
journalctl -u janus.service
journalctl -u signaling.service

# Mit dem Parameter -b werden die Logdateien auf Ereingisse 
# seit dem letzten Bootvorgang beschränkt. 
# Mit dem Parameter -f wird das Ende der Logdatei und während der Anzeige
# hinzugekommene Ereignisse angezeigt.

journalctl -u coturn.service -b -f
journalctl -u janus.service -b -f
journalctl -u signaling.service -b -f

Nextcloud für die Verwendung von Spreed konfigurieren

Zunächst muss unter den Nextcloud-Apps die Talk-App installiert und aktiviert sein.

Unter Einstellungen / Talk sind dann folgende Informationen - angepasst an Ihre Daten - zu hinterlegen:

  • STUN-Server:
    • Server/Port: signaling.ihre-schule.de:3478
  • TURN-Server:
    • Server/Port: signaling-ihre-schule.de:3478
    • Secret: <Schlüssel 1>
  • Hochleistungs-Backend
    • Server: https://signaling.ihre-schule.de/standalone-signaling
    • Haken bei: SSL-Zertifikat überprüfen
    • Geteiltes Geheimnis: <Schlüssel 3>

Letzte Aktualisierung der Seite: 2021-10-24 15:34