Configurar un Sistema de Videoconferencias con Jitsi Meet

Qué es Jitsi Meet?

Jitsi Meet es una herramienta multiplataforma y gratuita que permite hacer videoconferencias grupales a través de Internet. En las videollamadas de Jitsi Meet no hay ningún límite en el número de participantes, pudiendo entrar tantos como lo permita la potencia y el ancho de banda del servidor. En este caso nos proponemos instalar y configurar jitsi y jibri, y adaptarlo un poquito a las necesidades de una empresa cubana.

Requisitos para el proceso:

• Internet (Solo para el proceso de instalación)
• Para Jisti utilicé un CT con ubuntu 18.04 live server 2 core, 4 Gb ram, 2 Gb swap y 20 Gb hdd ip: 10.1.1.2 FQDN: conferencias.empresa.cu
• Para jibri utilicé un VM con ubuntu 18.04 live server 2 core, 4 Gb ram y 60 Gb hdd ip: 10.1.1.3 FQDN jibri.empresa.cu

NOTA: Los recursos que puse fueron en mi entorno de pruebas, en un entorno de producción, se le deben asignar más recursos a Jitsi, Jibri con esos recursos trabaja bien.

Comenzando con Jitsi:

Suponiendo que ya se creó el CT y se aplicó apt update y apt upgrade. Hacemos las siguientes pruebas:

root@conferencias:~# hostname
conferencias
root@conferencias:~# hostname -f
conferencias.empresa.cu

Esas deben ser las respuestas.

Luego pasamos a la configuración del firewall:

root@conferencias:~# ufw allow 80/tcp
Rules updated
Rules updated (v6)

root@conferencias:~# ufw allow 443/tcp
Rules updated
Rules updated (v6)

root@conferencias:~# ufw allow 4443/tcp
Rules updated
Rules updated (v6)

root@conferencias:~# sudo ufw allow 10000/udp
Rules updated
Rules updated (v6)
root@conferencias:~# sudo ufw allow 22/tcp
Rules updated
Rules updated (v6)

root@conferencias:~# ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

root@conferencias:~# ufw status
Status: active

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

Así nos debe quedar la configuración de nuestro firewall.

Instalamos algunos paquetes necesarios:

apt install gnupg2 apt-transport-https sudo

apt install openjdk-8-jre-headless

Establecemos JAVA_HOME como una variable de entorno con las dos líneas siguientes:

root@conferencias:~# echo "JAVA_HOME=$(readlink -f /usr/bin/java | sed "s:bin/java::")" |tee -a /etc/profile
root@conferencias:~# source /etc/profile

Agregamos el repositorio de Jitsi:

root@conferencias:~# wget -qO - https://download.jitsi.org/jitsi-key.gpg.key |apt-key add -
root@conferencias:~# sh -c "echo 'deb https://download.jitsi.org stable/' > /etc/apt/sources.list.d/jitsi-stable.list"
root@conferencias:~# apt update

Instalamos Jitsi Meet

root@conferencias:~# apt install jitsi-meet

Durante la instalación nos pedirá un nombre de host, ahí le ponemos: conferencias.empresa.cu
Además nos pedirá que certificados usar, en mi caso escogí la primera opción, para que me genere un certificado auto firmado. (esto se puede cambiar después, yo lo dejé así)

Una vez terminado el proceso de instalación ya podrá usar la videoconferencia accediendo a https://conferencias.empresa.cu

Para videoconferencias con muchos participantes se recomienda cambiar las siguientes variables:

root@conferencias:~# nano /etc/systemd/system.conf

y agregamos lo siguiente al final:

DefaultLimitNOFILE=65000
DefaultLimitNPROC=65000
DefaultTasksMax=65000

Es recomedable editar:

root@conferencias:~# nano /etc/prosody/conf.avail/conferencias.empresa.cu.cfg.lua

y descomentar la línea 16 donde dice:

-- https_ports = { }; -- Remove this line to prevent listening on port 5284

dejarla que quede así:

https_ports = { }; -- Remove this line to prevent listening on port 5284

Luego reiniciar el servicio prosody:

root@conferencias:~# service prosody restart

y verificar que todo esta bien:

root@conferencias:~# service prosody status

NOTA: Se recomienda hacer una salva del contenedor CT

Para que no todos los usuarios puedan crear salas de videoconferencias y así tener controlado quien puede crear salas de videoconferencia de forma autenticada se continúa con el siguiente proceso:

