BigBlueButton

Updated 8 Avril 2021

BigBlueButton

BigBlueButton est un outil de conférence Web open source. Au départ, elle a été conçue à des fins éducatives. Son nom vient de l'idée de base, qui est de pouvoir démarrer une conférence Web aussi facilement que possible, comme si l'on appuyait sur un "gros bouton bleu".

Créer un conteneur LXC

BigBlueButton est développé et testé sur Ubuntu Xenial. Vous pouvez installer Ubuntu dans un conteneur LXC. Pour créer un conteneur LXC, il faut d'abord installer les paquets requis :

emerge -a app-emulation/lxc dev-libs/libcgroup

Lancez cgconfig pour créer le cgroup systemd :

/etc/init.d/cgconfig start

Configurer le démarrage de Docker dans un environnement LXC

Si Docker est utilisé dans un conteneur LXC, chargez les modules du noyau nécessaires sur l'hôte et ajoutez-les à la liste de démarrage automatique :

modprobe -a br_netfilter ip_tables nf_conntrack_netlink nf_nat overlay xt_conntrack

echo -e "br_netfilter\nip_tables\nnf_conntrack_netlink\nnf_nat\noverlay\nxt_conntrack" > /etc/modules-load.d/docker.conf

Créez un conteneur pour BigBlueButton :

lxc-create -t download -n bigbluebutton -- -d ubuntu -r xenial -a amd64

Lancez-le :

lxc-start bigbluebutton

