Permitiendo grabaciones y streaming en Jitsi con Jibri

Si en un post anterior vimos cómo podemos montarnos nuestra propia solución de videoconferencias para nuestra empresa, hoy le vamos a dar un par de añadidos, como es la posibilidad de grabar las sesiones o hacer streaming en directo de nuestras reuniones.

Mediante Jibri vamos a poder permitir grabar en disco o en nube las sesiones que hagamos, así como si se quiere hacer un directo y retransmitir por Youtube. Una consideración importante será que sólo podemos hacer una grabación de manera simultánea o streaming, para más, deberemos crear distintos Jibri’s (por ejemplo en contenedores).

La idea es seguir el post anterior así que vamos a permitir está interesante funcionalidad! Partimos de que en Github se encuentra todo el proyecto y perfectamente documentado, aquí vamos con un Ubuntu 20.04.

Empezamos con lo fundamental, tenemos que tener la versión 8 de Java, conoceremos la versión que tenemos ejecutando:

java -version

 

En mi caso, al tener Ubuntu 20.04, veo que tengo la versión 11, así que hay que hacer downgrade, primero aseguramos instalar la versión 8:

sudo apt-get install openjdk-8-jre
sudo apt-get install openjdk-8-jdk

 

Y al ejecutar ‘update-alternatives –config java’ podremos elegir la versión de java que usaremos, en mi caso elegimos la 2:

There are 2 choices for the alternative java (providing /usr/bin/java).

  Selection    Path                                            Priority   Status
------------------------------------------------------------
* 0            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1111      auto mode
  1            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1111      manual mode
  2            /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java   1081      manual mode

 

Creamos la variable JAVA_HOME con ‘nano ~/.bashrc’, la añadimos al final del fichero, y tras grabar el fichero saldremos de sesión y volveremos a cargar para confirmar que la variable se carga (con un simple ‘echo $JAVA_HOME’).

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-amd64/bin/java

 

Instalamos las siguientes dependencias que serán necesarias:

apt update
apt install unzip ffmpeg curl alsa-utils icewm xdotool xserver-xorg-input-void xserver-xorg-video-dummy -y

 

Cargamos el módulo ALSA loopback, forzamos a que se cargue en el boot y verificamos que lo tenemos cargado:

echo "snd-aloop" >> /etc/modules
modprobe snd-aloop
lsmod | grep snd_aloop

 

Instalamos la última versión estable de Google Chrome:

curl -sS -o - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add
echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" > /etc/apt/sources.list.d/google-chrome.list
apt update && apt install google-chrome-stable -y

 

Para ocultar el Warning que nos sacará Chrome que grabará la sesión: “Chrome is being controlled by automated test software” lo indicaremos mediante una preferencia:

mkdir -p /etc/opt/chrome/policies/managed
echo '{ "CommandLineFlagSecurityWarningsEnabled": false }' >>/etc/opt/chrome/policies/managed/managed_policies.json

 

También necesitaremos Chromedriver:

CHROME_DRIVER_VERSION=`curl -sS chromedriver.storage.googleapis.com/LATEST_RELEASE`
wget -N http://chromedriver.storage.googleapis.com/$CHROME_DRIVER_VERSION/chromedriver_linux64.zip -P ~/
unzip ~/chromedriver_linux64.zip -d ~/
rm ~/chromedriver_linux64.zip
mv -f ~/chromedriver /usr/local/bin/chromedriver
chown root:root /usr/local/bin/chromedriver
chmod 0755 /usr/local/bin/chromedriver

 

Instalamos el repositorio de Jitsi para instalar Jibri finalmente:

wget -qO - https://download.jitsi.org/jitsi-key.gpg.key | sudo apt-key add -
sh -c "echo 'deb https://download.jitsi.org stable/' > /etc/apt/sources.list.d/jitsi-stable.list"
apt update
apt install jibri -y

 

Metemos al usuario de Jibri en los grupos para tener acceso a los dispositivos de audio o video:

usermod -aG adm,audio,video,plugdev jibri

 

Añadimos al final del fichero /etc/prosody/conf.avail/meet.dominio.eso.cfg.lua lo siguiente:

Component "internal.auth.meet.dominio.eso" "muc"
    modules_enabled = {
      "ping";
    }
    storage = "memory"
    muc_room_cache_size = 1000

VirtualHost "recorder.meet.dominio.eso"
    modules_enabled = {
      "ping";
    }
    authentication = "internal_plain"

 

Y recargamos Prosody:

prosody reload

 

Creamos las dos cuentas que utilizará Prosody y les establecemos una contraseña que usaremos en un ratito:

prosodyctl register jibri auth.meet.dominio.eso CONTRASEÑA
prosodyctl register recorder recorder.meet.dominio.eso CONTRASEÑA

 

Añadimos estas 2 linas al final de ‘/etc/jitsi/jicofo/sip-communicator.properties’ para localizar los controladores Jibri:

org.jitsi.jicofo.jibri.BREWERY=JibriBrewery@internal.auth.meet.dominio.eso
org.jitsi.jicofo.jibri.PENDING_TIMEOUT=90

 

Y recargamos Jicofo:

/etc/init.d/jicofo reload

 

Descomentamos y dejar así las siguientes líneas en ‘/etc/jitsi/meet/meet.dominio.eso-config.js’ para habilitar las grabaciones o streaming:

fileRecordingsEnabled: true,
liveStreamingEnabled: true,
hiddenDomain: 'recorder.meet.dominio.eso',

 

Creamos el fichero de configuración de Jibri ‘/etc/jitsi/jibri/config.json’:

{
    "recording_directory":"/srv/recordings",
    "finalize_recording_script_path": "/path/to/finalize_recording.sh",
    "xmpp_environments": [
        {
            "name": "prod environment",
            "xmpp_server_hosts": [
                "meet.dominio.eso"
            ],
            "xmpp_domain": "meet.dominio.eso",
            "control_login": {
                // The domain to use for logging in
                "domain": "auth.meet.dominio.eso",
                // The credentials for logging in
                "username": "jibri",
                "password": "CONTRASEÑA"
            },
            "control_muc": {
                "domain": "internal.auth.meet.dominio.eso",
                "room_name": "JibriBrewery",
                "nickname": "jibri-nickname"
            },
            "call_login": {
                "domain": "recorder.meet.dominio.eso",
                "username": "recorder",
                "password": "CONTRASEÑA"
            },
            "room_jid_domain_string_to_strip_from_start": "conference.",
            "usage_timeout": "0"
        }
    ]
}

Creamos el directorio donde vamos a dejar las grabaciones y nos damos permisos, también podríamos guardarlas en nube o en un share que montemos en la máquina:

mkdir /srv/recordings
chown jibri:jitsi /srv/recordings

 

Reiniciamos Jitsi:

service jibri restart

 

 

Y listo! Podemos probar a hacer una reunión y hacer una transmisión en vivo o hacer una grabación de la reunión.

 

Al iniciar la grabación todos los participantes escucharán un mensaje que se está grabando la sesión y se podrá comprobar también porque veremos un icono arriba a la derecha.

 

Y podremos confirmar que las grabaciones las va dejando en el directorio que hemos indicado, en este ejemplo en ‘/srv/recordings/’.

Espero que como siempre, que os haya resultado de interés y agradecer a todos los que dais esos likes y recomendaciones en redes sociales.