Habilitando gravações e streaming Jitsi com Jibri

Se em um Postagem anterior Vimos como podemos configurar nossa própria solução de videoconferência para nossa empresa, Hoje vamos dar algumas adições, como a possibilidade de gravar as sessões ou transmitir ao vivo nossas reuniões.

Através do Jibri podemos gravar em disco ou na nuvem as sessões que fazemos, bem como se você quiser fazer uma transmissão ao vivo e transmitir no Youtube. Uma consideração importante será que só podemos fazer uma gravação simultaneamente ou transmitir, para mais, teremos que criar diferentes Jibri's (por exemplo, em recipientes).

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

No meu 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:

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

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

curl -sS -o - https (em inglês)://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add
echo "Deb [arco = amd64] Referências 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": Falso }' >>/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 (em inglês)://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,áudio,vídeo,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=Ji**********@in******.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: Verdadeiro,
liveStreamingEnabled: Verdadeiro,
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": [
        {
            "Nome": "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
                "nome de usuário": "jibri",
                "senha": "CONTRASEÑA"
            },
            "control_muc": {
                "domain": "internal.auth.meet.dominio.eso",
                "room_name": "JibriBrewery",
                "nickname": "jibri-nickname"
            },
            "call_login": {
                "domain": "recorder.meet.dominio.eso",
                "nome de usuário": "recorder",
                "senha": "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

E é isso! 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.