DecaTec

Home-Server | Linux | Nextcloud | Raspberry Pi | Programmierung | Fotografie

Nextcloud Talk mit eigenem Signaling-Server (High Performance Backend)

Nextcloud Talk Logo

Nextcloud unterstützt mit Nextcloud Talk schon seit längerem Video-Konferenzen. Zu diesem Thema gab es hier im Blog bereits einen Artikel, wie man Nextcloud Talk mit eigenem TURN-Server (coturn) aufsetzen kann: Nextcloud Talk mit eigenem TURN-Server (coturn).

Leider hatte die Lösung einen Haken: Video-Chats mit mehr als vier bis fünf Personen waren hier nicht möglich. Nextcloud hat hier immer ab einer gewissen Teilnehmerzahl eine Warnung ausgegeben und man konnte darauf warten, dass die Verbindung irgendwann abbricht.

Dennoch gab es hier Potential nach oben: Mit dem sog. High Performance Backend für Nextcloud sind Video-Konferenzen mit sehr viel mehr Teilnehmern möglich. Hier benötigte man jedoch immer eine Nextcloud Enterprise-Subscription, die sich aber für die eigene Familien-Cloud preislich nicht gelohnt hat.

Nun hat sich Nextcloud mit seinem Partner Struktur AG dazu entschlossen, diese Vorteile an die Community weiterzugeben. Ab sofort ist der Teil des High Performance Backends, welche für Talk interessant ist, als Open Source verfügbar (siehe Nextcloud Blog). Genauer gesagt handelt es sich dabei um den sog. Signaling Server.

Die Installation ist aber nicht gerade trivial, so dass es hier bisher noch sehr wenige Anleitungen gibt. Daher soll dieser Artikel nun die Installation und Konfiguration des Signaling Servers und dessen Einbindung in Nextcloud beschreiben.

Update-Historie (letztes Update: 03.09.2020)
  • 03.09.2020:
    • Signaling-Konfiguration: Definition des Backends (neuere Versionen des Signaling Servers).
  • 28.07.2020:
    • Empfehlung für Ubuntu Server 20.04, Hinweise für ältere Versionen ergänzt.
  • 14.07.2020:
    • STUN-Server zur Janus-Konfiguration hinzugefügt.

Voraussetzungen

Für die Installation eines eigenen Signaling Server gelten folgende Voraussetzungen:

Server

Die Hardware, auf dem der Signaling Server betrieben wird, sollte folgende Voraussetzungen erfüllen:

  • 4 CPU Cores
  • 16 GB RAM
  • 1 GBit/s Netzwerk (Up und Down)

Auf schwächerer Hardware lässt sich der Signaling Server auch betreiben, hier kann es allerdings zu Einbußen bzgl. Performance und Teilnehmerzahl kommen.

Betriebssystem/Distribution

Ich verwende für diesen Artikel Ubuntu Server 20.04 LTS. Für ältere Versionen der Distribution (z.B. 18.04) ist das gezeigte Vorgehen so nicht umsetzbar, da die in den Paketquellen enthaltene Version von Janus zu alt ist. Hier muss man u.U. auf Backports von Janus aufsetzen.

Daher empfehle ich für einen Signaling Sever den einsatz vom Ubtuntu Server 20.04 LTS.

Software/Webserver/Domain

Für diesen Artikel setze ich ebenfalls folgendes Voraus:

Beispielhaft nutze ich in diesem Artikel die Domain signaling.meinedomain.de für den Signaling Server. Der verwendete TURN-Server (coturn) ist unter turn.meinedomain.de erreichbar. Nextcloud selbst hat die fiktive URL nextcloud.meinedomain.de.

Installation des Signaling Servers

Der Signaling Server (bzw. das sog. High Performance Backend für Nextcloud) besteht aus mehreren Komponenten:

Keys erzeugen

Für die Einrichtung der verschiedenen Komponenten werden unterschiedliche Keys benötigt, die wir hier im Vorfeld generieren können:

  • 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

Am besten man erstellt diese Keys und speichert sich diese irgendwo sicher ab.

Im weiteren Verlauf dieses Artikels wird auf diese Keys immer in spitzen Klammern verwiesen (z.B. <Janus API-Key>).

Daneben wird noch der Turn-Server-Key benötigt, der bei der Einrichtung von coturn vergeben wird (Variable static-auth-secret in der Datei /etc/turnserver.conf). Diesen sollte man nun auch nochmal raus suchen und mit den anderen Keys notieren.

