Nextcloud HPB: Talk / Signaling - Server v. 2.x

Mit Nextcloud und dem High Performance Backend (HPB: Nextcloud Talk-App und Nextcloud Signaling-Server), können Sie Präsentationen, Desktopsharing, Videokonferenzen, Telefonate und Chats – alles mit Ihrer selbstgehosteten Nextcloud – sicher und datenschutzkonform anbieten und federiert mit anderen Anwendern anderer Cloudinstanzen kommunizieren.

Zögern Sie nicht länger und zeigen Sie WhatsApp, Skype, Teams und Anderen, wie sichere Kommunikation einfach funktioniert.

Ein dedizierter Server, basierend auf Ubuntu 22/24.x LTS (64Bit) oder Debian 12 wird sowohl aus Last-, als auch aus Performancegründen benötigt.

Der Signalingserver ist über eine eigene (Sub-)Domain aus dem Internet erreichbar und sollte diese Mindestvoraussetzungen erfüllen: Ubuntu 22/24.x LTS o. Debian 12, 4 CPU Cores, 16GB RAM und 1GBit/s (up/down).

Auch auf schwächerer Hardware lässt sich der Signaling Server betreiben, es kann allerdings zu Einbußen bzgl. der Performance und der Konferenzteilnehmeranzahl kommen.

Letzte Aktualisierungen:
» 01. Oktober 2024
libsrtp2-1_2.6.0-1_amd64.deb (Debian)
go1.23.1.linux-amd64.tar.gz
Nextcloud HPB v. 2.x

Hinweis:
Wir empfehlen und unterstützen nur drei separate Server, also einen Nextcloud Server, einen Signaling-Server und einen coturn-Server!

Beginnen wir nun und melden uns per SSH und als Benutzer mit sudo-Berechtigungen am System an.

sudo -s

Tragen Sie Ihre öffentliche/statische IP-Adresse und ihre Domäne in die Datei /etc/hosts ein:

nano /etc/hosts

...
127.0.1.1 ihresignaling.domain.de
...
<öffentliche IP-Adresse> ihresignaling.domain.de

Öffnen Sie den Port 80/tcp und Port 443/tcp in Ihrer UFW (Firewall),

ufw allow 80/tcp comment "LetsEncrypt"
ufw allow 443/tcp comment "Nextcloud HPB"
ufw allow 32769:65535/udp comment "Nextcloud HPB"

Für die Einrichtung der benötigten Komponenten werden unterschiedliche Keys benötigt. In Ergänzung zum coturn-Secret generieren wir noch vier weitere Keys:

Schlüssel	Befehl zum Generieren
TURN/static-auth-secret (siehe coturn-Anleitung » …`coturn-secret`)	openssl rand -hex 32
JANUS-API-KEY	openssl rand -base64 16
HASH-KEY	openssl rand -hex 16
BLOCK-KEY	openssl rand -hex 16
Nextcloud-SECRET-KEY	openssl rand -hex 16

Wir fahren mit der Installation notwendiger Softwarereleases fort:

git
go 1.23.1
make
protobuf-compiler >= 3

cd /usr/local/src

UBUNTU 22/24:
wget http://ubuntu-master.mirror.tudos.de/ubuntu/pool/universe/libs/libsrtp2/libsrtp2-1_2.5.0-3_amd64.deb

DEBIAN 12:
wget http://ftp.de.debian.org/debian/pool/main/libs/libsrtp2/libsrtp2-1_2.6.0-1_amd64.deb

UBUNTU 22/24 und DEBIAN 12:
wget https://go.dev/dl/go1.23.1.linux-amd64.tar.gz
tar -xvf go1.23.1.linux-amd64.tar.gz
mv go /usr/local

Öffnen Sie die Datei

nano /root/.bashrc

und fügen Sie Folgendes am Ende ein:

[…]
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export PATH=$GOPATH/bin:$GOROOT/bin:$PATH

Schließen Sie die Datei und lesen Sie diese neu ein:

source /root/.bashrc

Fahren Sie fort:

apt install -y libnspr4 libnss3
dpkg -i libsrtp2*.deb

Um den Sgnaling-Server installieren zu können müssen wir diesen selbst Kompilieren:

