Configurando Nextcloud Signaling Server

Este artículo es una traducción al español de la guia que puedes encontrar en https://www.c-rieger.de/nextcloud-hub-3-talk-signaling-server/

---

Con Nextcloud HUB 4 y el backend de alto rendimiento ( aplicación TALK y servidor de señalización Nextcloud ), utilizando su propio servidor de señalización y coturn, puede hacer presentaciones, compartir escritorio, videoconferencias, llamadas telefónicas y chats, todo con su Nextcloud autohospedado.

Para ello se requiere un servidor dedicado basado en Ubuntu 20.04 o 22.04 LTS (64 bits) tanto por motivos de carga como de rendimiento.

Una vez finalizada la guía podrás acceder al servidor de señalización desde Internet a través de tu propio (sub)dominio pero debes cumplir con estos requisitos mínimos: Ubuntu 20.04.x ​​/ 22.04.x ​​​​LTS, 4 núcleos de CPU, 16 GB de RAM y 1 GBit/s (up/ abajo). Es posible que el servidor de señalización pueda funcionar con un hardware más débil, pero puede haber pérdidas en términos de rendimiento y número de participantes en la conferencia.

Nota:
¡Se recomiendan tres servidores separados, es decir, un servidor Nextcloud, un servidor de señalización y un servidor coturn!

sudo -s

Agregue su dirección IP pública/estática y su dominio al archivo /etc/hosts:

nano /etc/hosts

...
127.0.1.1 subdominio.dominio.es
...
<IP Pública> subdominio.dominio.es

Abra el puerto 80/tcp y el puerto 443/tcp en su UFW (firewall),

ufw allow 22/tcp comment "SSH"
ufw allow 80/tcp comment "LetsEncrypt"
ufw allow 443/tcp comment "Nextcloud HPB"
ufw allow 32769:65535/udp comment "Nextcloud HPB"
ufw enable
systemctl enable ufw.service
systemctl restart ufw.service

Se requieren diferentes claves para configurar los componentes requeridos. Además del coturn secret , generamos cuatro claves más:

llave	comando para generar
TURN/static-auth-secret Ver aqui instrucciones de COTURN	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

Procedemos a instalar las versiones de software necesarias :

• git
• go >= 1.17
• make
• protobuf-compiler >= 3

cd /usr/local/src
wget http://ubuntu-master.mirror.tudos.de/ubuntu/pool/universe/libs/libsrtp2/libsrtp2-1_2.4.2-3_amd64.deb
wget https://go.dev/dl/go1.19.2.linux-amd64.tar.gz
tar -C /usr/local -xzf go1.19.2.linux-amd64.tar.gz
sh -c 'echo "export PATH=$PATH:/usr/local/go/bin" >> /etc/profile'
apt install -y libnspr4 libnss3
dpkg -i libsrtp2*.deb
rm -f go1.19.2.linux-amd64.tar.gz libsrtp2-1_2.4.2-3_amd64.deb

Para poder instalar el servidor Signaling, tenemos que compilarlo nosotros mismos:

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

Después de unos minutos, la compilación está completa y la configuración se puede ajustar:

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

Edite las siguientes áreas:

