Aktivieren von Jitsi-Aufnahmen und Streaming mit Jibri

Si en un Vorheriger Beitrag vimos cómo podemos montarnos nuestra propia solución de videoconferencias para nuestra empresa, Heute werden wir ihm ein paar Ergänzungen geben, wie z.B. die Möglichkeit, die Sitzungen aufzuzeichnen oder unsere Meetings live zu streamen.

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

In meinem Fall, 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 "1_i386.deb [arch=amd64] HTTP (Englisch)://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": FALSCH }' >>/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 hinzufügen -
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 = {
      "anpingen";
    }
    storage = "Gedächtnis"
    muc_room_cache_size = 1000

Virtueller Gastgeber "recorder.meet.dominio.eso"
    modules_enabled = {
      "anpingen";
    }
    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: STIMMT,
liveStreamingEnabled: STIMMT,
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
                "Domäne": "auth.meet.dominio.eso",
                // The credentials for logging in
                "Nutzername": "jibri",
                "Passwort": "PASSWORT"
            },
            "control_muc": {
                "Domäne": "internal.auth.meet.dominio.eso",
                "room_name": "JibriBrewery",
                "nickname": "jibri-nickname"
            },
            "call_login": {
                "Domäne": "recorder.meet.dominio.eso",
                "Nutzername": "Blockflöte",
                "Passwort": "PASSWORT"
            },
            "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

Und das ist es! 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.