libSRTP

Janus benötigt eine recht aktuelle Version des Pakets libsrtp2-1. Die in den Ubuntu Paketquellen enthaltene Version ist hier leider zu alt, so dass man hier eine manuelle Installation per DEB-Datei (aus dem kommenden Ubuntu-Release) vornehmen muss:

cd /tmp
wget http://de.archive.ubuntu.com/ubuntu/pool/universe/libs/libsrtp2/libsrtp2-1_2.3.0-4_amd64.deb
apt install /tmp/libsrtp2-1_2.3.0-4_amd64.deb
rm libsrtp2-1_2.3.0-4_amd64.deb

Signaling Server

Als nächstes kann ich schon der Signaling Server installiert werden. Hier gibt es keine fertigen Pakete, so dass man sich die Software selbst bauen muss:

apt install golang-go
cd /etc/
git clone https://github.com/strukturag/nextcloud-spreed-signaling.git
cd /etc/nextcloud-spreed-signaling
make build

Nach ein paar Augenblicken sollte der Build durchgelaufen sein.

Anschließend muss die Konfigurations-Datei angepasst werden:

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

Die Datei ist in verschiedene Sektionen aufgeteilt:

  • Sektion „http“:
    • Hier wird die IP und der Port angegeben (diese Zeile muss daher einfach einkommentiert werden):
      listen = 127.0.0.1:8080
  • Sektion „sessions“:
    • Angabe des Hash-Keys (s.o.):
      hashkey = <Hash-Key>
    • Angabe des Block-Keys (s.o.):
      blockkey = <Block-Key>
  • Sektion „backend“:
    • Hier wird die URL der Cloud-Instanz als sog. Backend angegeben, so dass nur diese auf den Signaling Server zugreifen kann.
    • Dazu trägt man das Backend unter backends ein (der Name ist hier eigtnlich egal):
      backends = backend1
    • Weiter unten wird dieses Backend dann definiert:
      [backend1]
      # URL of the Nextcloud instance
      url = https://cloud.meinedomain.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>
    • Der Name des Backends ist hier „backend1“ (angegeben in eckigen Klammern) und muss dem Namen entsprechen, welcher weiter oben unter „backends“ angegeben wurde.
  • Sektion „mcu“:
    • Hier wird die Verbindung zum Websocket von Janus festgelegt:
      type = janus
      url = ws://127.0.0.1:8188
  • Sektion „turn“:
    • Hinzufügen des Janus API-Keys:
      apikey = <Janus API-Key>
    • Hinzufügen des Secret Keys vom TURN-Server (coturn):
      secret = <Turn-Server-Key>
    • Angabe der TURN-Server-URL:
      servers = turn:turn.meinedomain.de:5349?transport=udp,turn:turn.meinedomain.de:5349?transport=tcp

Hinweis: Die Variable allowall sollte aus Gründen der Sicherheit in dieser Konfoguration immer auf false gesetzt werden. Die einzige Ausnahme besteht zum Testen des Signaling Servers mittels des mitgelieferten Clients (siehe unten).

Bevor wir den Signaling Server nun starten können, müssen die restlichen Programme installiert werden.

Janus

Die Installation erfolgt hier über einen Befehl:

apt install janus

Anschließend müssen hier ebenfalls die Konfigurations-Dateien bearbeitet werden:

nano /etc/janus/janus.jcfg

Hier konfigurieren wir den STUN-Server (coturn), aktivieren die Option „Full Trickle“ und tragen den API-Key ein:

# ...
stun_server = "turn.meinedomain.de"
stun_port = 5349
# ...
full_trickle = true
# ...
turn_rest_api_key = "<Janus API-Key>"
# ...

Anschließend wird Janus so konfiguriert, dass es nur lokal (d.h. nicht über das Netzwerk) angesprochen werden kann:

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

Das Interface wird dabei auf „lo“ gesetzt:

# ...
interface = "lo" 
# ..

Das gleiche wird auch für den Websocket gemacht:

nano /etc/janus/janus.transport.websockets.jcfg
# ...
ws_interface = "lo"
# ...

NATS

Ebenfalls benötigt wird ein NATS-Server. Diesen Installieren wir der Einfachheit halber mittels Docker:

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

