Abilitazione delle registrazioni e dello streaming Jitsi con Jibri

Se in un Messaggio precedente Abbiamo visto come possiamo configurare la nostra soluzione di videoconferenza per la nostra azienda, Oggi gli daremo un paio di aggiunte, come la possibilità di registrare le sessioni o trasmettere in diretta streaming i nostri incontri.

Tramite Jibri potremo registrare su disco o in cloud le sessioni che facciamo, così come se vuoi fare un live streaming e trasmettere su Youtube. Una considerazione importante sarà che possiamo effettuare una registrazione solo contemporaneamente o in streaming, per saperne di più, dovremo creare diversi Jibri (ad esempio in contenitori).

L'idea è di seguire il post precedente, quindi consentiremo questa interessante funzionalità! Partiamo dal fatto che su Github L'intero progetto è ben documentato, eccoci con un Ubuntu 20.04.

Cominciamo con le basi, Dobbiamo avere la versione 8 Giava, Sapremo la versione che abbiamo in esecuzione:

java -version

Nel mio caso, avere Ubuntu 20.04, Vedo che ho la versione 11, Quindi devi eseguire il downgrade, Per prima cosa ci assicuriamo di installare la versione 8:

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

E quando si esegue 'update-alternatives –Configurazione Java’ Saremo in grado di scegliere la versione di Java che utilizzeremo, Nel mio caso abbiamo scelto il 2:

Ci sono 2 Scelte per l'alternativa Java (Fornire /usr/bin/java).

  Stato priorità percorso di selezione
------------------------------------------------------------
* 0            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1111      Modalità automatica
  1            /usr/lib/jvm/java-11-openjdk-amd64/bin/java      1111      Modalità manuale
  2            /usr/lib/jvm/java-8-openjdk-amd64/jre/bin/java   1081      Modalità manuale

Creiamo la variabile JAVA_HOME con 'nano ~/.bashrc', Lo aggiungiamo alla fine del file, e dopo aver salvato il file usciremo dalla sessione e caricheremo di nuovo per confermare che la variabile è caricata (con un semplice 'echo $JAVA_HOME').

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

Installiamo le seguenti dipendenze che saranno necessarie:

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

Caricamento del modulo di loopback ALSA, Lo forziamo a caricarsi nel bagagliaio e verifichiamo di averlo caricato:

ECO "snd-aloop" >> /ETC/MODULES modProbe SND-ALOOP LSMOD | Grep snd_aloop

Installiamo l'ultima versione stabile di Google Chrome:

ricciolo -sS -o - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key aggiungi eco "deb [arch=amd64] Protocollo HTTP://dl.google.com/linux/chrome/deb/ stabile principale" > /etc/apt/sources.list.d/google-chrome.list aggiornamento apt && apt installa google-chrome-stable -y

Para ocultar el Warning que nos sacará Chrome que grabará la sesión: “Chrome è controllato da un software di test automatizzato” lo indicaremos mediante una preferencia:

mkdir -p /etc/opt/chrome/policies/managed
echo '{ "CommandLineFlagSecurityWarningsEnabled": Falso }' >>/ecc/opt/chrome/policy/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 ~/ decomprimi ~/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/locale/bin/chromedriver

Abbiamo installato il repository Jitsi per installare finalmente Jibri:

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

Mettiamo l'utente Jibri nei gruppi per avere accesso ai dispositivi audio o video:

usermod -aG adm,audio,video,Plugdev Jibri

Aggiungi alla fine del file /etc/prosody/conf.avail/meet.domain.eso.cfg.lua quanto segue:

Componente "interno.auth.meet.domain.eso" "Muc"
    modules_enabled = {
      "ping";
    }
    stoccaggio = "memoria"
    muc_room_cache_size = 1000

VirtualHost "registratore.meet.domain.eso"
    modules_enabled = {
      "ping";
    }
    autenticazione = "internal_plain"

E ricarichiamo Prosody:

Ricarica Prosodia

Creiamo i due account che Prosody utilizzerà e stabiliamo una password che useremo tra un po':

prosodyctl registra jibri auth.meet.domain.eso PASSWORD prosodyctl registra recorder.meet.domain.eso PASSWORD

Aggiungiamo questi 2 righe alla fine di '/etc/jitsi/jicofo/sip-communicator.properties’ per individuare i driver Jibri:

org.jitsi.jicofo.jibri.BREWERY=Ji**********@in******.esotto
org.jitsi.jicofo.jibri.PENDING_TIMEOUT=90

E ricarichiamo Jicofo:

/etc/init.d/jicofo ricarica

Togliamo il commento e lasciamo le seguenti righe in '/etc/jitsi/meet/meet.dominio.eso-config.js’ per abilitare le registrazioni o lo streaming:

fileRecordingsEnabled: Vero,
liveStreamingAbilitato: Vero,
Dominio nascosto: 'recorder.meet.dominio.eso',

Creiamo il file di configurazione Jibri '/etc/jitsi/jibri/config.json':

{
    "recording_directory":"/SRV/Registrazioni",
    "finalize_recording_script_path": "/percorso/verso/finalize_recording.sh",
    "xmpp_environments": [
        {
            "Nome": "Ambiente di produzione",
            "xmpp_server_hosts": [
                "incontrare.dominio.eso"
            ],
            "xmpp_domain": "incontrare.dominio.eso",
            "control_login": {
                // Il dominio da utilizzare per l'accesso
                "Dominio": "auth.meet.domain.eso",
                // Le credenziali per l'accesso
                "nome utente": "Jibri",
                "parola d’ordine": "PAROLA D’ORDINE"
            },
            "control_muc": {
                "Dominio": "interno.auth.meet.domain.eso",
                "room_name": "Birrificio Jibri",
                "soprannome": "jibri-soprannome"
            },
            "call_login": {
                "Dominio": "registratore.meet.domain.eso",
                "nome utente": "Flauto dolce",
                "parola d’ordine": "PAROLA D’ORDINE"
            },
            "room_jid_domain_string_to_strip_from_start": "conferenza.",
            "usage_timeout": "0"
        }
    ]
}

Creiamo la directory in cui lasceremo le registrazioni e ci diamo i permessi, Potremmo anche salvarli nel cloud o in una condivisione che montiamo sulla macchina:

mkdir /srv/registrazioni chown jibri:jitsi /srv/registrazioni

Riavviamo Jitsi:

Riavvio del servizio Jibri

E questo è tutto! Possiamo provare a fare una riunione e fare un live streaming o fare una registrazione della riunione.

All'avvio della registrazione, tutti i partecipanti sentiranno un messaggio che indica che la sessione è in fase di registrazione e potrai anche controllarlo perché vedremo un'icona in alto a destra.