apt install -y git make protobuf-compiler
cd /etc/
git clone https://github.com/strukturag/nextcloud-spreed-signaling.git
cd /etc/nextcloud-spreed-signaling
make build

Nach wenigen Minuten ist der build abgeschlossen und die Konfiguration kann angepasst werden:

cd /etc/nextcloud-spreed-signaling
cp server.conf.in server.conf
nano server.conf

Bearbeiten Sie die folgenden Bereiche:

[http]
# IP and port to listen on for HTTP requests.
# Comment line to disable the listener.
listen = 127.0.0.1:8080
...
[sessions]
# Secret value used to generate checksums of sessions. This should be a random
# string of 32 or 64 bytes.
hashkey = <HASH-KEY>
...
# Optional key for encrypting data in the sessions. Must be either 16, 24 or
# 32 bytes.
# If no key is specified, data will not be encrypted (not recommended).
blockkey = <BLOCK-KEY>
...
[backend]
# Comma-separated list of backend ids from which clients are allowed to connect
# from. Each backend will have isolated rooms, i.e. clients connecting to room
# "abc12345" on backend 1 will be in a different room than clients connected to
# a room with the same name on backend 2. Also sessions connected from different
# backends will not be able to communicate with each other.
backends = backend1
...
secret = <Nextcloud-SECRET-KEY>
...
[backend1]
# URL of the Nextcloud instance
url = https://ihrenextcloud.domain.de
# Shared secret for requests from and to the backend servers. This must be the
# same value as configured in the Nextcloud admin ui.
secret = <Nextcloud-SECRET-KEY>
...
[nats]
# Url of NATS backend to use. This can also be a list of URLs to connect to
# multiple backends. For local development, this can be set to ":loopback:"
# to process NATS messages internally instead of sending them through an
# external NATS backend.
url = nats://localhost:4222

[mcu]
# The type of the MCU to use. Currently only "janus" and "proxy" are supported.
# Leave empty to disable MCU functionality.
type = janus

# For type "janus": the URL to the websocket endpoint of the MCU server.
# For type "proxy": a space-separated list of proxy URLs to connect to.
#url =
url = ws://127.0.0.1:8188
...
[turn]
# API key that the MCU will need to send when requesting TURN credentials.
apikey = <JANUS-API-KEY>
# secret = Ihr zuvor selbst generierter <Janus-API-Key>

# The shared secret to use for generating TURN credentials. This must be the
# same as on the TURN server.
secret = <TURN/static-auth-secret>
# secret = Ihr zu Beginn selbst generierters coturn-static-auth-secret

# A comma-separated list of TURN servers to use. Leave empty to disable the
# TURN REST API.
#servers = turn:1.2.3.4:9991?transport=udp,turn:1.2.3.4:9991?transport=tcp
servers = turn:coturn.domain.de:443?transport=udp,turn:coturn.domain.de:443?transport=tcp
...

Die gesamte server.conf-Datei sieht ohne die Defaultwerte wie folgt aus:

[http]
listen = 127.0.0.1:8080
[https]
certificate = /etc/nginx/ssl/server.crt
key = /etc/nginx/ssl/server.key
[app]
debug = false
[sessions]
hashkey = <hash-key>
blockkey = <block-key>
[clients]
internalsecret = the-shared-secret-for-internal-clients
[backend]
backends = backend1
allowall = false
secret = <nextcloud-secret>
timeout = 10
connectionsperhost = 8
[backend1]
url = https://ihre.domain.de
secret = <nextcloud-secret-key>
[nats]
url = nats://localhost:4222
[mcu]
type = janus
url = ws://127.0.0.1:8188
[turn]
apikey = <janus-api-key>
secret = <TURN/static-auth-secret>
servers = turn:coturn.domain.de:443?transport=udp,turn:coturn.domain.de:443?transport=tcp
[geoip]
[geoip-overrides]
[stats]

Es folgt die Janus Installation

apt install -y janus

gefolgt von der Konfiguration

nano /etc/janus/janus.jcfg

Passen Sie die Konfiguration wie folgt an:

