Nextcloud/Talk/HPB: Unterschied zwischen den Versionen

Aus Foxwiki
Subpages:
Versionsgeschichte interaktiv durchsuchen
← Zum vorherigen Versionsunterschied
VisuellWikitext
JoergNolte (Diskussion | Beiträge)
498 Bearbeitungen
Keine Bearbeitungszusammenfassung
K Textersetzung - „== Einzelnachweise ==↵<references />“ durch „“
 
(234 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
== Komponenten des Signaling-Servers ==
Nextcloud Talk '''H'''igh '''P'''erformance '''B'''ackend


Der Signaling-Server besteht aus den folgenden Komponenten / Diensten:
= Beschreibung =
; Komponenten
{| class="wikitable sortable"
|-
! Komponente !! Aufgabe !! Link !! Beschreibung
|-
| Janus || WebRTC Gateway || [[Nextcloud/Talk:HPB:Janus]] ||
|- 
| NATS || Messaging Server || [[Nextcloud/Talk:HPB:NATS]] ||
|- 
| Signaling-Servern || Signaling-Servern || [[Nextcloud/Talk:HPB:Signaling-Server]] ||
|-
| Webserver Frontend  || Webserver Frontend || [[Nextcloud/Talk:HPB:Apache]] ||
|}


= Installation =
== Server-Daten ==


* dem Nextcloud Talk signaling server [https://github.com/strukturag/nextcloud-spreed-signaling Signaling]
{| class="wikitable sortable"
* dem Janus WebRTC gateway [https://github.com/meetecho/janus-gateway Janus]
|-
* und dem NATS messaging server [https://nats.io/ NATS]
! Server !! URL
|-
| Nextcloud-Server || cloud.foxtom.de
|-
| TURN-Server || turn.foxtom.de:5349
|-
| Signaling Server || signaling.foxtom.de
|}


= Konfiguration =
== Schlüssel (keys) erstellen ==
{| class="wikitable sortable"
|-
! Aufgabe !! Befehl
|-
| Api-Key für Janus  || openssl rand -base64 16
|- 
| Hash-Key  || openssl rand -hex 16
|- 
| Block-Key  || openssl rand -hex 16
|- 
| Secret Key für die Nextcloud || openssl rand -hex 16
|}


=== Vorbereitungen ===
;siehe auch '''[[Openssl]]'''


Für die jeweiligen Komponenten werden Schlüssel (keys) benötigt, die im Vorfeld wie folgt erzeugt werden können:
== Einbinden in Nextcloud Talk ==
siehe '''[[Nextcloud/Talk:HPB:Einbinden in Nextcloud Talk]]'''


* der <api-Key> für Janus:
== Firewall konfigurieren ==
  openssl rand -base64 16
# apt install ufw
* ein Hash-Key:
  openssl rand -hex 16
* ein Block-Key:
  openssl rand -hex 16
* ein Secret Key für die Nextcloud
  openssl rand -hex 16
* der Schlüssel für den TURN-Server ist in den Talk-Einstellungen der Nextcloud zu finden (https://cloud.itw-berlin.net/settings/admin/talk)


# ufw allow http
# ufw allow https
# ufw allow ssh
# ufw allow 5349/tcp
# ufw allow 5349/udp


Die Adressen der benötigten Server:
# ufw enable


 
  # ufw status
*Nextcloud-Server : cloud.itw-berlin.net
  Status: active
*TURN-Server      : cloud.itw-berlin.net:5349
*Signaling Server : signaling.foxtom.de
 
 
== Installation der Komponenten / Dienste ==
 
=== Janus ===
 
Janus kann über die Paketverwaltung installiert werden:
 
apt install janus
 
Die anzupassenden Konfigurationsdateien finden sich im Verzeichnis '''/etc/janus'''. Von Bedeutung sind die Dateien:
 
* janus.jcfg
* janus.transport.http.jcfg
* und janus.transport.websockets.jcfg
 
In der Datei '''janus.jcfg''' müssen folgende Einstellungen angepasst werden:
 
...
  stun_server = "cloud.itw-berlin.net"
  stun_port = 5349
...
full_trickle = true
...
turn_server = "cloud.itw-berlin.net"
turn_port = 5349
...
turn_rest_api_key = "<api-Key>"
...
 
Um den Janus-Server so zu konfigurieren, daß er nur lokal angesprochen werden kann, werden die Dateien '''janus.transport.http.jcfg''' & '''janus.transport.websockets.jcfg''' wie folgt modifiziert:
 
'''janus.transport.http.jcfg''':
 
...
interface = "lo"
...
 
'''janus.transport.websockets.jcfg''':
   
   
  ...
  To                        Action      From
  ws_interface = "lo"
  --                        ------      ----
  ...
  80/tcp                    ALLOW      Anywhere                 
443/tcp                    ALLOW      Anywhere                 
22/tcp                    ALLOW      Anywhere                 
5349/tcp                  ALLOW      Anywhere                 
5349/udp                  ALLOW      Anywhere                 
80/tcp (v6)                ALLOW      Anywhere (v6)           
443/tcp (v6)              ALLOW      Anywhere (v6)           
22/tcp (v6)                ALLOW      Anywhere (v6)           
5349/tcp (v6)              ALLOW      Anywhere (v6)           
5349/udp (v6)              ALLOW      Anywhere (v6)


== Dateien ==


=== NATS ===
= Anwendung =
 
NATS kann durch das Hinzufügen der entsprechenden Quelle:
 
sudo curl -sL -o /etc/apt/trusted.gpg.d/morph027-nats-server.asc https://packaging.gitlab.io/nats-server/gpg.key
echo "deb https://packaging.gitlab.io/nats-server nats main" | sudo tee /etc/apt/sources.list.d/morph027-nats-server.list
 
direkt im Anschluß über die Paketverwaltung installiert werden:
 
sudo apt update
sudo apt install -y nats-server
 
Die Konfigurationsdatei '''nats.conf''' wird im Verzeichnis '''/etc/nats''' angelegt und enthält nur die Zeile "listen: 127.0.0.1:4222":
 
sudo install -d -o nats -g nats /etc/nats
sudo -u nats echo "listen: 127.0.0.1:4222" > /etc/nats/nats.conf
 
 
 
=== Signaling Server ===
 
Zur Installation des Servers wird das Paket '''golang-go''' benötigt, welches über die Paketverwaltung installiert werden kann: 
 
apt install golang-go
 
Die benötigten Quellpakete werden über GitHub bezogen und hier im Verzeichnis /usr/src abgelegt:
 
cd /usr/src
git clone https://github.com/strukturag/nextcloud-spreed-signaling.git
cd /usr/src/nextcloud-spreed-signaling
 
Der anschließende Befehl '''make build''' erstellt das Programm '''bin/signaling'''
 
make build
 
=== Konfiguration ===
 
Eine beispielhafte Konfigurationsdatei findet sich in /usr/src/nextcloud-spreed-signaling als '''server.conf.in'''
 
Diese Datei wird nach /etc/signaling/server.conf kopiert:
cd /usr/src/nextcloud-spreed-signaling
cp server.conf.in /etc/signaling/server.conf
 
und die Berechtigungen angepasst:
 
chmod 600 /etc/signaling/sserver.conf
chown signaling: /etc/signaling/server.conf
 
Entsprechend den lokalen Begebenheiten wir diese Datei wie folgt editiert:
 
listen = 127.0.0.1:8080
...
[sessions]
hashkey = <Hash-Key>
...
blockkey = <Block-Key>
...
[backend]
backends = backend1
[backend1]
url = https://cloud.itw-berlin.net
​...
secret = <Nextcloud Secret Key>
...
[nats]
url = nats://localhost:4222
...
[mcu]
type = janus
...
url = ws://127.0.0.1:8188
...
[turn]
apikey = <api-key>
secret = <TURN-Server-Key>
servers = turn:cloud.itw-berlin.net:5349?transport=udp,turn:cloud.itw-berlin.net:5349?transport=tcp
...
 
== Starten des Signaling-Servers ==
 
Für einen ersten Test muß der Janus-Server bereits laufen:
 
sudo systemctl start janus
sudo systemctl status janus
● janus.service - Janus WebRTC gateway
    Loaded: loaded (/lib/systemd/system/janus.service; enabled; vendor preset: enabled)
    Active: active (running) since Wed 2021-01-06 15:07:00 CET; 15s ago
      Docs: https://janus.conf.meetecho.com/docs/index.html
  Main PID: 9851 (janus)
    Tasks: 24 (limit: 2296)
    Memory: 9.1M
    CGroup: /system.slice/janus.service
            └─9851 /usr/bin/janus -o
 
Jan 06 15:07:01 signaling janus[9851]: [ERR] [config.c:janus_config_parse:191]  -- Error reading configuration file 'janus.transport.rabbitmq.cfg'... error 2 (No such file or directory)
Jan 06 15:07:01 signaling janus[9851]: RabbitMQ SSL support disabled
Jan 06 15:07:01 signaling janus[9851]: [WARN] RabbitMQ support disabled (Janus API)
Jan 06 15:07:01 signaling janus[9851]: [WARN] RabbitMQ support disabled (Admin API)
Jan 06 15:07:01 signaling janus[9851]: [WARN] RabbitMQ support disabled for both Janus and Admin API, giving up
Jan 06 15:07:01 signaling janus[9851]: [WARN] The 'janus.transport.rabbitmq' plugin could not be initialized
Jan 06 15:07:01 signaling janus[9851]: [WARN] libnice version outdated: 0.1.14 installed, at least 0.1.15 recommended
Jan 06 15:07:01 signaling janus[9851]: HTTP transport timer started
Jan 06 15:07:09 signaling janus[9851]: Creating new session: 5197647642285633; 0x7efe24004830
Jan 06 15:07:09 signaling janus[9851]: Creating new handle in session 5197647642285633: 2088316009596726; 0x7efe24004830 0x7efe24001be0
 
Direktes Starten des Signaling-Servers im Vordergrund:
 
sudo /usr/src/nextcloud-spreed-signaling/bin/signaling --config /etc/signaling/server.conf
2021-01-06 15:11:51.109402 I | main.go:130: Starting up version 64cccab641874b3e688c1eb9029b5bb9215741e5/go1.11.6 as pid 9913
2021-01-06 15:11:51.109824 I | main.go:139: Using a maximum of 1 CPUs
2021-01-06 15:11:51.111647 I | natsclient.go:116: Connection established to nats://localhost:4222 (ND2IPCPXAOZMW5QPQ3R476UVGKI42RUNGIQ7YOHLNHK3QLTS7HXIVIWH)
2021-01-06 15:11:51.111713 I | backend_configuration.go:77: Backend backend1 added for https://cloud.itw-berlin.net/
2021-01-06 15:11:51.111723 I | hub.go:177: Using a maximum of 8 concurrent backend connections per host
2021-01-06 15:11:51.111739 I | hub.go:184: Using a timeout of 10s for backend connections
2021-01-06 15:11:51.111759 I | hub.go:270: Not using GeoIP database
2021-01-06 15:11:51.113242 I | mcu_janus.go:289: Connected to Janus WebRTC Server 0.9.2 by Meetecho s.r.l.
2021-01-06 15:11:51.113260 I | mcu_janus.go:293: Found JANUS VideoRoom plugin 0.0.9 by Meetecho s.r.l.
2021-01-06 15:11:51.113269 I | mcu_janus.go:299: Data channels are supported
2021-01-06 15:11:51.113274 I | mcu_janus.go:305: Full-Trickle is enabled
2021-01-06 15:11:51.113280 I | mcu_janus.go:308: Maximum bandwidth 1048576 bits/sec per publishing stream
2021-01-06 15:11:51.113285 I | mcu_janus.go:309: Maximum bandwidth 2097152 bits/sec per screensharing stream
2021-01-06 15:11:51.114259 I | mcu_janus.go:315: Created Janus session 6900302758812903
2021-01-06 15:11:51.114951 I | mcu_janus.go:322: Created Janus handle 7778710372665701
2021-01-06 15:11:51.115064 I | main.go:226: Using janus MCU
2021-01-06 15:11:51.115132 I | hub.go:357: Using a timeout of 10s for MCU requests
2021-01-06 15:11:51.115192 I | backend_server.go:94: Using configured TURN API key
2021-01-06 15:11:51.115250 I | backend_server.go:95: Using configured shared TURN secret
2021-01-06 15:11:51.115315 I | backend_server.go:97: Adding "turn:cloud.itw-berlin.net:5349?transport=udp" as TURN server
2021-01-06 15:11:51.115372 I | backend_server.go:97: Adding "turn:cloud.itw-berlin.net:5349?transport=tcp" as TURN server
2021-01-06 15:11:51.115420 I | backend_server.go:104: No IPs configured for the stats endpoint, only allowing access from 127.0.0.1
2021-01-06 15:11:51.115613 I | main.go:302: Listening on 127.0.0.1:8080
 
 
== 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 zum Beispiel 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
 
 
 
== 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
 
Die Option'' SSL Zertifikat überprüfen'' sollte hier aktiviert werden, wenn der Signaling Server über ein valides Zertifikat verfügt (zum Beispiel Let’s Encrypt).
 
 
== Benchmark/Test ==
Für den Signaling Server gibt es ebenfalls einen mitgelieferten Client, mit dem man den Server testen 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: vi /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 ===
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).
 
= Signalisierungsserver für Nextcloud =
Vor kurzem wurde die Software zum Betrieb von Nextcloud Talk in größeren Nextcloudumgebungen als Open Source veröffentlicht: man braucht einen eigenen Signalisierungsserver, um mit mehreren parallel Leuten effektiv über Nextcloud Talk arbeiten zu können.
* Per Default wird der interne verwendet.
* Wie wird dieser [https://github.com/strukturag/nextcloud-spreed-signaling Signalisierungsserver] nun aufgesetzt?
 
 
Den Signaling Server direkt von Github selbst kompilieren:
apt install git automake golang build-essential certbot nginx apt-transport-https ca-certificates curl gnupg-agent software-properties-common
git clone https://github.com/strukturag/nextcloud-spreed-signaling.git
cd nextcloud-spreed-signaling/
make build
cp bin/signaling /usr/bin/
Nun die Konfigurationsdatei aus dem Repo an die richtige Stelle kopieren.:
mkdir /etc/signaling/
cp server.conf.in /etc/signaling/server.conf
useradd --system --shell /usr/sbin/nologin --comment "Standalone signaling server for Nextcloud Talk." signaling
 
chown signaling: /etc/signaling/server.conf
chmod 600 /etc/signaling/server.conf
 
Anschließend den Service für den Signaling Server einrichten und vorher natürlich die Systemd Datei entsprechend eurer Pfade anpassen, wenn abweichend:
cp dist/init/systemd/signaling.service /etc/systemd/system/signaling.service
systemctl daemon-reload
systemctl enable signaling
Nun müssen wir die einzelnen Services für den Signaling Server aufsetzen.
 
 
 
Wenn ihr nun alles richtig gemacht habt, sollte ''curl -i https://signaling.xy.de/standalone-signaling/api/v1/welcome'' folgende Antwort liefern:
HTTP/1.1 200 OK
Date: Thu, 05 Jul 2018 09:28:08 GMT
Server: nextcloud-spreed-signaling/1.0.0
Content-Type: application/json; charset=utf-8
Content-Length: 59
{"nextcloud-spreed-signaling":"Welcome","version":"1.0.0"}
== Nextcloud Integration ==
Installiert die Beta Version von Nextcloud Talk – am besten zum Testen mal in einer eigenen Installation auf dem Beta Release Channel für Nextcloud 19 (für Nextcloud 18 habe ich das nicht probiert).
* In den Einstellungen von Nextcloud im Reiter Talk nun folgende Konfiguration setzen:
 
STUN und Signaling Server laufen bei mir auf getrennten Maschinen.
* Das Gemeinsame Geheimnis ist das '''secret''' aus der Signaling Server conf.
 
Quelle: https://nichteinschalten.de/signalisierungsserver-fuer-nextcloud-aufsetzen-how-to/
 
= How to Install Nextcloud Talk High Performance Backend with Stun/Turnserver on Ubuntu =
* Since Nextcloud has released the [https://www.heise.de/ix/meldung/Nextcloud-stellt-High-Performance-Back-End-unter-Open-Source-Lizenz-4727074.html High Performance Backend as OpenSource under AGPL License], i tried my luck to install it on Ubuntu.
* Now I want to share how to do it.
 
 
== Arbeitsschritte ==
 
=== Install and config stun/turnserver ===
you have to install the package coturn:
apt install coturn
enable daemonizing for your turnserver:
sed -i '/TURNSERVER_ENABLED/c\TURNSERVER_ENABLED=1' /etc/default/coturn
create a random hex key for your nextcloud talk app and signaling server with:
openssl rand -hex 32
and copy it for later use, then edit /etc/turnserver.conf:
mv /etc/turnserver.conf /etc/turnserver.conf.bak && nano /etc/turnserver.conf
copy, paste and adjust the following code:
listening-port=5349
fingerprint
lt-cred-mech
use-auth-secret
static-auth-secret=output_of_openssl rand -hex 32
realm=signaling.example.com
total-quota=100
bps-capacity=0
stale-nonce
no-loopback-peers
no-multicast-peers
 
and last, restart and enable coturn:
systemctl restart coturn && systemctl enable coturn
 
=== Install and config janus ===
The Version of janus in official repository of Ubuntu 18.04 is 0.2.6-1build2, so if you use 18.04 try [https://gitlab.com/packaging/janus/ Gitlab Repository].
* of morph27 instead.
* If you use 20.04 the version is suitable.
 
'''Ubuntu 18.04'''add repo key:
curl -sL -o /etc/apt/trusted.gpg.d/morph027-janus.asc https://packaging.gitlab.io/janus/gpg.key
 
add repo:
. /etc/lsb-release; echo "deb [arch=amd64] https://packaging.gitlab.io/janus/$DISTRIB_CODENAME $DISTRIB_CODENAME main" | tee /etc/apt/sources.list.d/morph027-janus.list
apt update
 
enable and restart janus:
systemctl restart janus && systemctl enable janus
 
start and enable NATS-Server:
systemctl start nats-server && systemctl enable nats-server
 
=== Install nextcloud-spreed-signaling Server ===
now we can install the nextcloud-spreed-signaling server, first of all, we have to install the packages we need to built:
apt install git automake golang build-essential python3 -y
then we clone the git repository and start the build process:
cd /opt
git clone https://github.com/strukturag/nextcloud-spreed-signaling.git
cd nextcloud-spreed-signaling/
make build
 
then copy the binary to /usr/bin
cp bin/signaling /usr/bin/
 
now create a dedicated user:
useradd --system --shell /usr/sbin/nologin --comment "Standalone signaling server for Nextcloud Talk." signaling
create the server.conf in /etc/signaling/
mkdir /etc/signaling/
touch /etc/signaling/server.conf
chown signaling: /etc/signaling/server.conf
chmod 600 /etc/signaling/server.conf
 
and copy the systemd file:
cp dist/init/systemd/signaling.service /etc/systemd/system/signaling.service
systemctl daemon-reload
systemctl enable signaling
 
 
 
vi /etc/signaling/server.conf
 
then copy, paste and adjust (change keys to yours) the following config
[http]
listen = 127.0.0.1:8080
[app]
debug = false
[sessions]
hashkey = db61d5a8c6bd2b47a3cb0abce3545040
blockkey = f702adbf248ab0e752fa76cb46bcba12
[backend]
allowed = nextcloud.example.com
allowall = false
secret = 692cdc99256135bcb7849ca1886e2ed6
timeout = 10
connectionsperhost = 8
[nats]
url = nats://localhost:4222
[mcu]
type = janus
url = ws://127.0.0.1:8188
[turn]
apikey = Z6ZkKhjwCFa6RMpFU854Fw==
secret = 2309a206fc4de0f511ce9da52c088171f69193d1f701323d5ab4f733c9853445
servers = turn:signaling.example.com:5349?transport=udp,turn:signaling.example.com:5349?transport=tcp
 
then start signaling:
systemctl start signaling
 
and check staus of the service:
systemctl status signaling
 
and if it listens on port 8080:
netstat -tulpen | grep 8080
 
 
 
 
 
 
 
= Spreed standalone signaling server =
 
This repository contains the standalone signaling server which can be used for Nextcloud Talk ([https://apps.nextcloud.com/apps/spreed https://apps.nextcloud.com/apps/spreed]).
 
See [https://nextcloud-talk.readthedocs.io/en/latest/standalone-signaling-api-v1/ https://nextcloud-talk.readthedocs.io/en/latest/standalone-signaling-api-v1/] for further information on the API of the signaling server.
 
== Building ==
 
The following tools are required for building the signaling server.* git
* go >= 1.10
* make
 
 
 
 
 
 
The signaling server connects to a NATS server ([https://nats.io/ https://nats.io/]) to distribute messages between different instances. See the NATS documentation on how to set up a server and run it.
 
Once the NATS server is running (and the URL to it is configured for the signaling server), you can start the signaling server.
 
$ ./bin/signaling
 
By default, the configuration is loaded from <tt>server.conf</tt> in the current directory, but a different path can be passed through the <tt>--config</tt> option.
 
$ ./bin/signaling --config /etc/signaling/server.conf
 
=== Running as daemon ===
 
==== systemd ====
 
Create a dedicated user:
 
sudo useradd --system \
    --gid signaling \
    --shell /usr/sbin/nologin \
    --comment "Standalone signaling server for Nextcloud Talk." \
    signaling
 
Copy <tt>server.conf.in</tt> to <tt>/etc/signaling/server.conf</tt> and fix permissions:
 
sudo chmod 600 /etc/signaling/server.conf
sudo chown signaling: /etc/signaling/server.conf
 
Copy <tt>dist/init/systemd/signaling.service</tt> to <tt>/etc/systemd/system/signaling.service</tt> (adjust abs. path in <tt>ExecStart</tt> to match your binary location!)
 
Enable and start service:
 
systemctl enable signaling.service
systemctl start signaling.service
 
 
[http://nats.io/documentation/tutorials/gnatsd-install/ http://nats.io/documentation/tutorials/gnatsd-install/]
 
 
[https://github.com/meetecho/janus-gateway https://github.com/meetecho/janus-gateway]) can be used to act as a WebRTC gateway. See the documentation of Janus on how to configure and run the server. At least the <tt>VideoRoom</tt> plugin and the websocket transport of Janus must be enabled.
 
The signaling server uses the <tt>VideoRoom</tt> plugin of Janus to manage sessions. All gateway details are hidden from the clients, all messages are sent through the signaling server. Only WebRTC media is exchanged directly between the gateway and the clients.
 
Edit the <tt>server.conf</tt> and enter the URL to the websocket endpoint of Janus in the section <tt>[mcu]</tt> and key <tt>url</tt>. During startup, the signaling server will connect to Janus and log information of the gateway.
 
The maximum bandwidth per publishing stream can also be configured in the section <tt>[mcu]</tt>, see properties <tt>maxstreambitrate</tt> and <tt>maxscreenbitrate</tt>.
 
 
 
== Benchmarking the server ==
A simple client exists to benchmark the server. Please note that the features that are benchmarked might not cover the whole functionality, check the implementation in <tt>src/client</tt> for details on the client.
 
To authenticate new client connections to the signaling server, the client starts a dummy authentication handler on a local interface and passes the URL in the <tt>hello</tt> request. Therefore the signaling server should be configured to allow all backend hosts (option <tt>allowall</tt> in section <tt>backend</tt>).
 
The client is not compiled by default, but can be using the <tt>client</tt> target:
$ '''make client'''
Usage:
 
$ '''./bin/client'''
Usage of ./bin/client:
  -addr string
        http service address (default "localhost:28080")
  -config string
        config file to use (default "server.conf")
  -maxClients int
        number of client connections (default 100)


= Sicherheit =
= Dokumentation =
== Projekt ==
# https://github.com/strukturag/nextcloud-spreed-signaling


= Links =
= Links =
== Intern ==
== Siehe auch ==
TODO
# https://de.wikipedia.org/wiki/WebRTC


== Extern ==
== Weblinks ==
# https://github.com/strukturag/nextcloud-spreed-signaling
# https://de.wikipedia.org/wiki/WebRTC
# https://decatec.de/home-server/nextcloud-talk-mit-eigenem-signaling-server-high-performance-backend/
# https://decatec.de/home-server/nextcloud-talk-mit-eigenem-signaling-server-high-performance-backend/
# https://decatec.de/home-server/nextcloud-auf-ubuntu-server-20-04-lts-mit-nginx-mariadb-php-lets-encrypt-redis-und-fail2ban/  
# https://decatec.de/home-server/nextcloud-auf-ubuntu-server-20-04-lts-mit-nginx-mariadb-php-lets-encrypt-redis-und-fail2ban/  
Zeile 529: Zeile 99:
# https://decatec.de/home-server/docker-auf-ubuntu-server/
# https://decatec.de/home-server/docker-auf-ubuntu-server/


[[Kategorie:Entwurf]]
 
[[Kategorie:Nextcloud]]
 
 
 
[[Kategorie:Nextcloud/Talk]]

Aktuelle Version vom 2. Juni 2024, 09:45 Uhr

Nextcloud Talk High Performance Backend

Beschreibung

Komponenten
Komponente Aufgabe Link Beschreibung
Janus WebRTC Gateway Nextcloud/Talk:HPB:Janus
NATS Messaging Server Nextcloud/Talk:HPB:NATS
Signaling-Servern Signaling-Servern Nextcloud/Talk:HPB:Signaling-Server
Webserver Frontend Webserver Frontend Nextcloud/Talk:HPB:Apache

Installation

Server-Daten

Server URL
Nextcloud-Server cloud.foxtom.de
TURN-Server turn.foxtom.de:5349
Signaling Server signaling.foxtom.de

Konfiguration

Schlüssel (keys) erstellen

Aufgabe Befehl
Api-Key für Janus openssl rand -base64 16
Hash-Key openssl rand -hex 16
Block-Key openssl rand -hex 16
Secret Key für die Nextcloud openssl rand -hex 16
siehe auch Openssl

Einbinden in Nextcloud Talk

siehe Nextcloud/Talk:HPB:Einbinden in Nextcloud Talk

Firewall konfigurieren

# apt install ufw

# ufw allow http
# ufw allow https
# ufw allow ssh
# ufw allow 5349/tcp
# ufw allow 5349/udp

# ufw enable

# ufw status
Status: active

To                         Action      From
--                         ------      ----
80/tcp                     ALLOW       Anywhere                  
443/tcp                    ALLOW       Anywhere                  
22/tcp                     ALLOW       Anywhere                  
5349/tcp                   ALLOW       Anywhere                  
5349/udp                   ALLOW       Anywhere                  
80/tcp (v6)                ALLOW       Anywhere (v6)             
443/tcp (v6)               ALLOW       Anywhere (v6)             
22/tcp (v6)                ALLOW       Anywhere (v6)             
5349/tcp (v6)              ALLOW       Anywhere (v6)             
5349/udp (v6)              ALLOW       Anywhere (v6)

Dateien

Anwendung

Sicherheit

Dokumentation

Projekt

  1. https://github.com/strukturag/nextcloud-spreed-signaling

Links

Siehe auch

  1. https://de.wikipedia.org/wiki/WebRTC

Weblinks

  1. https://decatec.de/home-server/nextcloud-talk-mit-eigenem-signaling-server-high-performance-backend/
  2. https://decatec.de/home-server/nextcloud-auf-ubuntu-server-20-04-lts-mit-nginx-mariadb-php-lets-encrypt-redis-und-fail2ban/
  3. https://decatec.de/home-server/nextcloud-talk-mit-eigenem-turn-server-coturn/
  4. https://decatec.de/linux/lets-encrypt-zertifikate-mit-acme-sh-und-nginx/
  5. https://decatec.de/home-server/rsa-und-ecdsa-zertifikate-mit-nginx-hybrid-loesung/
  6. https://decatec.de/home-server/tlsv1-3-unter-ubuntu-server-18-04-lts-mit-nginx/
  7. https://decatec.de/home-server/docker-auf-ubuntu-server/
Abgerufen von „https://wiki.foxtom.de/index.php?title=Nextcloud/Talk/HPB&oldid=101710“