Configurez votre réseau conformément aux [instructions] (lxc#nastroika_seti_konteinera), mais n'attribuez pas d'adresse IP ni de passerelle en modifiant le fichier de configuration du conteneur.

Autorisez l'exécution du test hello-world pour Docker :

/var/calculate/lxc/calculate/config
lxc.cgroup.devices.allow = c 10:200 rwm

Modifiez les paramètres du réseau dans le conteneur. Indiquez l'adresse IP, le masque de réseau, la passerelle par défaut et les adresses des serveurs DNS :

/etc/network/interfaces
...
auto eth0
iface eth0 inet static
  address 192.168.11.2
  netmask 255.255.255.0
  gateway 192.168.11.1
  dns-nameservers 8.8.8.8
...

Relancez le conteneur.

lxc-stop -r bigbluebutton

Connectez le conteneur :

lxc-attach bigbluebutton

Actualisez le dépôt binaire :

apt-get update

Installez le client et le serveur SSH :

apt-get install ssh openssh-server -y

Modifiez le mot de passe root :

passwd

Autorisez l'utilisateur root à se connecter via SSH :

/etc/ssh/sshd_config
...
PermitRootLogin yes
...

Relancez SSH:

systemctl restart ssh

Réinitialisez la locale :

sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen

sed -i -e 's/# ru_RU.UTF-8 UTF-8/ru_RU.UTF-8 UTF-8/' /etc/locale.gen

dpkg-reconfigure --frontend=noninteractive locales

update-locale LANG=en_US.UTF-8

Vérifiez que la locale est bien définie en tant que variable d'environnement :

systemctl show-environment
LANG=en_US.UTF-8
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Ajoutez la définition du serveur comme meet.example.org :

/etc/hosts
127.0.0.1   meet.example.org bigbluebutton localhost

Comme l'installation se fait dans un conteneur, certains composants de BigBlueButton ont besoin d'une source entropy. Installez le générateur de nombres aléatoires :

apt-get install haveged -y

Ajoutez le démon à la liste de démarrage automatique et lancez-le :

systemctl enable haveged

systemctl start haveged

Installez la boîte à outils de gestion des dépôts :

apt-get install software-properties-common -y

Installer et configurer BigBlueButton

Ajoutez les dépôts à partir desquels l'installation doit être effectuée :

add-apt-repository ppa:bigbluebutton/support -y

add-apt-repository ppa:rmescandon/yq -y

Activez le dépôt MongoDB et installez la base de données :

wget -qO - https://www.mongodb.org/static/pgp/server-3.4.asc | apt-key add -

echo "deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.4 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-3.4.list

apt-get update

apt-get install -y mongodb-org curl

Ajoutez le dépôt NodeJS avec la version 8.x et mettez-le en place :

curl -sL https://deb.nodesource.com/setup_8.x | bash -

apt-get install -y nodejs

Ajoutez la clé et le dépôt BigBlueButton :

wget https://ubuntu.bigbluebutton.org/repo/bigbluebutton.asc -O- | apt-key add -

echo "deb https://ubuntu.bigbluebutton.org/xenial-220/ bigbluebutton-xenial main" | tee /etc/apt/sources.list.d/bigbluebutton.list

apt-get update

Lancez l'installation de BigBlueButton :

apt-get install bigbluebutton -y

Vous serez tenu d'accepter la licence EULA.

En raison des limitations de LXC, le processus d'installation ne peut pas être achevé si Redis et FreeSWITCH ne peuvent pas démarrer.

Corrigez le module de démarrage de Redis en désactivant les restrictions manquantes :

/etc/systemd/system/redis.service
[Unit]
Description=Advanced key-value store
After=network.target
Documentation=http://redis.io/documentation, man:redis-server(1)

[Service]
Type=forking
ExecStart=/usr/bin/redis-server /etc/redis/redis.conf
PIDFile=/var/run/redis/redis-server.pid
TimeoutStopSec=0
Restart=always
User=redis
Group=redis

ExecStartPre=-/bin/run-parts --verbose /etc/redis/redis-server.pre-up.d
ExecStartPost=-/bin/run-parts --verbose /etc/redis/redis-server.post-up.d
ExecStop=-/bin/run-parts --verbose /etc/redis/redis-server.pre-down.d
ExecStop=/bin/kill -s TERM $MAINPID
ExecStopPost=-/bin/run-parts --verbose /etc/redis/redis-server.post-down.d

UMask=007
#PrivateTmp=yes
#PrivateDevices=yes
#ProtectHome=yes
#ReadOnlyDirectories=/
#ReadWriteDirectories=-/var/lib/redis
#ReadWriteDirectories=-/var/log/redis
#ReadWriteDirectories=-/var/run/redis
#CapabilityBoundingSet=~CAP_SYS_PTRACE

# redis-server writes its own config file when in cluster mode so we allow
# writing there (NB. ProtectSystem=true over ProtectSystem=full)
#ProtectSystem=true
#ReadWriteDirectories=-/etc/redis

[Install]
WantedBy=multi-user.target
Alias=redis.service

Démarrez Redis :

systemctl daemon-reload

systemctl start redis

Corrigez le module de démarrage de FreeSWITCH en désactivant les restrictions manquantes :

/etc/systemd/system/multi-user.target.wants/freeswitch.service
[Unit]
Description=freeswitch
After=syslog.target network.target local-fs.target

[Service]
; service
Type=forking
PIDFile=/opt/freeswitch/var/run/freeswitch/freeswitch.pid
Environment="DAEMON_OPTS=-nonat"
EnvironmentFile=-/etc/default/freeswitch
ExecStart=/opt/freeswitch/bin/freeswitch -u freeswitch -g daemon -ncwait $DAEMON_OPTS
TimeoutSec=45s
Restart=always
; exec
WorkingDirectory=/opt/freeswitch
User=freeswitch
Group=daemon

#LimitCORE=infinity
#LimitNOFILE=100000
#LimitNPROC=60000
#LimitSTACK=250000
#LimitRTPRIO=infinity
#LimitRTTIME=7000000
#IOSchedulingClass=realtime
#IOSchedulingPriority=2
#CPUSchedulingPolicy=rr
#CPUSchedulingPriority=89

#UMask=0007

[Install]
WantedBy=multi-user.target

Lancez FreeSWITCH:

systemctl daemon-reload

systemctl start freeswitch

Reprenez l'installation :

apt-get install -f

Installer BigBlueButton HTML5 :

apt-get install bbb-html5

Pour réduire les bruits d'impulsion, réglez le niveau sonore pour la transmission de la voix entre utilisateurs :

/opt/freeswitch/etc/freeswitch/autoload_configs/conference.conf.xml
<profile name="cdquality">
  <param name="domain" value="$${domain}"/>
  <param name="rate" value="48000"/>
  <param name="interval" value="20"/>
  <param name="energy-level" value="10"/>
...

Redémarrer BigBlueButton:

bbb-conf --restart

Contrôler les erreurs de configuration :

bbb-conf --check
BigBlueButton Server 2.2.3 (1833)
                    Kernel version: 4.19.96-calculate
                      Distribution: Ubuntu 16.04.6 LTS (64-bit)
                            Memory: 131797 MB
                         CPU cores: 16

/usr/share/bbb-web/WEB-INF/classes/bigbluebutton.properties (bbb-web)
       bigbluebutton.web.serverURL: http://meet.example.org
                defaultGuestPolicy: ALWAYS_ACCEPT
                 svgImagesRequired: true

/etc/nginx/sites-available/bigbluebutton (nginx)
                       server name: http://meet.example.org
                              port: 80, [::]:80
                    bbb-client dir: /var/www/bigbluebutton

/var/www/bigbluebutton/client/conf/config.xml (bbb-client)
                Port test (tunnel): rtmp://meet.example.org
                              red5: meet.example.org
              useWebrtcIfAvailable: true

/opt/freeswitch/etc/freeswitch/vars.xml (FreeSWITCH)
                       local_ip_v4: 192.168.11.2
                   external_rtp_ip: stun:stun.freeswitch.org
                   external_sip_ip: stun:stun.freeswitch.org

/opt/freeswitch/etc/freeswitch/sip_profiles/external.xml (FreeSWITCH)
                        ext-rtp-ip: $${local_ip_v4}
                        ext-sip-ip: $${local_ip_v4}
                        ws-binding: :5066
                       wss-binding: :7443

/usr/local/bigbluebutton/core/scripts/bigbluebutton.yml (record and playback)
                     playback_host: meet.example.org
                 playback_protocol: http
                            ffmpeg: 4.2.2-1bbb1~ubuntu16.04

/etc/bigbluebutton/nginx/sip.nginx (sip.nginx)
                        proxy_pass: 192.168.11.2

/usr/local/bigbluebutton/bbb-webrtc-sfu/config/default.yml (Kurento SFU)
                        kurento.ip: 192.168.11.2
                       kurento.url: ws://127.0.0.1:8888/kurento
                    localIpAddress: 192.168.11.2
               recordScreenSharing: true
                     recordWebcams: true
                  codec_video_main: VP8
               codec_video_content: VP8

/usr/share/meteor/bundle/programs/server/assets/app/config/settings.yml (HTML5 client)
                             build: 870
                        kurentoUrl: wss://meet.example.org/bbb-webrtc-sfu
                  enableListenOnly: true

# Potential problems described below

Spécifiez le nom d'hôte pour BigBlueButton, meet.example.org :

bbb-conf --setip meet.example.org

Configuration HTTPS

Obtenir le certificat Let's Encrypt

Procurez-vous un certificat pour le domaine meet.example.org, comme expliqué dans le manuel.

Configuration HTTPS pour Nginx

Créer un répertoire dédié aux certificats :

mkdir /etc/nginx/ssl

Copiez les certificats reçus via Let's Encrypt :

cp fullchain.pem /etc/nginx/ssl/meet.example.org/fullchain.pem

cp privkey.pem /etc/nginx/ssl/meet.example.org/privkey.pem

Créer une clé DH :

openssl dhparam -out /etc/nginx/ssl/dhp-4096.pem 4096

Ajoutez HTTPS Nginx:

/etc/nginx/sites-available/bigbluebutton
server {
    server_name meet.example.org;
    listen 80;
    listen [::]:80;
    listen 443 ssl;
    listen [::]:443 ssl;

    ssl_certificate /etc/nginx/ssl/meet.example.org/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/meet.example.org/privkey.pem;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers "ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+3DES:!aNULL:!MD5:!DSS:!AES256";
    ssl_prefer_server_ciphers on;
    ssl_dhparam /etc/nginx/ssl/dhp-4096.pem;

    if ($scheme = http) {
        return 301 https://$server_name$request_uri;
    }
    ...

Configuration FreeSWITCH pour SSL

Configurez FreeSWITCH pour l'utilisation de SSL. Pour ce faire, indiquez l'adresse externe :

/etc/bigbluebutton/nginx/sip.nginx
location /ws {
    proxy_pass https://1.2.3.4:7443;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "Upgrade";
    proxy_read_timeout 6h;
    proxy_send_timeout 6h;
    client_body_timeout 6h;
    send_timeout 6h;
}

Important

Il est à noter que c'est l'adresse IP externe qui est indiquée dans cette configuration, et non le nom de l'hôte.

Configurer BigBlueButton pour l'exécution de sessions HTTPS

Configurez BigBlueButton pour l'exécution de sessions HTTPS et HTML5 :

/usr/share/bbb-web/WEB-INF/classes/bigbluebutton.properties
...
#----------------------------------------------------
# This URL is where the BBB client is accessible. When a user sucessfully
# enters a name and password, she is redirected here to load the client.
# Do not commit changes to this field.
bigbluebutton.web.serverURL=https://meet.example.org
...
# Force all attendees to join the meeting using the HTML5 client
attendeesJoinViaHTML5Client=true

# Force all moderators to join the meeting using the HTML5 client
moderatorsJoinViaHTML5Client=true

Partagez l'accès à l'écran, aussi par HTTPS :

/usr/share/red5/webapps/screenshare/WEB-INF/screenshare.properties
...
streamBaseUrl=rtmp://meet.example.org/screenshare
jnlpUrl=https://meet.example.org/screenshare
jnlpFile=https://meet.example.org/screenshare/screenshare.jnlp

Demander au client de charger les composants via HTTPS :

sed -e 's|http://|https://|g' -i /var/www/bigbluebutton/client/conf/config.xml

Configurer WebRTC via le socket SSL :

/usr/share/meteor/bundle/programs/server/assets/app/config/settings.yml
...
  kurento:
    wsUrl: wss://meet.example.org/bbb-webrtc-sfu
...
  note:
    enabled: true
    url: https://meet.example.org/pad
...

Configurez le traitement des enregistrements via HTTPS :

/usr/local/bigbluebutton/core/scripts/bigbluebutton.yml
...
playback_protocol: https

Redémarrer BigBlueButton:

bbb-conf --restart

Redémarrez Nginx :

systemctl restart nginx

Configuration d'un serveur TURN

Configurez votre serveur TURN, turn.example.org, comme expliqué dans le manuel.

Indiquez à BigBlueButton d'utiliser le serveur turn.example.org configuré comme serveur STUN et TURN. Pour vous connecter au serveur TURN, utilisez la clé 4b85833c7fdf06130bd7398ac9af558b. Elle est enregistrée dans static-auth-secret, dans les paramètres de votre serveur TURN.

/usr/share/bbb-web/WEB-INF/classes/spring/turn-stun-servers.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="stun0" class="org.bigbluebutton.web.services.turn.StunServer">
        <constructor-arg index="0" value="stun:turn.example.org"/>
    </bean>

    <bean id="turn0" class="org.bigbluebutton.web.services.turn.TurnServer">
        <constructor-arg index="0" value="4b85833c7fdf06130bd7398ac9af558b"/>
        <constructor-arg index="1" value="turns:turn.example.org:443?transport=tcp"/>
        <constructor-arg index="2" value="86400"/>
    </bean>

    <bean id="turn1" class="org.bigbluebutton.web.services.turn.TurnServer">
        <constructor-arg index="0" value="4b85833c7fdf06130bd7398ac9af558b"/>
        <constructor-arg index="1" value="turn:turn.example.org:443?transport=tcp"/>
        <constructor-arg index="2" value="86400"/>
    </bean>

    <bean id="stunTurnService"
            class="org.bigbluebutton.web.services.turn.StunTurnService">
        <property name="stunServers">
            <set>
                <ref bean="stun0"/>
            </set>
        </property>
        <property name="turnServers">
            <set>
                <ref bean="turn0"/>
                <ref bean="turn1"/>
            </set>
        </property>
    </bean>
</beans>

Redémarrer BigBlueButton:

bbb-conf --restart

Configurer Greenlight

Greenlight est une application Ruby on Rails qui fournit une interface simple permettant aux utilisateurs de créer des salles, d'organiser des conférences et de gérer les enregistrements de celles-ci.

Installez les outils nécessaires pour connecter le dépôt :

apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common -y

Ajoutez les clés et associez le dépôt de Docker :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -

apt-key fingerprint 0EBFCD88

add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

apt-get update

Installez Docker 17.09.1 :

apt-get install docker-ce=17.09.1~ce-0~ubuntu docker-compose containerd.io -y

Vérifiez que Docker fonctionne en démarrant le conteneur hello-world :

docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete 
Digest: sha256:f9dfddf63636d84ef479d645ab5885156ae030f611a56f3a7ac7f2fdd86d7e4e
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.
...

Désactivez la mise à jour de docker-ce :

echo docker-ce hold | dpkg --set-selections

Créez un répertoire de configuration pour GreenLight :

mkdir ~/greenlight && cd ~/greenlight

Préparez un exemple de fichier de configuration GreenLight :

docker run --rm bigbluebutton/greenlight:v2 cat ./sample.env > .env

Créez une clé secrète pour GreenLight :

docker run --rm bigbluebutton/greenlight:v2 bundle exec rake secret

458e2c786750cb534f2350d12bcf173052cf5fa275c66d545fb64affe805f49cb09169a8a8799cbcaff7762c1c1664e48e5cf4d8754a5f0865e0c9fedc53e1cc

Enregistrez cette valeur dans la variable SECRET_KEY_BASE du fichier.env:

~/greenlight/.env
# Create a Secret Key for Rails
#
# You can generate a secure one through the Greenlight docker image
# with the command.
#
#   docker run --rm bigbluebutton/greenlight:v2 bundle exec rake secret
#
SECRET_KEY_BASE=458e2c786750cb534f2350d12bcf173052cf5fa275c66d545fb64affe805f49cb09169a8a8799cbcaff7762c1c1664e48e5cf4d8754a5f0865e0c9fedc53e1cc
...

Récupérer l'URL du BigBlueButton et sa clé :

bbb-conf --secret
    URL: https://meet.example.org/bigbluebutton/
    Secret: zZ7XSEB7EjubByrCxAthTNYomDVbMwjUbfT4xqoa3p

    Link to the API-Mate:
    https://mconf.github.io/api-mate/#server=https://meet.example.org/bigbluebutton/&sharedSecret=zZ7XSEB7EjubByrCxAthTNYomDVbMwjUbfT4xqoa3p

Enregistrez cette valeur dans les variables BIGBLUEBUTTON_ENDPOINT et BIGBLUEBUTTON_SECRET du fichier.env:

~/greenlight/.env
...
# The endpoint and secret for your BigBlueButton server.
# Set these if you are running GreenLight on a single BigBlueButton server.
# You can retrive these by running the following command on your BigBlueButton server:
#
#   bbb-conf --secret
#
BIGBLUEBUTTON_ENDPOINT=https://meet.example.org/bigbluebutton/
BIGBLUEBUTTON_SECRET=zZ7XSEB7EjubByrCxAthTNYomDVbMwjUbfT4xqoa3p

Vérifiez les paramètres de GreenLight :

docker run --rm --env-file .env bigbluebutton/greenlight:v2 bundle exec rake conf:check
Checking environment: Passed
Checking Connection: Passed
Checking Secret: Passed

Ajoutez une configuration Nginx :

docker run --rm bigbluebutton/greenlight:v2 cat ./greenlight.nginx | tee /etc/bigbluebutton/nginx/greenlight.nginx

Ajoutez une référence BigBlueButton à la page de GreenLight :

/etc/nginx/sites-available/bigbluebutton
...
    # Redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
            root   /var/www/nginx-default;
    }
    location = / {
        return 307 /b;
    }
}