[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://subdominio.dominio.es
# 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 = Su previamente generado <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 = El autogenerado 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.dominio.es:443?transport=udp,turn:coturn.dominio.es:443?transport=tcp
...

Todo el archivo server.conf se ve así sin los valores predeterminados:

[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.dominio.es:443?transport=udp,turn:coturn.dominio.es:443?transport=tcp
[geoip]
[geoip-overrides]
[stats]

Sigamos con la instalación de Janus

apt install -y janus

seguido de la configuración

nano /etc/janus/janus.jcfg

Ajuste la configuración de la siguiente manera:

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

Janus solo se direcciona localmente y, por lo tanto, se configura de la siguiente manera:

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

...
interface = "lo"
...

También para el Websocket

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

...
ws_interface = "lo"
...

Para poder usar NATS, prepararemos el sistema para Docker-CE:

apt remove docker docker-engine docker.io
apt install -y apt-transport-https ca-certificates curl software-properties-common

echo "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable" | tee /etc/apt/sources.list.d/docker.list
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
apt update && apt install -y docker-ce

Ahora descargue NATS como Docker:

docker pull nats:latest

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

Ahora vamos a configurar el servidor web.

echo "deb [arch=amd64] http://nginx.org/packages/mainline/ubuntu $(lsb_release -cs) nginx" | tee /etc/apt/sources.list.d/nginx.list

curl -fsSL https://nginx.org/keys/nginx_signing.key | apt-key add -

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

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

Copie todo el siguiente contenido en el archivo:

user www-data;
worker_processes auto;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
multi_accept on; use epoll;
}
http {
server_names_hash_bucket_size 64;
access_log /var/log/nginx/access.log;
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;
}

y cree los directorios necesarios:

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

Cree los archivos vHost necesarios en:

[ -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/subdominio.dominio.es.conf

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

Copie todas las siguientes líneas en el archivo http.conf y ajuste los valores marcados en rojo según su sistema:

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

Cambie al archivo de señalización-vHost:

nano /etc/nginx/conf.d/subdominio.dominio.es.conf

y copie el siguiente texto en este archivo. Ajuste los valores en rojo.

upstream signaling {
server 127.0.0.1:8080;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name subdominio.dominio.es;
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

Asegúrese de que se pueda acceder a su servidor externamente a través del puerto 80/TCP y el puerto 443/TCP. ¡La creación y actualización de certificados de Let’s Encrypt debe realizarse a través de http y el puerto 80! Para el manejo de certificados ahora creamos un usuario dedicado y lo agregamos al grupo www-data:

adduser --disabled-login acmeuser

usermod -a -G www-data acmeuser

Otorgamos a este usuario técnico las autorizaciones necesarias para poder iniciar el servidor web necesario cuando se renueve un certificado.

visudo

En el medio del archivo, debajo

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

ingrese la siguiente línea:

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

Guarde y salga de este archivo con CTRL+X seguido de una y .

Cambie al shell del nuevo usuario (acmeuser) para instalar el software del certificado y luego salga de este shell nuevamente:

apt install -y socat

su - acmeuser

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

exit

Ajuste los permisos adecuados para poder almacenar los nuevos certificados en él:

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

Establezca Let’s Encrypt como la CA predeterminada.

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

Cambiar de nuevo al shell del nuevo usuario

su - acmeuser

y solicitar (solicitar) los certificados SSL. Reemplace subdominio.dominio.es con su dominio:

acme.sh --issue -d subdominio.dominio.es --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 subdominio.dominio.es --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"

Salga del shell del nuevo usuario

exit

Elimine los certificados autofirmados que utilizó anteriormente de nginx y active los certificados SSL nuevos, completos y ya válidos de Let’s Encrypt. Luego reinicie el servidor web:

sed -i '/ssl-cert-snakeoil/d' /etc/nginx/conf.d/subdominio.dominio.es.conf
sed -i s/#\ssl/\ssl/g /etc/nginx/conf.d/subdominio.dominio.es.conf
service nginx restart

Instalamos un propio servidor coturn. Verifique su servidor coturn a través de este enlace externo. Como se muestra en el ejemplo, inserte su nombre de dominio y puerto en lugar del ejemplo «stun: coturn.dominio.es :443″.

Si ve entradas del tipo «srflx» y » Done» en la columna «Priority» en la última línea , ¡su servidor coturn está funcionando correctamente! Solo en este caso seguiremos con la instalación y configuración.

Ahora iniciamos el servidor de señalización. Comencemos con el servicio Janus:

service janus restart

El software se inicia inicialmente de forma manual:

cd /etc/nextcloud-spreed-signaling

./bin/signaling --config server.conf

Si la aplicación se inicia sin errores, la finalizamos (CTRL+c) y configuramos un usuario técnico y un nuevo servicio del sistema:

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

El archivo de configuración del servidor se guarda de forma persistente para que las actualizaciones no lo sobrescriban. También se fijan las autorizaciones correspondientes:

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

El servicio ahora se crea de la siguiente manera:

nano dist/init/systemd/signaling.service

Por favor copie el texto completo en él:

[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

Finalmente, el servicio se registra en el servidor y se inicia:

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

Ahora cambie a su Nextcloud: active y configure la aplicación Nextcloud Talk como administrador de Nextcloud de la siguiente manera.

STUN-Server:

* coturn.dominio.es:443

TURN-Server:

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

Signaling-Server:

* https://subdominio.dominio.es/standalone-signaling/
* Nextcloud-SECRET-KEY