nat: {
stun_server = "coturn.domain.de"
stun_port = 443
...
full_trickle = true
...
turn_rest_api_key = "<JANUS-API-KEY>"
...

Janus wird nur lokal angesprochen und daher wie folgt konfiguriert:

nano /etc/janus/janus.transport.http.jcfg

...
interface = "lo"
...

Ebenfalls für den Websocket

nano /etc/janus/janus.transport.websockets.jcfg

...
ws_interface = "lo"
...

Um NATS verwenden zu können, bereiten wir das System noch für Docker-CE vor:

apt remove docker docker-engine docker.io

apt install -y apt-transport-https ca-certificates curl software-properties-common

Ubuntu:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

DEBIAN:

curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Ubuntu und Debian:

apt update && apt install -y docker-ce

Laden Sie nun NATS als Docker herunter:

docker pull nats:latest

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

Richten wir nun den Webserver ein.

curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

UBUNTU:

echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/mainline/ubuntu `lsb_release -cs` nginx" | sudo tee /etc/apt/sources.list.d/nginx.list

DEBIAN:

echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/mainline/debian `lsb_release -cs` nginx" | sudo tee /etc/apt/sources.list.d/nginx.list

UBUNTU und DEBIAN:

apt update && apt install -y ssl-cert ca-certificates nginx socat jq

systemctl enable nginx.service

openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak && touch /etc/nginx/nginx.conf

nano /etc/nginx/nginx.conf

Kopieren Sie den gesamten nachfolgenden Inhalt in die Datei:

user www-data;
worker_processes auto;
pid /var/run/nginx.pid;
events {
  worker_connections 2048;
  multi_accept on; use epoll;
  }
http {
  log_format criegerde escape=json
  '{'
    '"time_local":"$time_local",'
    '"remote_addr":"$remote_addr",'
    '"remote_user":"$remote_user",'
    '"request":"$request",'
    '"status": "$status",'
    '"body_bytes_sent":"$body_bytes_sent",'
    '"request_time":"$request_time",'
    '"http_referrer":"$http_referer",'
    '"http_user_agent":"$http_user_agent"'
  '}';
  server_names_hash_bucket_size 64;
  access_log /var/log/nginx/access.log criegerde;
  error_log /var/log/nginx/error.log warn;
  set_real_ip_from 127.0.0.1;
  real_ip_header X-Forwarded-For;
  real_ip_recursive on;
  include /etc/nginx/mime.types;
  default_type application/octet-stream;
  sendfile on;
  send_timeout 3600;
  tcp_nopush on;
  tcp_nodelay on;
  open_file_cache max=500 inactive=10m;
  open_file_cache_errors on;
  keepalive_timeout 65;
  reset_timedout_connection on;
  server_tokens off;
  resolver 127.0.0.53 valid=30s;
  resolver_timeout 5s;
  include /etc/nginx/conf.d/*.conf;
  }

und legen notwendige Verzeichnisse an:

mkdir -p /var/www/letsencrypt/.well-known/acme-challenge /etc/letsencrypt/rsa-certs /etc/letsencrypt/ecc-certs

Erstellen Sie die notwendigen vHost-Dateien an:

[ -f /etc/nginx/conf.d/default.conf ] && mv /etc/nginx/conf.d/default.conf /etc/nginx/conf.d/default.conf.bak

touch /etc/nginx/conf.d/default.conf
touch /etc/nginx/conf.d/http.conf
touch /etc/nginx/conf.d/ihresignaling.domain.de.conf

nano /etc/nginx/conf.d/http.conf

Kopieren Sie alle nachfolgenden Zeilen in die Datei http.conf und passen die rot markierten Werte entsprechend Ihres Systems an:

server {
listen 80 default_server;
listen [::]:80 default_server;
server_name ihresignaling.domain.de;
root /var/www;
location ^~ /.well-known/acme-challenge {
default_type text/plain;
root /var/www/letsencrypt;
}
location / {
return 301 https://$host$request_uri;
}
}

Wechseln Sie in die signaling-vHost-Datei:

nano /etc/nginx/conf.d/ihresignaling.domain.de.conf

und kopieren den nachfolgenden Text in diese Datei. Passen Sie die roten Werte an.

upstream signaling {
server 127.0.0.1:8080;
}
server {
listen 443 ssl;
listen [::]:443 ssl;
http2 on;
server_name ihresignaling.domain.de;
ssl_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
ssl_certificate_key /etc/ssl/private/ssl-cert-snakeoil.key;
ssl_trusted_certificate /etc/ssl/certs/ssl-cert-snakeoil.pem;
#ssl_certificate /etc/letsencrypt/rsa-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/rsa-certs/privkey.pem;
#ssl_certificate /etc/letsencrypt/ecc-certs/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/ecc-certs/privkey.pem;
#ssl_trusted_certificate /etc/letsencrypt/ecc-certs/chain.pem;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
ssl_protocols TLSv1.3 TLSv1.2;
ssl_ciphers 'TLS-CHACHA20-POLY1305-SHA256:TLS-AES-256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384';
ssl_ecdh_curve X448:secp521r1:secp384r1; 
ssl_prefer_server_ciphers on;
ssl_stapling on;
ssl_stapling_verify on;
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;
}
}

service nginx restart

Bitte stellen Sie sicher, dass Ihr Server sowohl über Port 80/TCP als auch über Port 443/TCP von außen erreichbar ist. Das Erstellen und Aktualisieren von Let’s Encryptzertifikaten erfolgt zwingend über http und Port 80! Für das Zertifikatshandling erstellen wir nun einen dedizierten Benutzer und fügen diesen der www-data Gruppe hinzu:

adduser --disabled-login acmeuser

usermod -a -G www-data acmeuser

Diesem technischen Benutzer erteilen wir noch die notwendigen Berechtigungen, um bei einer Zertifikatserneuerung den notwendigen Webserverstart initiieren zu können.

visudo

In der Mitte der Datei, unterhalb von

[..]
User privilege specification
root ALL=(ALL:ALL) ALL
[...]

tragen Sie die folgende Zeile ein:

acmeuser ALL=NOPASSWD: /bin/systemctl reload nginx.service

Mit STRG+X gefolgt von einem y speichern und verlassen Sie diese Datei.

Wechseln Sie in die Shell des neuen Benutzers (acmeuser) um die Zertifikatssoftware zu installieren und verlassen diese Shell danach wieder:

apt install -y socat

su - acmeuser

curl https://get.acme.sh | sh

exit

Passen Sie die entsprechenden Berechtigungen an, um die neuen Zertifikate darin speichern zu können:

chmod -R 775 /var/www/letsencrypt /etc/letsencrypt && chown -R www-data:www-data /var/www/ /etc/letsencrypt

Setzen Sie Let’s Encrypt als Standard CA.

su - acmeuser -c ".acme.sh/acme.sh --set-default-ca --server letsencrypt"

Wechseln Sie erneut in die Shell des neuen Benutzers

su - acmeuser

und requestieren (beantragen) die SSL-Zertifikate. Ersetzen Sie dabei ihre.domain.de mit Ihrer Domain :

acme.sh --issue -d ihresignaling.domain.de --server letsencrypt --keylength 4096 -w /var/www/letsencrypt --key-file /etc/letsencrypt/rsa-certs/privkey.pem --ca-file /etc/letsencrypt/rsa-certs/chain.pem --cert-file /etc/letsencrypt/rsa-certs/cert.pem --fullchain-file /etc/letsencrypt/rsa-certs/fullchain.pem --reloadcmd "sudo /bin/systemctl reload nginx.service"

acme.sh --issue -d ihresignaling.domain.de --server letsencrypt --keylength ec-384 -w /var/www/letsencrypt --key-file /etc/letsencrypt/ecc-certs/privkey.pem --ca-file /etc/letsencrypt/ecc-certs/chain.pem --cert-file /etc/letsencrypt/ecc-certs/cert.pem --fullchain-file /etc/letsencrypt/ecc-certs/fullchain.pem --reloadcmd "sudo /bin/systemctl reload nginx.service"

Verlassen Sie die Shell des neuen Benutzers

exit

Entfernen Sie Ihre bisher verwendeten Self-Signed-Zertifikate aus nginx und aktivieren Sie die neuen, vollwertigen und bereits gültigen SSL Zertifikate von Let’s Encrypt. Starten Sie dann den Webserver neu:

sed -i '/ssl-cert-snakeoil/d' /etc/nginx/conf.d/ihresignaling.domain.de.conf
sed -i s/#\ssl/\ssl/g /etc/nginx/conf.d/ihresignaling.domain.de.conf
service nginx restart

Wir setzen einen eigenen stun-/coturn-Server voraus. Überprüfen Sie Ihren stun-/coturn-Server über diesen externen Link. Fügen Sie, wie im Beispiel dargestellt, anstatt des Beispiels „stun:coturn.domain.de:443″ ihren Domainnamen und Port ein.

Werden Ihnen Einträge vom Typ „srflx“ und in der Spalte ‚Priority‘ in der letzten Zeile „Done“ angezeigt, so funktioniert ihr coturn-Server einwandfrei! Nur in diesem Fall fahren wir mit der Installation und Einrichtung fort.

Nun starten wir den Signaling-Server. Beginnen wir mit Janus-Service:

service janus restart

Die Software wird initial manuell gestartet:

cd /etc/nextcloud-spreed-signaling

./bin/signaling --config server.conf

Startet die Anwendung fehlerfrei, so beenden wir diese (STRG+c) und richten sowohl einen technischen Benutzer, als auch einen neuen Systemdienst ein:

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

Die Konfigurationsdatei des Servers wird persistent gesichert, um auch bei Updates nicht überschrieben zu werden. Des Weiteren werden die entsprechenden Berechtigungen gesetzt:

mkdir -p /etc/signaling
cp server.conf /etc/signaling/server.conf
chmod 600 /etc/signaling/server.conf
chown signaling: /etc/signaling/server.conf

Der Dienst wird nun wie folgt erstellt:

nano /etc/nextcloud-spreed-signaling/dist/init/systemd/signaling.service

Bitte kopieren Sie den gesamten Text hinein:

[Unit]
Description=Nextcloud Talk signaling server
After=janus.service

[Service]
ExecStart=/etc/nextcloud-spreed-signaling/bin/signaling --config /etc/signaling/server.conf
User=signaling
Group=signaling
Restart=on-failure

# Makes sure that /etc/signaling is owned by this service
ConfigurationDirectory=signaling

# Hardening - see systemd.exec(5)
CapabilityBoundingSet=
ExecPaths=/etc/nextcloud-spreed-signaling/bin/signaling /usr/lib
LockPersonality=yes
MemoryDenyWriteExecute=yes
NoExecPaths=/
NoNewPrivileges=yes
PrivateDevices=yes
PrivateTmp=yes
PrivateUsers=yes
ProcSubset=pid
ProtectClock=yes
ProtectControlGroups=yes
ProtectHome=yes
ProtectHostname=yes
ProtectKernelLogs=yes
ProtectKernelModules=yes
ProtectKernelTunables=yes
ProtectProc=invisible
ProtectSystem=strict
RemoveIPC=yes
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
RestrictNamespaces=yes
RestrictRealtime=yes
RestrictSUIDSGID=yes
SystemCallArchitectures=native
SystemCallFilter=@system-service
SystemCallFilter=~ @privileged

[Install]
WantedBy=multi-user.target

Abschließend wird der Dienst am Server registriert und gestartet:

cp /etc/nextcloud-spreed-signaling/dist/init/systemd/signaling.service /etc/systemd/system/signaling.service
systemctl enable signaling.service && systemctl start signaling.service

Prüfen Sie, ob das HPB wie erwartet antwortet:

https://ihresignaling.domain.de/standalone-signaling/api/v1/welcome

Die Antwort sollte wie folgt aussehen, die Version entspricht der verwendeten Version.

Die Version (in diesem Beispiel „47ad…“) können Sie bei Nextclouds GIT abgleichen.

Wechseln Sie nun in Ihre Nextcloud: aktivieren und konfigurieren als Nextcloud-Administrator die Nextcloud-Talk-App wie folgt.

STUN-Server:

* coturn.domain.de:443

TURN-Server:

* turn und turns
* coturn.domain.de:443
* TURN/coturn-static-auth-secret
* UDP und TCP

Signaling-Server:

* https://ihresignaling.domain.de/standalone-signaling/
* Nextcloud-SECRET-KEY

Herzlichen Glückwunsch! Sie haben ihre Nextcloud um einen Signaling-Server und somit um die Nextcloud- Talk Funktionalitäten erfolgreich erweitert! Über Ihre Unterstützung (diese wird ordnungsgemäß versteuert!) würden sich meine Frau, meine Zwillinge und ich sehr freuen. Vorab vielen Dank!