Créez un script pour docker-compose :

docker run --rm bigbluebutton/greenlight:v2 cat ./docker-compose.yml > docker-compose.yml

Créez un mot de passe pour PostgreSQL :

export pass=$(openssl rand -hex 8); sed -i 's/POSTGRES_PASSWORD=password/POSTGRES_PASSWORD='$pass'/g' docker-compose.yml;sed -i 's/DB_PASSWORD=password/DB_PASSWORD='$pass'/g' .env

Modifiez la version de docker-compose :

sed -i "s/version: '3'/version: '2'/" docker-compose.yml

Démarrez le conteneur :

docker-compose up -d

Redémarrez Nginx :

systemctl restart nginx

Créer le compte administrateur :

docker exec greenlight-v2 bundle exec rake user:create["Admin Name","support@example.org","password","admin"]

C'est fait ! Une fois meet.example.org ouvert, le site ressemblera à ceci :

BigBlueButton est bien installé

Pour vous connecter en tant qu'administrateur, indiquez l'e-mailsupport@example.org~ et le mot de passe admin~~.

Configurer les notifications e-mail

Pour activer la confirmation du compte par courriel, spécifiez les paramètres du serveur de messagerie d'envoi :

~/greenlight/.env
...
# Set this to true if you want GreenLight to send verification emails upon
# the creation of a new account
#
ALLOW_MAIL_NOTIFICATIONS=true