Hier muss weiter nichts konfiguriert werden, der Docker-Cointainer wird nur so angelegt, dass dieser beim Systemstart automatisch mit gestartet wird.

nginx

Nun muss nich dafür gesorgt werden, dass der Signaling Server durch nginx (oder einen anderen Webserver) erreichbar ist. Hierzu bearbeiten wir den virtuellen Host, der die Signaling-Domain bedient:

nano /etc/nginx/conf.d/signaling.meinedomain.de.conf

Hier werden nun der Upstream zu Signaling Server selbst und zwei location-Blöcke hinzugefügt. Die erweiterte Konfiguration des vHosts (z.B. SSL- bzw. Header-Konfiguration) wird an dieser Stelle nicht weiter behandelt.

upstream signaling {
    server 127.0.0.1:8080;
}

server {
        listen 443 ssl http2;
        listen [::]:443 ssl http2;
        server_name signaling.meinedomain.de;

        # SSL and header configuration omitted

        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;
        }
}

Nach einem Neustart von nginx ist dieser Teil auch abgeschlossen:

service nginx restart

Starten des Signaling Servers

Nun kommt der spannende Teil: Wir starten zum ersten mal den Signaling Server!
Dazu wird erst einmal der Janus-Dienst neu gestartet:

service janus restart

Anschließend wird das Programm für einen ersten Test im Vordergrund aufgerufen:

cd /etc/nextcloud-spreed-signaling 
./bin/signaling --config server.conf

Hier wird u.U. sehr viel Output erzeugt, aber es sollten keine Fehler darunter zu finden sein.

Signaling Server als Systemdienst

Damit der Signaling Server nicht jedes Mal über die Konsole im Vordergrund gestartet werden muss, sollte dieser als Systemdienst installiert werden. Dazu stoppen wir erst einmal die Konsolen-Instanz.

Zunächst legen wir uns einen speziellen User für den Signaling Server an:

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

Anschließend wird die Konfigurationsdatei des Servers noch an einen anderen Ort kopiert (damit diese z.B. bei Update nicht überschrieben wird). Ebenso 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

Nun editieren wir noch die Datei für den Systemdienst:

nano dist/init/systemd/signaling.service

Folgendes ist hier einzutragen:

[Unit]
Description=Nextcloud Talk signaling server

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

[Install]
WantedBy=multi-user.target

Der Dienst wird im System registriert und aktiviert:

cp dist/init/systemd/signaling.service /etc/systemd/system/signaling.service
systemctl enable signaling.service
systemctl start signaling.service

Anschließend wir der Signaling Server immer beim Systemstart mit geladen.

Einbinden des Signaling Servers in Nextcloud

Die Konsole packen wir erst einmal bei Seite und hinterlegen den neuen Signaling Server in der Nextcloud-Instanz. Dies geschieht unter Einstellungen > Talk. Ganz unten wird nun ein Signaling Server mit dem Plus-Zeichen hinzugefügt. Die Domain lautet hierfür https://signaling.meinedomain.de/standalone-signaling. Unter Gemeinsames Geheimnis wird nun der Nextcloud Secret Key hinterlegt, den wir ganz am Anfang erzeugt haben:

Hinterlegen des Signaling Servers in der Nextcloud Talk Konfiguration

Hinterlegen des Signaling Servers in der Nextcloud Talk Konfiguration

Die Option SSL Zertifikat überprüfen sollte hier aktiviert werden, wenn der Signaling Server über ein valides Zertifikat verfügt (z.B. Let’s Encrypt).

Anschließend sollte man Talk mit einer Videokonferenz testen. Dazu fragt man am besten einen anderen Cloud-User um Hilfe, oder testet dies einfach über eine Talk-Konferenz mit mehreren Endgeräten (z.B. PC, Notebook, Handy, etc.). Wenn hier Chat- und Videofunktionen gegeben sind, läuft der Signaling Server korrekt.

Benchmark/Test

Für den Signaling Server gibt es ebenfalls einen mitgelieferten Client, mit dem man den Server testen bzw. einen Benchmark ausführen kann.

Dazu muss der Client erst einmal gebaut werden:

cd /etc/nextcloud-spreed-signaling 
make client

Als nächstes muss die Server-Konfiguration noch geändert werden, damit Verbindungen mit den Client möglich sind:

nano /etc/signaling/server.conf

Hier muss in der Backend-Sektion die Variable allowall auf true gesetzt werden, damit keine Einschränkung auf bestimmte Domains besteht.