Editamos: root@conferencias:~# nano /etc/prosody/conf.avail/conferencias.empresa.cu.cfg.lua

en la línea 26 que dice:

authentication = "anonymous"

la dejamos así:

authentication = "internal_plain"

y al final de ese archivo agregamos lo siguiente:

VirtualHost "guest.conferencias.empresa.cu"
authentication = "anonymous"
c2s_require_encryption = false

Editamos:

root@conferencias:~# nano /etc/jitsi/meet/conferencias.empresa.cu-config.js

en la línea 10 (que está en blanco justo debajo de: domain: ‘conferencias.empresa.cu’, ) agregamos:

anonymousdomain: 'guest.conferencias.emrpesa.cu',

Quedaría así lo editado del archivo:

/* eslint-disable no-unused-vars, no-var */

var config = {
// Connection
//

hosts: {
// XMPP domain.
domain: 'conferencias.empresa.cu',
anonymousdomain: 'guest.conferencias.empresa.cu',
// When using authentication, domain for guest users.
...............................................................(ahi continua el archivo......)

Editamos:

root@conferencias:~# nano /etc/jitsi/jicofo/sip-communicator.properties

y agregamos lo siguiente:

org.jitsi.jicofo.auth.URL=XMPP:conferencias.empresa.cu

Para crear los usuarios que tendrán acceso a crear salas de videoconferencia se usa el comando siguiente:

prosodyctl register username conferencias.empresa.cu password

como el siguiente ejemplo:

prosodyctl register admin conferencias.empresa.cu adminpassword

Reiniciamos lo siguiente:

root@conferencias:~# service prosody restart && service jicofo restart && service jitsi-videobridge2 restart

Hasta este punto ya se tiene una videoconferencia con autenticación de usuarios (sólo se tiene que autenticar el que crea la sala, los demás entran como invitados).

En caso de tener jitsi detras de un NAT hay dos formas posibles configurando jitsi o dejando jitsi como está y usando proxy inverso:

A- En caso de que sea con proxy inverso se puede usar la siguiente configuración del proxy inverso con nginx:

server {
listen 443 ssl http2;
ssl_certificate /etc/nginx/cert.crt;
ssl_certificate_key /etc/nginx/cert.key;
ssl on;
ssl_session_cache builtin:1000 shared:SSL:10m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4;
ssl_prefer_server_ciphers on;

server_name url.externa.del.jitsi; // esta es la url que deben poner los que estan externamente al jitsi
location / {
ssi on;
proxy_pass https://URL.o.ip.interna.del.jitsi:4444/; // esta es la url o ip interno del jitsi... el 4444 pq es el puerto de eschucha del jitsi para https (tiene internamente un proxy inverso)
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forward-Proto http;
proxy_set_header X-Nginx-Proxy true;
proxy_ssl_verify off;
}
}

En caso de tener un proxy inverso, además, en el firewall se debe redireccionar el puerto 4443 por tcp y los puertos 10000-20000 por udp hacia el jitsi, y mantener el puerto 443 (https) hacia el proxy inverso.

B- En caso de que no se tenga un proxy inverso en el firewall se debe redireccionar todos los puertos (443/tcp, 4443/tcp, 10000-20000/udp) hacia jitsi.

PARA AMBOS CASOS (A Y B):
Editar:

nano /etc/jitsi/videobridge/sip-communicator.properties

org.ice4j.ice.harvest.NAT_HARVESTER_LOCAL_ADDRESS=<Local.IP.Address>
org.ice4j.ice.harvest.NAT_HARVESTER_PUBLIC_ADDRESS=<PUBLIC.IP.Address>

y comentar la siguiente línea:

org.ice4j.ice.harvest.STUN_MAPPING_HARVESTER_ADDRESSES

NOTA: AQUÍ SE RECOMIENDA QUE HAGA OTRA SALVA DE SU CT.

Para acomodarlo un poco a las necesidades de nuestra empresa haremos lo siguiente:

Editamos:

root@conferencias:~# nano /etc/jitsi/meet/conferencias.empresa.cu-config.js

en la línea donde dice:

// disableAudioLevels: false,

la dejamos así:

disableAudioLevels: true,

en la línea que dice:

// startAudioMuted: 10,

la dejamos así:

startAudioMuted: 3,

Con esto garantizamos que los tres primeros que acceden a la sala de videoconferencia tengan el micrófono abierto, y los que entran después lo hacen con el micrófono cerrado, así no se nos forma un problema.

Más o menos por la línea 130 habla del tema de la resolución de video, lo cual es importante habilitarlo porque default viene en HD, así que consume mucho más ancho de banda y recursos, por que yo agregue esto a partir de la linea 130:

resolution: 360,
maxFps:15,
constraints: {
video: {
aspectRatio: 16 / 9,
height: {
ideal: 360,
max: 360,
min: 240
},
frameRate: {
max: 15
}
}
},

Además buscar la línea:

// requireDisplayName: true,

y descometarla, con eso se garantiza que cuando un usuario vaya a acceder a una sala, tenga que ponerse un nick obligatoriamente.

El archivo:

/usr/share/jitsi-meet/lang/main-esUS.json

ahí se cambian los carteles que salen al inicio de la web, y se adecuan a la empresa de cada cual, eso es editar solamente.

Hacer lo siguiente en el archivo:

/usr/share/jitsi-meet/interface_config.js

DISABLE_FOCUS_INDICATOR: true,
DISABLE_DOMINANT_SPEAKER_INDICATOR: true,
DISABLE_VIDEO_BACKGROUND: true,
DISABLE_DOMINANT_SPEAKER_INDICATOR: true,
DISABLE_JOIN_LEAVE_NOTIFICATIONS: true,

En el archivo:

/usr/share/jitsi-meet/interface_config.js

hay una serie de parámetros que se pueden cambiar, como por ejemplo dejarlos así:

APP_NAME: 'VideoConferencias Empresa X',
JITSI_WATERMARK_LINK: 'https://intranet.empresa.cu',

Donde:
app_name es el nombre que te sale en la ventana de tu navegador
jitsi_watermark_link es el link al que te redirecciona cuando le das click en el logotipo de la web.

El archivo:

/usr/share/jitsi-meet/images/watermark.png

ese es el logo que sale en la web, ese fichero se puede cambiar y poner el logo de tu empresa con ese mismo nombre

IMPORTANTE: Por defecto Jitsi viene que sólo muestra el nombre de cada participante sólo cuando se le pasa el mouse por arriba, una solución para que muestre el nombre de cada participante siempre editar el archivo ccs que esta en /usr/share/jitsi-meet/css/ y dejarlo así.

El usuario que creó la sala tiene la opción de obligar a todos a que vean lo que el decida, esto se hace en la opciones, donde dice MAS, señalar lo que dice todos me siguen.

Hasta aquí ya hay un sistema de videoconferencias con Jitsi como para una empresa.cu

NOTA: Se recomienda para las videoconferencias el uso del google chrome como navegador.

Ahora pasamos a configurar JIBRI que es quien se encarga de grabar las videoconferencias:

Suponiendo que ya se creo el VM y se aplico apt update y apt upgrade. Hacemos las siguientes pruebas:

root@jibri:~# hostname
jibri
root@jibri:~# hostname -f
jibri.empresa.cu

Aquí la parte del firewall la voy a saltar, solo es abrir en el jitsi server y jibri server los puertos 5222 5223 5369 todos tcp. Como en la primera parte.

Instalando paquetes necesarios:

root@jibri:~# apt install wget gnupg software-properties-common
root@jibri:~# apt install unzip ffmpeg curl alsa-utils icewm xdotool xserver-xorg-input-void xserver-xorg-video-dummy

Para cargar el modulo ALSA:

root@jibri:~# echo "snd-aloop" >> /etc/modules
root@jibri:~# modprobe snd-aloop

Así comprobamos que se cargo bien

root@jibri:~# lsmod | grep snd_aloop
snd_aloop 24576 0
snd_pcm 98304 1 snd_aloop
snd 81920 3 snd_timer,snd_aloop,snd_pcm

Instalar JAVA adoptopenjdk-8-hotspot
Jibri usa un JAVA llamado adoptopenjdk-8-hotspot que esta bloqueado para Cuba, para descargarlo hay varias formas: usando vpn es una, en mi caso yo lo descargue de aquí en mi pc , y luego lo instale manualmente en la VM.

Una vez descargado el archivo dicho anteriormente, lo copiamos en la carpeta /home/usuario y pasamos a extraerlo:

root@jibri:/home/usuario# tar xzf OpenJDK8U-jdk_x64_linux_hotspot_8u265b01.tar.gz

Añadiendo esta versión de Java a su PATH

root@jibri:/home/usuario# export PATH=$PWD/jdk8u265-b01/bin:$PATH

Comprobando que todo va bien:

root@jibri:/home/usuario# java -version

Debe devolver algo así:

root@jibri:/home/usuario# java -version
openjdk version "1.8.0_265"
OpenJDK Runtime Environment (AdoptOpenJDK)(build 1.8.0_265-b01)
OpenJDK 64-Bit Server VM (AdoptOpenJDK)(build 25.265-b01, mixed mode)

Pasamos a instalar Google Chrome Stable. En mi caso use un VPN (debido al bloqueo) en mi pc y descargue el .deb desde este link.

Una vez descargado lo copio al VM se pasa a instalarlo:

root@jibri:~# dpkg -i google-chrome-stable_current_amd64.deb

NOTA: La primera vez que lo hice me dio un error de dependencias, instale esas dependencias, y volví a correr dpkg, y se instalo bien.

Creamos el siguiente directorio:

root@jibri:~# mkdir -p /etc/opt/chrome/policies/managed

Luego:

root@jibri:~# echo '{ "CommandLineFlagSecurityWarningsEnabled": false }' >>/etc/opt/chrome/policies/managed/managed_policies.json

Ahora necesitamos Chrome Driver (también bloqueado para cuba). por lo que hice lo mismo que con google chrome… VPN en mi windows y copiar al VM.

Descargue de aquí

Una vez copiado el chromedriver_linux64.zip descargado hacia nuestro VM de jibri, los extraemos

root@jibri:~# unzip ~/chromedriver_linux64.zip -d ~/

Luego borramos el chromedriver_linux64.zip que ya no es necesario, movemos de carpeta el chromedriver y le damos permisos:

root@jibri:~# rm ~/chromedriver_linux64.zip

root@jibri:~# mv -f ~/chromedriver /usr/local/bin/chromedriver

root@jibri:~# chown root:root /usr/local/bin/chromedriver

root@jibri:~# chmod 0755 /usr/local/bin/chromedriver

Una vez hecho eso vamos finalmente a instalar jibri.

root@jibri:~# wget -qO - https://download.jitsi.org/jitsi-key.gpg.key | sudo apt-key add -

root@jibri:~# sh -c "echo 'deb https://download.jitsi.org stable/' > /etc/apt/sources.list.d/jitsi-stable.list"

root@jibri:~# apt update && apt install jibri

Una vez instalado le damos permisos al usuario jibri que se crea durante la instalación jibri:

root@jibri:~# usermod -aG adm,audio,video,plugdev jibri

Como jibri usa google chrome para conectarse a la videoconferencia y grabarla, me daba error en la parte del certificado auto firmado, por eso hay que decirle a google chrome que lo acepte automáticamente, yo lo hice así:

root@jibri:~# mv /usr/bin/google-chrome /usr/bin/google-chrome-orig

root@jibri:~# cat <<EOF >/usr/bin/google-chrome
#!/bin/bash
/usr/bin/google-chrome-orig --ignore-certificate-errors \$@
EOF

El archivo debe quedar asi:

root@jibri:~# cat /usr/bin/google-chrome
#!/bin/bash
/usr/bin/google-chrome-orig --ignore-certificate-errors $@

Finalmente le damos permisos:

root@jibri:~# chmod +x /usr/bin/google-chrome

NOTA: Hacemos una salva de ambos contenedores.

Ahora pasamos a la configuración de Jitsi Meet server para que jibri se conecte a el (esto se hace en el Jitsi server todo)

Editamos el archivo:

root@conferencias:~# nano /etc/prosody/conf.d/conferencias.empresa.cu.cfg.lua

Agregamos al final del archivo lo siguiente:

-- internal muc component, meant to enable pools of jibri and jigasi clients
Component "internal.auth.conferencias.empresa.cu" "muc"
modules_enabled = {
"ping";
}
storage = "memory"
muc_room_cache_size = 1000

VirtualHost "recorder.conferencias.empresa.cu"
modules_enabled = {
"ping";
}
authentication = "internal_plain"

Reiniciamos el prosody:

root@conferencias:~# service prosody restart

Creamos los siguientes usuarios:

root@conferencias:~# prosodyctl register jibri auth.conferencias.empresa.cu passjibri

root@conferencias:~# prosodyctl register recorder recorder.conferencias.empresa.cu passrecorder

Editamos ahora:

root@conferencias:~# nano /etc/jitsi/jicofo/sip-communicator.properties

Añadimos lo siguiente:

org.jitsi.jicofo.jibri.BREWERY=JibriBrewery@internal.auth.conferencias.empresa.cu
org.jitsi.jicofo.jibri.PENDING_TIMEOUT=90

Reiniciamos Jicofo:

root@conferencias:~# service jicofo restart

Editamos:

root@conferencias:~# nano /etc/jitsi/meet/conferencias.empresa.cu-config.js

Buscamos dentro de la configuración los siguientes parámetros, que están comentados, y los dejamos así:

fileRecordingsEnabled: true,
hiddenDomain: 'recorder.conferencias.empresa.cu',

Debemos asegurarnos de que en el archivo siguiente en TOOLBAR_BUTTONS este el botón recorder habilitado por lo que editamos

root@conferencias:~# /usr/share/jitsi-meet/interface_config.js

y aproximadamente en la línea 187 está: TOOLBAR_BUTTONS

ahí agregamos:

'recording'

En mi caso yo edite mas cosas en TOOLBAR_BUTTONS y me queda de la siguiente forma:

TOOLBAR_BUTTONS: [
'microphone', 'camera', 'closedcaptions', 'desktop', 'fullscreen',
'fodeviceselection', 'hangup', 'profile', 'recording',
'etherpad', 'settings', 'raisehand',
'videoquality', 'filmstrip', 'feedback', 'shortcuts',
'tileview', 'download', 'help', 'mute-everyone', ],

11- Ahora pasamos a configurar en el jibri para que se conecte a Jitsi Meet:

root@jibri:~# nano /etc/jitsi/jibri/config.json

Adentro le ponemos e siguiente contenido:

//////////////////////////////////////////////////////////////////////

{
// NOTE: this is a *SAMPLE* config file, it will need to be configured with
// values from your environment
// Where recording files should be temporarily stored
"recording_directory":"/srv/recordings",
// The path to the script which will be run on completed recordings
"finalize_recording_script_path": "/path/to/finalize_recording.sh",
"xmpp_environments": [
{
// A friendly name for this environment which can be used
// for logging, stats, etc.
"name": "prod environment",
// The hosts of the XMPP servers to connect to as part of
// this environment
"xmpp_server_hosts": [
"conferencias.empresa.cu"
],
// The xmpp domain we'll connect to on the XMPP server
"xmpp_domain": "conferencias.empresa.cu",
// Jibri will login to the xmpp server as a privileged user
"control_login": {
// The domain to use for logging in
"domain": "auth.conferencias.empresa.cu",
// The credentials for logging in
"username": "jibri",
"password": "passjibri"
},
// Using the control_login information above, Jibri will join
// a control muc as a means of announcing its availability
// to provide services for a given environment
"control_muc": {
"domain": "internal.auth.conferencias.empresa.cu",
"room_name": "JibriBrewery",
"nickname": "jibri-nickname"
},
// All participants in a call join a muc so they can exchange
// information. Jibri can be instructed to join a special muc
// with credentials to give it special abilities (e.g. not being
// displayed to other users like a normal participant)
"call_login": {
"domain": "recorder.conferencias.empresa.cu",
"username": "recorder",
"password": "passrecorder"
},
// When jibri gets a request to start a service for a room, the room
// jid will look like:
// roomName@optional.prefixes.subdomain.xmpp_domain
// We'll build the url for the call by transforming that into:
// https://xmpp_domain/subdomain/roomName
// So if there are any prefixes in the jid (like jitsi meet, which
// has its participants join a muc at conference.xmpp_domain) then
// list that prefix here so it can be stripped out to generate
// the call url correctly
"room_jid_domain_string_to_strip_from_start": "conference.",
// The amount of time, in minutes, a service is allowed to continue.
// Once a service has been running for this long, it will be
// stopped (cleanly). A value of 0 means an indefinite amount
// of time is allowed
"usage_timeout": "0"
}
]
}

//////////////////////////////////////////////////////////////////////

Creamos el siguiente directorio:

root@jibri:~# mkdir /srv/recordings

le damos permisos a jibri para acceder a ese directorio:

root@jibri:~# chown jibri:jitsi /srv/recordings

reiniciamos y habilitamos jibri:

root@jibri:~# service jibri restart
root@jibri:~# systemctl enable jibri

Reiniciamos todo y probamos.

 

Espero les sirva y no olviden darle like.