SMTP_SERVER=mail.example.org
SMTP_PORT=465
SMTP_DOMAIN=example.org
SMTP_USERNAME=
SMTP_PASSWORD=
SMTP_ATUH=
SMTP_STARTTLS_AUTO=true

# Specify the email address that all mail is sent from
SMTP_SENDER=support@example.org
...

Relancez Greenlight :

docker-compose down && docker-compose up -d

Changer de mot de passe

Pour modifier le mot de passe d'un utilisateur, vous pouvez utiliser le terminal RubyOnRail :

docker exec -it greenlight-v2 bundle exec rails c

Loading production environment (Rails 5.2.3)
irb(main):001:0> User.find_by(email: "user@example.org").update_attribute(:password, "new_secret")
=> true

Une fois cette opération effectuée, vous pouvez réinitialiser le mot de passe de l'utilisateur sur la page d'édition du compte :

Réinitialiser le mot de passe utilisateur

Mettre à jour BigBlueButton

Connectez le conteneur :

lxc-attach bigbluebutton

Actualisez le dépôt binaire :

apt-get update

Mettez à jour tous les paquets du système :

apt-get dist-upgrade

Actualisez l'image de Greenlight :

cd ~/greenlight

docker pull bigbluebutton/greenlight:v2

Assurez-vous que les paramètres n'ont pas été modifiés après la mise à jour :

/opt/freeswitch/etc/freeswitch/autoload_configs/conference.conf.xml
<profile name="cdquality">
  <param name="domain" value="$${domain}"/>
  <param name="rate" value="48000"/>
  <param name="interval" value="20"/>
  <param name="energy-level" value="10"/>
...

Relancez le conteneur.

lxc-stop -r bigbluebutton

Récupération d'images Docker avec Btrfs

Si votre conteneur utilise Btrfs, Docker se servira de sous-volumes pour les images, qui ne seront pas copiées lors de la création d'instantanés pour ce conteneur. Vous devez télécharger à nouveau les fichiers sources pour lancer Greenlight.

Téléchargez à nouveau toutes les images Docker utilisées avec Greenlight :

cd ~/greenlight

docker pull bigbluebutton/greenlight:v2

docker pull postgres:9.5

Relancez Greenlight :

docker-compose down && docker-compose up -d