[backend]
# ...
allowall = true
# ...

Der Service ist dann noch neu zu starten:

service signaling restart

Nun kann mit den Client ein Benchmark durchgeführt werden:

cd /etc/nextcloud-spreed-signaling 
./bin/client -addr localhost:8080

Der Client baut daraufhin 100 Verbindungen zum Server auf und zeigt den Durchsatz an.

Benchmark des Signaling Servers

Benchmark des Signaling Servers

Wichtig ist hier v.a., dass sämtliche Verbindungen zu Stande kommen („All connections established“). Im Hintergrund sieht man, dass das System CPU-seitig ordentlich unter Last gesetzt wird.

Wichtig: Aus Sicherheitsgründen sollte die Variable allowall in der server.conf nach dem Test wieder auf false gesetzt werden (Neustart des Services nicht vergessen).

Fazit

Mit einem eigenen Signaling Server ist es nun mit Nextcloud Talk endlich möglich, Konferenzen mit mehr als vier bis fünf Teilnehmern zu realisieren. Die Installation ist durchaus etwas aufwendiger, aber man hat anschließend eine gute (Video-)Chat-Lösung für die eigene Cloud.

Weiterführende Artikel

Links

, , , , , , , , , , , ,

Kommentare: 111

  • ray sagt:

    Danke erstmal für deine Anleitung.

    Die config unter Ubuntu 20.04 LTS lief problemlos.

    Nextcloud 20 auf einem Server mit cotun –> läuft
    turn von extern testen funktioniert

    Janos, signal und nats auf einem 2ten server –> läuft
    allowall = true und client-test funktioniert, allowall = false natürrlich wieder eingestellt

    Vom Nextcloud-Server ein curl -k -i https://xxxxx.de/standalone-signaling/api/v1/welcome funktioniert auch.

    In der Nextcloud eingetragen funktioniert auch, „OK: Laufende Version: 18c1874333c03425a9a459f23c8cd7238ef8aa28“

    leider geht talk aber nicht ;(

    „Fehler beim Aufbau der Signaling-Verbindung. Versuche erneut…“

    Hat jemand eine Idee woran da sliegen könnte ???

    • Jan sagt:

      Hi,

      von deinen Tests her sieht es erst einmal gut aus. Hier können dir wohl nur die Logs aufzeigen, woran es hapert…

      Gruß,
      Jan

      • foo sagt:

        Joop, ich hab es gefunden …

        Nachdem ich in der Nextcloud verify bei den certs für den Signal-Server aktiviert hatte kam auch ein connect zum Signal-Server und Janos zu stande … da taucht dann im log der Fehler auf, mit debug 7… intermed’s beim cert des Nextcloud-Servers vergessen ….

        Also immer schön darauf achten das alles mit den passenden Cert’s incl. Intermed’s versehen ist !!! Dann geht alles perfekt …

        PS: Danke nochmal für die gute Anleitung hier …

  • Alfred Hamdami sagt:

    Erstmal Danke für die Anleitung, habe aber leider ein Problem,
    (ich sollte erwähnen, das ich eigentlich mit Linux nix am Hut habe….)
    Die Status Abfragen sind OK. Nginx, Signaling, Janus (bindet sich auch an den StunServer) und bei Nats bekomme ich auf ein Ping ein Pong….Nextcloud kann den Signalig Server auch einbinden. Aber der Clienttest geht in die Hose:
    „unsupported message type: {Id: Type:error Error:unsupported_content_type Hello: Room Control Event
    Backend checksum verification failed“
    kannst du mir da vielleicht weiterhelfen?
    Danke Alfred

    • Jan sagt:

      Hallo Alfred,

      das sieht mir so aus, als ob das Backend in der Signaling-Konfiguration nicht richtig hinterlegt/konfiguriert wurde („Backend checksum verification failed“).
      Daher bitte nochmal die Backend-Sektion in der server.confg kontrollieren/anpassen.

      Gruß,
      Jan

  • Alfred Hamdami sagt:

    Hallo Jan,

    vielen Dank für die schnelle Antwort. Das wars…Es hatte sich ein kleiner
    Fehlerteufel eingeschlichen.

    nochmals Danke
    Alfred

  • Harry sagt:

    Hallo Jan,

    der Signaling-Server alleine isf für ein HPB (High Performance Backend) nicht ausreichend. Damit kann vielleicht eine Videokonferenz mit mehr als 4 bis 5 Teilnehmer realisiert werden, aber man kommt sehr schnell ans Limit, insbesondere bei einer Vielzahl von Teilnehmern und mehreren Konferenzräumen, da weiterhin über eine Peer-to-Peer Verbindung gestreamt wird.

    Für ein HPB ist zwingend die Implementierung einer SFU (Select Forwarding Unit) erfordelich.

    Eine SFU ist eine Videokonferenzarchitektur, welche folgende Datenübertragungsprozesse zwischen dem Server und den Endpunkten bietet:

    1. Der Server empfängt eingehende Videostreams von allen Endpunkten.
    2. Der Server sendet mehrere Kopien unkomprimierter Videostreams anderer Teilnehmer an jeden Endpunkt.
    3. Die Endpunkte führen eingehende Videostreams zusammen.

    Dank der SFU muss der Client nicht jedem Teilnehmer das gleiche ausgehende Signal senden, so wie es bei der Peer-to-Peer-Verbindung der Fall ist, sondern der Stream wird an den Server gesendet und an alle Benutzer verteilt. Infolgedessen sendet der Teilnehmer ein ausgehendes Signal und empfängt Streams anderer Benutzer vom Server.

    Für Deine Konfiguration ist das Video-Room-Plugin für Janus geeignet.
    Alternativen von SFU sind Asterisk, Jitsi Videobridge (JVB) etc. etc.

    Mit einer MCU (Multipoint Conferencing Unit) kann ein HPB neben dem Signaling-Server auch realisiert werden, aber die Streams werden bei dieser Videokonferenzarchitektur ständig decodiert und wieder neu codiert, wodurch eine erhebliche Rechenleistung des Servers notwendig ist.

    Viele Grüße
    Harry

    • Jan sagt:

      Hi Harry,

      danke für deine Ausführungen. Wie ich das sehe, ist für den Signaling Server selbst Janus notwendig. Ohne Janus bekommt man das vermutlich gar nicht ans Laufen. Dass hier auch das Video-Room-Plugin genutzt wird, kann ich bestätigen, da bei zu alten Janus-Versionen, die ohne Video-Room-Unterstützung ausgeliefert wurden (z.B. unter Ubuntu 18.04) eine eindeutige Fehlermeldung kommt, dass Video-Rooms nicht unterstützt werden.

      Interessant wäre hier, wie man den Signaling Server mit einer JVB zusammen bringen kann. Hast du hier schon Erfahrungen?

      Gruß,
      Jan

  • Harry sagt:

    Hallo Jan,

    ja, zum Signaling-Server ist zursätzlich ein WebRTC-Server und eine SFU Voraussetzung, damit nicht mehr Peer-To-Peer verwendet wird und die Streams über den Server laufen. Dann können auch 50, einige hundert oder mehr Anwender Talk nutzen.

    Janus WebRTC Server (siehe link)

    https://github.com/meetecho/janus-gateway

    Da hat sich beim gestrigen Post ein kleiner Fehler eingeschlichen.
    Das Video Room Plugin ist nicht zwingend erforderlich.
    Ich meinte natürlich das Janus SFU Plugin (siehe link)

    https://github.com/mozilla/janus-plugin-sfu

    Wir haben ca. 650 Clients und sind wieder weg von Talk und verwenden derzeit Cisco Webex mit 250 Lizenzen, aufgrund fehlender Funktionen, die Talk nicht bieten kann wie z.B. automatische Transkription, Meeting Management, Webcasts, Sitzungsaufzeichnung etc.

    Aber ich werde bei nächster Gelegenheit ein HPB für Nextcloud Talk als Backup-Lösung einrichten, da bei uns der Bedarf an Videokonferenz auf Grund der jetzigen Lage kontinuierlich steigt. Die Cisco Webex Lösung ist zwar sehr gut und ausgereift, aber sehr teuer.

    Viele Grüße
    Harry

  • Adrian Hasler sagt:

    Hallo Jan. Einmal mehr ein tolles Tutorial. Werde nun definitiv bei Nexcloud mit Ubuntu 20.04 gemäss einem anderen Tutorial von Dir umsteigen. Weisst Du, wie dieser Signaling-Server hinter einem Nginx Reverse Proxy betrieben werden kann?

    • Jan sagt:

      Hi Adrian,

      hier wird der Endpunkt für den Signaling-Server in nginx konfiguriert. Dies ist im Prinzip schon eine Proxy-Anweisung. Natürlich kann der Signaling-Server (inkl. Janus usw.) auf einer anderen Maschine als der nginx laufen. In diesem Fall muss der Signaling-Server nur so konfiguriert werden, dass dieser nicht nur auf die lokale IP (127.0.0.1) lauscht.

      Gruß,
      Jan

  • Alfred Hamdami sagt:

    Hallo Jan,
    ich schon wieder…Der Test klappt zwar aber beim Versuch eine Talk Session
    zu starten kommt „Fehler beim Aufbau der Signaling Verbindung“
    1.Frage kann man beim Signaling ein Log einschalten und wenn ja wie?
    ich habe nur ein nginx log mit einem post „POST /standalone-signaling/api/v1/room/“xxxxx“ HTTP/1.1 200 2″ Im Janus log stehen keine Infos.
    2.Frage muss die Chose über Public IP’s laufen oder geht es auch rein Intern ?
    Ich muss zu meiner Ehrenrettung nochmal erwähnen das das alles relatives Neuland für mich ist (ich stand halt noch als die Musik zu spielen aufhörte…)
    viele Grüße
    Alfred

    • Jan sagt:

      Hi Alfred,

      also lokal sollte es funktionieren. Hier kannst du dann nur keine Let’s Encrypt Zertifikate nutzen. Ich kann mir hier auch vorstellen, dass Nextcloud die Einbindung eines Signaling Servers unterbindet, wenn keine „echten“ Zertifikate zum Einsatz kommen.
      Die Janus-Logs müssten im syslog auftauchen. Der beste Weg ist hier vermutlich, den Signaling Server manuell über die Kommandozeile zu starten (also nicht per systemd-Unit). Dann im Browser eine Verbindung aufbauen. Nun solltest du auf der Kommandozeile „im Hintergrund“ einen Output bekommen, der vielleicht eine Fehlermeldung offenbart.

      Gruß,
      Jan

  • Chris sagt:

    Hm. Ich habe jetzt nach längerem Frickeln das HPB zum Laufen bekommen, allerdings habe ich erst nachdem ich in der server.conf bei [mcu] den Wert „type“ einkommentiert und auf „janus“ gesetzt habe. Der Doku zufolge wird nämlich sonst die MCU komplett deaktiviert:
    # The type of the MCU to use. Currently only „janus“ and „proxy“ are supported.
    # Leave empty to disable MCU functionality.
    type = janus

    Der Default ist „type =“, also leer, und damit wohl gar keine MCU konfiguriert.

    Habe ich da einen Denkfehler – wird gar keine MCU benutzt? Wozu dann die Angabe des MCU URL?

    • Jan sagt:

      Hi Chris,

      danke für den Hinweis. Dass bei „type“ nicht mehr automatisch „janus“ angegeben wird, wurde wohl in einer neueren Version des Signaling Servers geändert. Ich habe das gleich mal im Artikel so angepasst.

      Gruß,
      Jan

  • Frank sagt:

    Hello,

    I hope you do not mind that I write in English. I’m from Holland and I can read German, but knowledge is not good enough to write in German. Sorry about that, and no problem if you answer in German….

    I have trouble understanding one point:

    in janus.jcfg we configure the turn_rest_api_key, but we do not configure a turn server and we do not configure a URL to access the api server in this configuration file.

    Also, in the turnserver.conf file of cotrun, I would expect that we have to enable the API server and configure the same secret key? But we do not do that.

    When I start janus, I get the following entry in the logfile:

    [Wed Nov 11 10:10:43 2020] TURN REST API backend: (disabled)

    So, I think something is wrong with the API configuration.

    Do you have any hints or suggestion for me?

    Fortunately, the signaling servers seems to work anyway, although joining a session is a bit slow (did not yet do an extensive test). So, maybe this turn API stuff is not important?

    Kind regards,

    Frank

    p.s.: thank you very much for this extensive and well written documentation. It was very helpful!

    • Jan sagt:

      Hi Frank,

      as I see it, we configure the turn rest API key in the janus configuration and this is the key for the signaling server, not for coturn. Maybe that’s only a naming problem of the variables.

      [Wed Nov 11 10:10:43 2020] TURN REST API backend: (disabled)

      Where exactly you get this output (which log file)?

      Best regards,
      Jan

  • Andre sagt:

    Hallo Jan,
    erstmal ein riesen Kompliment für deine Anleitung. So detailiert findet man eine solche nur selten im Netz. Ich konnte sowohl den Nats, als auch den Janus, Stun/Turn und signaling Server erfolgreich installieren. Den ersten Test habe ich nur mit dem Stun/Turn Server durchgeführt, läuft ohne Probleme. Wenn ich aber den Signaling Server eintrage, lädt die NC Talk App ohne ein Ende zu finden. Der Test mit den 100 Verbindungen läuft aber erfolgreich. Auch die Welcome URL baut die Verbindung auf. Auch in der Syslog gibt es ausschließlich Erfolgmeldungen. Einzige Meldung, die ich finden konnte, war in dem NC Log:
    Client error: `POST https://signaling.domain.com/standalone-signaling/api/v1/room/kzjfjibx` resulted in a `403 Forbidden` response: Authentication check failed
    Für Ideen oder Hinweise wäre ich sehr dankbar!

    Viele Grüße!
    Andre

    • Jan sagt:

      Hi Andre,

      die Infos sind etwas dürftig, ich würde aber zunächst mal die Backend-Konfiguration vom Signaling-Server kontrollieren. Sieht nämlich so aus, als ob nur der Zugriff durch deine Cloud selbst geblockt wird.

      Gruß,
      Jan

      • Andre sagt:

        Hi Jan,

        seltsam, im Backend scheint alles richtig zu sein:
        —————-
        url = https://cloud.mydomain.com
        secret = aabdba7….334
        —————-
        diese Secret habe ich auch als geheimnis bei den Talk Einstellungen beim Signaling Server eingetragen.
        Beim herstellen der Verbindung scheint es auf dem signaling Server zu funktionieren:
        ———Signaling————–
        signaling[27789]: client.go:252: Client from 213.168.83.234 has RTT of 1 ms (1.972382ms)
        Nov 11 12:07:56 srvsignaling01 signaling[27789]: client.go:252: Client from 203.153.83.xxx has RTT of 2 ms (2.612001ms)
        Nov 11 12:07:58 srvsignaling01 signaling[27789]: client.go:252: Client from 203.153.83.xxx has RTT of 2 ms (2.623099ms)
        Nov 11 12:07:59 srvsignaling01 signaling[27789]: client.go:252: Client from 203.153.83.xxx has RTT of 2 ms (2.064688ms)
        Nov 11 12:08:00 srvsignaling01 signaling[27789]: client.go:252: Client from 203.153.83.xxx has RTT of 2 ms (2.059613ms)
        ————————————

        Beim Janus Service sieht es eig. auch gut aus…:

        —————-Janus Service———————
        Nov 11 12:03:31 srvsignaling01 janus[27733]: [WSS-0x7fbdfc000b60] Destroying WebSocket client
        Nov 11 12:03:31 srvsignaling01 janus[27733]: Destroying session 5517310898768157; 0x7fbe54002d70
        Nov 11 12:03:31 srvsignaling01 janus[27733]: Detaching handle from JANUS VideoRoom plugin; 0x7fbe54003fd0 0x7fbdfc001440 0x7fbe54003fd0 0x7fbe54003380
        Nov 11 12:03:31 srvsignaling01 janus[27733]: [janus.plugin.videoroom-0x7fbdfc001440] No WebRTC media anymore; 0x7fbe54003fd0 0x7fbe54003380
        Nov 11 12:03:31 srvsignaling01 janus[27733]: [1507852527871844] Handle and related resources freed; 0x7fbe54003fd0 0x7fbe54002d70
        Nov 11 12:03:31 srvsignaling01 janus[27733]: Creating new session: 3446790375674101; 0x7fbe54002930
        Nov 11 12:03:31 srvsignaling01 janus[27733]: Creating new handle in session 3446790375674101: 4318126726419730; 0x7fbe54002930 0x7fbe54002af0
        ——————————————————

        Sehr seltsam… Ich kann mir nicht erklären, wo der Fehler sein soll.

        Viele Grüße!
        Andre

        • Jan sagt:

          Hi Andre,

          einen direkten Fehler kann ich hier erst einmal nicht erkennen, sorry.
          Aber nochmal zur Kontrolle: In der server.conf definierst du erst einmal ein Backend (z.B. [backend1]). Hier URL deiner Cloud und das Secret eingeben. Dann weiter oben in der backend-Sektion selbst muss dieses Backend noch unter „backends = …“ aufgenommen werden. Hier trage ich dann für gewöhnlich auch nochmal das NC-Secret ein (ein paar Zeilen darunter).

          Gruß,
          Jan

          • Andre sagt:

            Hallo Jan,

            ich habe die Config nun nochmals komplett neu angelegt. jetzt funktioniert es plotzlich. Vermutlich hat sich in der config ein Fehler eingeschlichen.

            Vielen Dank für deine Hilfe!

            Grüße!
            Andre

  • codeling sagt:

    Hallo,

    vielen Dank für die ausführliche Anleitung!
    Bei mir scheitert leider der Client-Test, es kommt pro Verbindungsversuch einmal diese Meldung:
    Unsupported message type: {Id: Type:error Error:Incomplete OCS response Hello: Bye: Room: Message: Control: Event:}

    und einmal diese:
    Received bye: &{Reason:hello_timeout}

    und dann steht der Client, und man kann ihn nur mehr per kill von außen abschießen (Ctrl+C hilft nicht). Habe keine Ahnung was diese Meldung genau bedeuten könnte, und wäre für jede Info was es da haben könnte, sehr dankbar!

    • Jan sagt:

      Hi,

      die Meldung sagt mir nun erst einmal nichts. Hast du mal ausprobiert, die Backports von Janus (siehe hier) zu nutzen? Oftmals kommt es bei älteren Janus-Versionen zu Problemen, vielleicht ist das schon die Lösung.

      Gruß,
      Jan

    • Max sagt:

      Hallo,

      hab leider (vermutlich) das gleiche Problem. Beim Test kommt bei mir:
      Unsupported message type: {Id: Type:error Error:Incomplete OCS response Hello: Bye: Room: Message: Control: Event:}

      Durch den Tipp von Jan (an der Stelle auch noch mal vielen Dank für die Anleitung!!) bin ich auf die neuere Version von Janus gestoßen und hab diese installiert. Extra mit neuen Config-Dateien, die ich dann wieder angepasst habe.
      Leider ist der Fehler gleich geblieben.
      Mach jetzt mit dem Server schon einige Stunden rum. Vielleicht hat ja jemand noch eine Idee. ;)

      Vielen Dank und Gruß
      Max

      • Jan sagt:

        Hi Max,

        hier lohnt es sich meiner Erfahrung nach immer, in der Browser-Console (F12) nach Fehlermeldungen zu suchen. Meist liefert erst das dann einen konkreteren Hinweis. In den Server-Logs findet man hier u.U. nicht viel, da die Verbindung bereits Client-seitig nicht richtig aufgebaut werden kann (daher auch die Suche auf der Client-Seite).

        Gruß,
        Jan

  • Georg sagt:

    Hallo!

    Vielen Dank für die Anleitung – habe sie mit etwas Mühe auf einem Server mit openSUSE Leap 15.2 realisieren können, am schwierigsten war hier Janus zu starten, das klappte erst nach manuellem compilen von Libwebsockets, Austausch des Videotransport Plugins mit dem einer anderen Janusversion, und laden der respektiven Libwebsockets. Scheint nun aber stabil und problemlos zu funktionieren – hoffentlich bleibt das bei etwaigen Package-Updates auch so.

    Eine Frage zur Signaling Software, ich habe die Anleitung mehrfach durchgelesen, entweder übersehe ich etwas, oder der Ersteller hat den Punkt ausgelassen: Es wird die Installation des NATS Servers kurz erklärt, aber nicht, dass man diesen auch in der SIgnaling server.conf eintragen soll. Ich habe dies selbstständig gemacht, unter [nats], frage mich aber ob es einen Grund gibt, warum in der Anleitung NATS lediglich installiert, aber nicht „verknüpft“ wird? Ich habe NATS zwar manuell installiert, und nicht via Docker, dies sollte aber keinen Unterschied machen.

    • Jan sagt:

      Hallo Georg,

      die Option für den NATS-Server ist in der server.conf zwar auskommentiert, dieser wird meiner Erfahrung nach aber dennoch genutzt. Ist denke ich eine Default-Einstellung. Hier braucht man also nur Änderungen an der Option durchführen, wenn z.B. ein anderer Port genutzt wird.

      Gruß,
      Jan

1 2

Schreibe einen Kommentar

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