Ayuda en la Instalación de ScaleLite

209 views

Skip to first unread message

Jonathan Sanchez

unread,

Jul 5, 2020, 5:33:01 PM7/5/20

to BigBlueButton-Espanol

Buen día,

En esta publicación voy a expresar todo el proceso que realice de instalación para que me ayuden en identificar la causa de este error

La instalación de ScaleLite la realice de la siguiente forma.

Nota: (La ayuda que reciba en esta publicación sera utilizada para crear un manual fácil, y que cualquiera pueda hacer esta instalación sin mayor complicación).

Servidor:

El servidor utilizado tiene las siguientes características:

Tipo: VPS

OS: Ubuntu 18.04

Cores: 6

Ram: 16GB

SSD: 700GB

Arquitectura: X86_64

Para esta explicación usare como ejemplo el dominio scalelite.example.com y el ip del servidor como ejemplo sera 111.111.111.111

Paso1:

Establecer el dominio scalelite.example.com como principal en el servidor, de este modo al servidor ya se podrá acceder por el dominio http://scalelite.example.com y no con el http://111.111.111.111

apt-get update
apt-get upgrade
hostnamectl set-hostname scalelite.example.com

Para configurar que el servidor re-direccione las conexiones entrantes a este dominio se debe modificar el archivo /etc/hosts

nano /etc/hosts

se te abrirá un documento para editar con una linea similar a esta:

127.0.0.1 localhost

y deberás agregar una linea quedando así:

127.0.0.1 localhost
111.111.111.111 scalelite.example.com

este documento según cada empresa de servicio de hosting puede variar su contenido, pero las lineas importantes son las expuestas anteriormente.

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Nota: de no tener el editor CLI nano, puede instalarlo de la siguiente forma.

apt-get install nano

con estos comando se actualiza el servidor por primera ves y se coloca como host principal el dominio scalelite.example.com

Nota: El nombre de dominio debe apuntar en su configuración DNS a la ip del servidor, cambiando el A(HOST) a la IP que en este caso seria 111.111.111.111 y colocando en TTL en mi caso 1 semana.

ya teniendo el dominio apuntando a mi servidor podemos iniciar la configuración del ScaleLite.

Paso 2:

ScaleLite requiere para su funcionamiento los siguientes elementos:

Postgresql como base de datos
Redis como cache externo
Multiple servidores Bigbluebutton (Minimo 3)
NFS para crear volumen compartido.

Nota: Para este ejemplo haré la instalación de la base de datos Postgre y el Redis en el mismo servidor donde estamos configurando el ScaleLite.

siguiendo la documentación oficial de este link y documentación de apoyo de este link nos muestra como instalar ScaleLite y uno de los primeros paso globales, es que debemos crear un archivo en el servidor ScaleLite de la siguiente forma

nano /etc/default/scalelite

y se deberá pegar la siguiente información

URL_HOST=
SECRET_KEY_BASE=
LOADBALANCER_SECRET=
DATABASE_URL=
REDIS_URL=
SCALELITE_TAG=
SCALELITE_RECORDING_DIR=
NGINX_SSL=
SCALELITE_NGINX_EXTRA_OPTS=

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Paso 3:

este archivo le dara a ScaleLite las variables globales que necesita para funcionar correctamente, ahora deberemos llenar en se orden la instalación.

URL_HOST: esta variable global hace referencia al nombre host del servidor al que debera apuntar su front-end para hacer la conexión a la API de ScaleLite.

Como generar: este paso ya lo tenemos adelantado, con la configuración del dominio que realizamos antes ya podemos tener nuestro archivo de la siguiente forma:

abrir el archivo con:

nano /etc/default/scalelite

Agregar a URL_HOST= lo siguiente "scalelite.example.com"

quedando de la siguiente forma:

URL_HOST=scalelite.example.com
SECRET_KEY_BASE=
LOADBALANCER_SECRET=
DATABASE_URL=
REDIS_URL=
SCALELITE_TAG=
SCALELITE_RECORDING_DIR=
NGINX_SSL=
SCALELITE_NGINX_EXTRA_OPTS=

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Paso 4:

SECRET_KEY_BASE: Esta variable global hace referencia a un secreto interno que usa RAIL.

Como generar: en el servidor de ScaleLite debes ejecutar el siguiente comando:

openssl rand -hex 64

te generara un resultado de la siguiente forma:

e6f01e4e89982e9183029ffe708f63f19d3211623334cbc7e67cab3d1ab01de882a1c6887177f85afb69f9f4a9394c348ecb70de5f7634023a13a7dfcdc59815

Agregar a SECRET_KEY_BASE= lo siguiente "e6f01e4e89982e9183029ffe708f63f19d3211623334cbc7e67cab3d1ab01de882a1c6887177f85afb69f9f4a9394c348ecb70de5f7634023a13a7dfcdc59815"

quedando de la siguiente forma:

URL_HOST=scalelite.example.com
SECRET_KEY_BASE=e6f01e4e89982e9183029ffe708f63f19d3211623334cbc7e67cab3d1ab01de882a1c6887177f85afb69f9f4a9394c348ecb70de5f7634023a13a7dfcdc59815
LOADBALANCER_SECRET=
DATABASE_URL=
REDIS_URL=
SCALELITE_TAG=
SCALELITE_RECORDING_DIR=
NGINX_SSL=
SCALELITE_NGINX_EXTRA_OPTS=

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Paso 5:

LOADBALANCER_SECRET: Esta variable global es el secreto compartido que las aplicaciones usarán al llamar a las API BigBlueButton en el equilibrador de carga.

Como generar: en el servidor de ScaleLite debes ejecutar el siguiente comando:

openssl rand -hex 32

te generara un resultado de la siguiente forma:

9544794390fb35b647847d29c75114fe527e300a35bd3e2a976b9ccd87f834ce

Agregar a LOADBALANCER_SECRET= lo siguiente " 9544794390fb35b647847d29c75114fe527e300a35bd3e2a976b9ccd87f834ce"

quedando de la siguiente forma:

URL_HOST=scalelite.example.com
SECRET_KEY_BASE=e6f01e4e89982e9183029ffe708f63f19d3211623334cbc7e67cab3d1ab01de882a1c6887177f85afb69f9f4a9394c348ecb70de5f7634023a13a7dfcdc59815
LOADBALANCER_SECRET=9544794390fb35b647847d29c75114fe527e300a35bd3e2a976b9ccd87f834ce
DATABASE_URL=
REDIS_URL=
SCALELITE_TAG=
SCALELITE_RECORDING_DIR=
NGINX_SSL=
SCALELITE_NGINX_EXTRA_OPTS=

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Paso 6:

DATABASE_URL: URL para conectarse a la base de datos PostgreSQL.

Como generar: la documentación oficial de este link nos re-direcciona a una web de rail, que no logre entender como realizar este paso con ese contenido, sin embargo la segunda url de ayuda que he colocado que se encuentra en este link si nos da una idea mas clara al respecto de como hacer este paso.

Para ellos debemos primero ejecutar este comando:

apt-get update

luego seguimos con la instalación de PostgreSql ejecutando el siguiente comando:

apt-get install postgresql postgresql-contrib

Nota: A la fecha de esta publicación este comando me realiza la instalación de PostgreSql en su versión 9.5.21, el cual se puede validar con el siguiente comando, luego de su instalación.

psql --version

Siguiendo con la documentación de ayuda, nos comenta que debemos crear un usuario en nuestro servidor de ScaleLite y un rol en PostgreSql llamado scalelite. como no especifican que permisos debe tener el usuario que crearemos en el servidor simplemente lo haremos básico.

para crear un usuario en el servidor ScaleLite debemos utilizar el siguiente comando:

adduser scalelite

luego nos solicitara una contraseña para este usuario, en este ejemplo le asignare la contraseña "12345".

Nota: Siempre tener en cuenta al crear contraseñas que sean bajo un estándar de seguridad mínimo aceptable.

les va a solicitar repetirla de nuevo.

seguido le pedirá información básica del nuevo usuario creado, que deben llenar según sus necesidades.

muy bien ya tenemos nuestro usuario en el servidor de ScaleLite, ahora nos queda crear un rol en PostgreSql

para empezar a trabajar con PostgreSql en nuestro servidor, Debemos cambiar de usuario he ingresar con el siguiente comando:

sudo -u postgres psql

estando en en el entorno de PostgreSql, vamos a crear el usuario scalelite.

CREATE USER scalelite PASSWORD '12345';

Ahora debemos asignar los permisos de super-usuario a scalelite.

ALTER ROLE scalelite WITH SUPERUSER;

hasta este punto ya tenemos tanto el usuario en el servidor ScaleLite como el rol en PostgreSql creado, con el nombre de "scalelite" y password "12345", ahora debemos asignar estos valores a nuestra variable de entorno de la siguiente forma.

Agregar a DATABASE_URL= lo siguiente "postgresql://scalelite:12345".

Nota: Esta forma aplica cuando PostgreSql se utilizara en el mismo servidor, donde estará ScaleLite.

quedando de la siguiente forma:

URL_HOST=scalelite.example.com
SECRET_KEY_BASE=e6f01e4e89982e9183029ffe708f63f19d3211623334cbc7e67cab3d1ab01de882a1c6887177f85afb69f9f4a9394c348ecb70de5f7634023a13a7dfcdc59815
LOADBALANCER_SECRET=9544794390fb35b647847d29c75114fe527e300a35bd3e2a976b9ccd87f834ce
DATABASE_URL=postgresql://scalelite:12345
REDIS_URL=
SCALELITE_TAG=
SCALELITE_RECORDING_DIR=
NGINX_SSL=
SCALELITE_NGINX_EXTRA_OPTS=

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Paso 7:

REDIS_URL: URL para conectarse al servidor Redis,

Como generar: la documentación oficial de este link nos re-direcciona a una web de ruby, que no logre entender como realizar este paso con ese contenido, sin embargo la segunda url de ayuda que he colocado que se encuentra en este link si nos da una idea mas clara al respecto de como hacer este paso, esta a traves del contenedor no la logre ejecutar en mi servidor asi que lo realice de la forma manual.

para ello primero debemos ejecutar este comando:

apt-get update

Luego seguimos con la instalación de redis.

apt-get install build-essential tcl

cambiar a la carpeta temporal.

cd /tmp

descargamos la versión mas estable de redis a traves de curl.

curl -O http://download.redis.io/redis-stable.tar.gz

debes desempacar la descarga con tar.

tar xzvf redis-stable.tar.gz

cambiamos a la ruta creada.

cd redis-stable

Ya tenemos todo para instalar, pero primero debemos construir el entorno para redis.

make

este proceso demora unos minutos y luego debemos ejecutar una prueba para validar que todo esta ok.

make test

este proceso demora unos minutos, luego que termine podemos iniciar la instalación.

make install

luego de instalar debemos copiar el archivo "redis.conf" en la ruta "/etc/redis/".

mkdir /etc/redis
cp /tmp/redis-stable/redis.conf /etc/redis

ahora debemos realizar un cambio para que inicie con el arranque del sistema.

nano /etc/redis/redis.conf

En el archivo, encuentre la supervised directiva. Actualmente, esto está configurado en no. Como estamos ejecutando un sistema operativo que utiliza el sistema systemd init, podemos cambiar esto a systemd

debe quedar:

. . .

# If you run Redis from upstart or systemd, Redis can interact with your
# supervision tree. Options:
#   supervised no      - no supervision interaction
#   supervised upstart - signal upstart by putting Redis into SIGSTOP mode
#   supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
#   supervised auto    - detect upstart or systemd method based on
#                        UPSTART_JOB or NOTIFY_SOCKET environment variables
# Note: these supervision methods only signal "process is ready."
#       They do not enable continuous liveness pings back to your supervisor.
supervised systemd

. . .

A continuación, busque el dir directorio. Esta opción especifica el directorio que Redis usará para volcar datos persistentes. Necesitamos elegir una ubicación en la que Redis tenga permiso de escritura y que los usuarios normales no puedan ver.

Usaremos el "/var/lib/redis" directorio para esto, que crearemos en un momento:

. . .

# The working directory.
#
# The DB will be written inside this directory, with the filename specified
# above using the 'dbfilename' configuration directive.
#
# The Append Only File will also be created inside this directory.
#
# Note that you must specify a directory here, not a file name.
dir /var/lib/redis

. . .

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

A continuación, podemos crear un archivo de unidad systemd para que el sistema init pueda administrar el proceso de Redis.

Cree y abra el /etc/systemd/system/redis.service archivo para comenzar:

nano /etc/systemd/system/redis.service

copie y pegue lo siguiente:

[Unit]
Description=Redis In-Memory Data Store
After=network.target

[Service]
User=redis
Group=redis
ExecStart=/usr/local/bin/redis-server /etc/redis/redis.conf
ExecStop=/usr/local/bin/redis-cli shutdown
Restart=always

[Install]
WantedBy=multi-user.target

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Crear el usuario, grupo y directorios de Redis.

Ahora, solo tenemos que crear el usuario, el grupo y el directorio al que hicimos referencia en los dos archivos anteriores.

Comience creando el redis usuario y el grupo. Esto se puede hacer en un solo comando escribiendo:

adduser --system --group --no-create-home redis

Ahora, podemos crear el /var/lib/redis directorio escribiendo:

mkdir /var/lib/redis

Deberíamos otorgar al redis usuario y al grupo la propiedad de este directorio:

chown redis:redis /var/lib/redis

Ajuste los permisos para que los usuarios normales no puedan acceder a esta ubicación:

chmod 770 /var/lib/redis

Iniciar y probar Redis.

Ahora, estamos listos para iniciar el servidor Redis.

Inicie el servicio systemd escribiendo:

systemctl start redis

Verifique que el servicio no haya tenido errores ejecutando:

systemctl status redis

Deberías ver algo que se parece a esto:

Output
● redis.service - Redis Server
   Loaded: loaded (/etc/systemd/system/redis.service; enabled; vendor preset: enabled)
   Active: active (running) since Wed 2016-05-11 14:38:08 EDT; 1min 43s ago
  Process: 3115 ExecStop=/usr/local/bin/redis-cli shutdown (code=exited, status=0/SUCCESS)
 Main PID: 3124 (redis-server)
    Tasks: 3 (limit: 512)
   Memory: 864.0K
      CPU: 179ms
   CGroup: /system.slice/redis.service
           └─3124 /usr/local/bin/redis-server 127.0.0.1:6379       

. . .

Habilitar Redis para comenzar en el arranque.

Si todas sus pruebas funcionaron y desea iniciar Redis automáticamente cuando se inicia el servidor, puede habilitar el servicio systemd.

Para hacerlo, escriba:

systemctl enable redis

si todo se realizo bien debe aparecer una salida como la siguiente:

Output
Created symlink from /etc/systemd/system/multi-user.target.wants/redis.service to /etc/systemd/system/redis.service.

ahora debemos asignar estos valores a nuestra variable de entorno de la siguiente forma.

Agregar a REDIS_URL= lo siguiente "redis://redis".

quedando de la siguiente forma:

URL_HOST=scalelite.example.com
SECRET_KEY_BASE=e6f01e4e89982e9183029ffe708f63f19d3211623334cbc7e67cab3d1ab01de882a1c6887177f85afb69f9f4a9394c348ecb70de5f7634023a13a7dfcdc59815
LOADBALANCER_SECRET=9544794390fb35b647847d29c75114fe527e300a35bd3e2a976b9ccd87f834ce
DATABASE_URL=postgresql://scalelite:12345
REDIS_URL=redis://redis
SCALELITE_TAG=
SCALELITE_RECORDING_DIR=
NGINX_SSL=
SCALELITE_NGINX_EXTRA_OPTS=

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Paso 8:

SCALELITE_TAG: como explica la documentación oficial de este link, este valor hace referencia a la versión que debe instalar en el contenedor.

Agregar a REDIS_URL= lo siguiente "v1".

quedando de la siguiente forma:

URL_HOST=scalelite.example.com
SECRET_KEY_BASE=e6f01e4e89982e9183029ffe708f63f19d3211623334cbc7e67cab3d1ab01de882a1c6887177f85afb69f9f4a9394c348ecb70de5f7634023a13a7dfcdc59815
LOADBALANCER_SECRET=9544794390fb35b647847d29c75114fe527e300a35bd3e2a976b9ccd87f834ce
DATABASE_URL=postgresql://scalelite:12345
REDIS_URL=redis://redis
SCALELITE_TAG=v1
SCALELITE_RECORDING_DIR=
NGINX_SSL=
SCALELITE_NGINX_EXTRA_OPTS=

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Paso 9:

SCALELITE_RECORDING_DIR: esta variable se utiliza para indicar a ScaleLite en cual ruta se alojaran las grabaciones de todos los servidores, para un mejor control.

Como generar: Para este proceso tenemos dos documentos como apoyo la oficial de este link, y la guia de este link.

En cada servidor BigBlueButton , ejecute estos comandos para crear el grupo y agregue el usuario bigbluebutton al grupo:

groupadd -g 2000 scalelite-spool
usermod -a -G scalelite-spool bigbluebutton

En el servidor Scalelite , ahora está listo para configurar la estructura de directorios y los permisos en el volumen compartido. Suponiendo que esté utilizando el punto de montaje, /mnt/scalelite-recordingslos comandos para hacerlo se verán así:

# Create the spool directory for recording transfer from BigBlueButton
mkdir -p /mnt/scalelite-recordings/var/bigbluebutton/spool
chown 1000:2000 /mnt/scalelite-recordings/var/bigbluebutton/spool
chmod 0775 /mnt/scalelite-recordings/var/bigbluebutton/spool

# Create the temporary (working) directory for recording import
mkdir -p /mnt/scalelite-recordings/var/bigbluebutton/recording/scalelite
chown 1000:1000 /mnt/scalelite-recordings/var/bigbluebutton/recording/scalelite
chmod 0775 /mnt/scalelite-recordings/var/bigbluebutton/recording/scalelite

# Create the directory for published recordings
mkdir -p /mnt/scalelite-recordings/var/bigbluebutton/published
chown 1000:1000 /mnt/scalelite-recordings/var/bigbluebutton/published
chmod 0775 /mnt/scalelite-recordings/var/bigbluebutton/published

# Create the directory for unpublished recordings
mkdir -p /mnt/scalelite-recordings/var/bigbluebutton/unpublished
chown 1000:1000 /mnt/scalelite-recordings/var/bigbluebutton/unpublished
chmod 0775 /mnt/scalelite-recordings/var/bigbluebutton/unpublished

muy bien ya tenemos configurada las rutas en el servidor ScaleLite ahora debemos instalar el NFS con el siguiente comando:

apt install nfs-kernel-server nfs-common

Para iniciar el servidor NFS, puede ejecutar el siguiente comando:

systemctl start nfs-kernel-server.service

Nota: Esta parte del proceso es la que no tengo muy clara como continuar, en este proceso es una de las ayuda que solicito a la comunidad para poder completar de forma correcta este manual.

Agregar a SCALELITE_RECORDING_DIR= lo siguiente "/mnt/scalelite-recordings/var/bigbluebutton".

quedando de la siguiente forma:

URL_HOST=scalelite.example.com
SECRET_KEY_BASE=e6f01e4e89982e9183029ffe708f63f19d3211623334cbc7e67cab3d1ab01de882a1c6887177f85afb69f9f4a9394c348ecb70de5f7634023a13a7dfcdc59815
LOADBALANCER_SECRET=9544794390fb35b647847d29c75114fe527e300a35bd3e2a976b9ccd87f834ce
DATABASE_URL=postgresql://scalelite:12345
REDIS_URL=redis://redis
SCALELITE_TAG=v1
SCALELITE_RECORDING_DIR=/mnt/scalelite-recordings/var/bigbluebutton
NGINX_SSL=
SCALELITE_NGINX_EXTRA_OPTS=

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

Paso 10:

NGINX_SSL: Esta variable permite que la imagen NGINX lea SSL.

Como generar: En la documentación oficial no se realiza mayor referencia a este paso, sin embargo en el documento de ayuda de este link, nos indica que se debe instalar NGINX en el servidor de ScaleLite y aplicar un certificado lets'encrypt al dominio que ya configuramos "scalelite.example.com".

muy bien empecemos, primero debemos instalar NGINX, esto se puede hacer con el siguiente comando:

apt update
apt install nginx

Ajustando el Firewalls

Antes de probar Nginx, el software de firewall debe ajustarse para permitir el acceso al servicio. Nginx se registra como un servicio con ufwla instalación, lo que facilita el acceso a Nginx.

Enumere las configuraciones de la aplicación con las que ufwsabe trabajar escribiendo:

ufw app list

Debería obtener una lista de los perfiles de la aplicación:

Available applications:
  Nginx Full
  Nginx HTTP
  Nginx HTTPS
  OpenSSH

Como puede ver, hay tres perfiles disponibles para Nginx:

Nginx Full : este perfil abre tanto el puerto 80 (tráfico web normal sin cifrar) como el puerto 443 (tráfico cifrado TLS / SSL)
Nginx HTTP : este perfil solo abre el puerto 80 (tráfico web normal sin cifrar)
Nginx HTTPS : este perfil solo abre el puerto 443 (tráfico cifrado TLS / SSL)

Podemos verificar con el systemdsistema init para asegurarnos de que el servicio se esté ejecutando escribiendo:

systemctl status nginx

Ahora debemos crear un bloque de servidor para el dominio que hemos configurado scalelite.example.com y poder aplicar el certificado let`s encrypt, primero debemos crear el directorio del dominio con el siguiente comando:

mkdir -p /var/www/scalelite.example.com/html

A continuación, asigne la propiedad del directorio con la $USER variable de entorno:

chown -R $USER:$USER /var/www/scalelite.example.com/html

Los permisos de sus raíces web deben ser correctos si no ha modificado su umask valor, pero puede asegurarse escribiendo:

chmod -R 755 /var/www/scalelite.example.com

Para que Nginx sirva este contenido, es necesario crear un bloque de servidor con las directivas correctas. En lugar de modificar el archivo de configuración predeterminado directamente, hagamos uno nuevo en :/etc/nginx/sites-available/example.com

nano /etc/nginx/sites-available/example.com

Pegue el siguiente bloque de configuración, que es similar al predeterminado, pero actualizado para nuestro nuevo directorio y nombre de dominio:

server {
        listen 80;
        listen [::]:80;

        root /var/www/scalelite.example.com/html;
        index index.html index.htm index.nginx-debian.html;

        server_name scalelite.example.com;

        location / {
                try_files $uri $uri/ =404;
        }
}

A continuación, habilitemos el archivo creando un enlace desde él al sites-enabled directorio, que Nginx lee durante el inicio:

ln -s /etc/nginx/sites-available/scalelite.example.com /etc/nginx/sites-enabled/

Si no hay ningún problema, reinicie Nginx para habilitar sus cambios:

systemctl restart nginx

Nginx ahora debería estar sirviendo su nombre de dominio. Puede probar esto navegando a , donde debería ver algo como esto:http://scalelite.example.com

Muy bien ya tenemos nuestro dominio configurado NGINX ahora debemos encryptar para que nuestro dominio responda a las solicitudes SSL.

primero debemos adicionar el repositorio de Certbot, a traves de este comando:

add-apt-repository ppa:certbot/certbot

Necesitarás presionar Enter para aceptar. Luego, actualiza la lista de paquetes para recolectar la información de los paquetes del nuevo repositorio:

apt update

Y finalmente, instala el paquete Nginx de Certbot con el apt:

apt install python-certbot-nginx

Para permitir adicionalmente, el tráfico HTTPS, debes habilitar el perfil completo de Nginx y borrar los perfiles redundantes:

ufw allow 'Nginx Full'
ufw delete allow 'Nginx HTTP'

En este momento, el estado debería desplegarse de la siguiente forma:

ufw status

generando como salida:

Output
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx Full                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx Full (v6)            ALLOW       Anywhere (v6)

Certbot provee diferentes maneras para obtener certificados SSL. Al usar el conector a Nginx, éste se encargará de reconfigurarlo, así como también, de recargar la configuración en caso de ser necesario. Para usar este conector, digita lo siguiente:

certbot --nginx -d scalelite.example.com

Esto ejecuta certbot con el conector --nginx, usando -d para especificar los nombres sobre los cuales queremos que el certificado sea válido.

Si ésta es la primera vez que se ejecuta certbot, se te solicitará que ingreses una dirección de correo electrónico y que aceptes los términos de servicio. Al hacerlo, certbot se comunicará con el servidor Let’s Encrypt, para intentar verificar que tú controlas el dominio para el cual se está solicitando el certificado.

En caso de éxito, certbot te preguntará cómo configurar los ajustes para HTTPS:

Output
Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access.
-------------------------------------------------------------------------------
1: No redirect - Make no further changes to the webserver configuration.
2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for
new sites, or if you're confident your site works on HTTPS. You can undo this
change by editing your web server's configuration.
-------------------------------------------------------------------------------
Select the appropriate number [1-2] then [enter] (press 'c' to cancel):

El mensaje anterior te permitirá escoger entre redireccionar o no el tráfico de HTTP a HTTPS, limitando el acceso HTTP;

Nota: Si selecciona 2 lo que hará es que al ingresar por http:// lo redireccione al túnel del https:// dejando inhabilitado la conexión al puerto 80.

Después de seleccionar su opción, pulse Enter. La configuración será actualizada, y Nginx se recargará para activar los nuevos ajustes. certbot concluirá con un mensaje informando que el proceso fue exitoso y la localización de tus certificados.

con esto ya tenemos aplicado el certificado ssl al dominio scalelite.example.com ahora podemos completar las variables globales que faltan.

Agregar a NGINX_SSL= lo siguiente "true".

Agregar a SCALELITE_NGINX_EXTRA_OPTS= lo siguiente "--mount type=bind,source=/etc/letsencrypt,target=/etc/nginx/ssl,readonly"

quedando de la siguiente forma:

URL_HOST=scalelite.example.com
SECRET_KEY_BASE=e6f01e4e89982e9183029ffe708f63f19d3211623334cbc7e67cab3d1ab01de882a1c6887177f85afb69f9f4a9394c348ecb70de5f7634023a13a7dfcdc59815
LOADBALANCER_SECRET=9544794390fb35b647847d29c75114fe527e300a35bd3e2a976b9ccd87f834ce
DATABASE_URL=postgresql://scalelite:12345
REDIS_URL=redis://redis
SCALELITE_TAG=v1
SCALELITE_RECORDING_DIR=/mnt/scalelite-recordings/var/bigbluebutton
NGINX_SSL=true
SCALELITE_NGINX_EXTRA_OPTS=--mount type=bind,source=/etc/letsencrypt,target=/etc/nginx/ssl,readonly

en nano debes usar Ctrl+x seguido de una "y" para guardas los cambios.

ya que todas las variables se encuentran listas, procedemos a desintalar NGINX para que ningun proceso en el servidor ScaleLite este haciendo uso de los puertos 80 y 443.

para ello debemos usar los siguientes comandos:

Para remover la configuracion del nginx:

apt-get remove nginx nginx-common

para remover los archivos de nginx:

apt-get purge nginx nginx-common

Muy bien lo logramos ya tenemos las variables globales que necesita ScaleLite para iniciar la instalación.

Paso 11: Implementación de contenedores Scalelite Docker

Instalar usando el repositorio

Actualice el aptíndice del paquete e instale paquetes para permitir el aptuso de un repositorio sobre HTTPS:

apt-get update

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

Agregue la clave GPG oficial de Docker:

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

vamos a descargar la version mas estable de Docker segun nuestra arquitectura, como especifique anteriormente la arquitectura de mi servidor es X86_64 y la version de Docker que nos corresponde es Amd64.

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

INSTALAR DOCKER ENGINE

Actualice el apt índice del paquete e instale la última versión de Docker Engine y del contenedor, o vaya al siguiente paso para instalar una versión específica:

apt-get update
apt-get install docker-ce docker-ce-cli containerd.io

Verifique que Docker Engine esté instalado correctamente ejecutando la hello-world imagen.

docker run hello-world

Esto le mostrara un mensaje del contenedor Hello Word de Docker si todo ha salido bien.

siguiendo con la documentación oficial debo usar los siguientes comando para instalar el contenedor de ScaleLite con Docker

Para la comunicación entre contenedores Scalelite, se debe crear una red privada. Para crear una red con el modo puente predeterminado, ejecute:

docker network create scalelite

A continuación, debe crear un archivo /etc/systemd/system/scalelite.target con el siguiente contenido.

[Unit]
Description=Scalelite
[Install]
WantedBy=multi-user.target

Esta unidad es una ayuda para permitir iniciar y detener todos los contenedores Scalelite juntos.

Y habilite el objetivo ejecutando

systemctl enable scalelite.target

Interfaz web (scalelite-api y scalelite-nginx)

Cree un archivo de unidad systemd /etc/systemd/system/scalelite-api.service con el siguiente contenido:

[Unit]
Description=Scalelite API
After=network-online.target
Wants=network-online.target
Before=scalelite.target
PartOf=scalelite.target
[Service]
EnvironmentFile=/etc/default/scalelite
ExecStartPre=-/usr/bin/docker kill scalelite-api
ExecStartPre=-/usr/bin/docker rm scalelite-api
ExecStartPre=/usr/bin/docker pull blindsidenetwks/scalelite:${SCALELITE_TAG}-api
ExecStart=/usr/bin/docker run --name scalelite-api --env-file /etc/default/scalelite --network scalelite --mount type=bind,source=${SCALELITE_RECORDING_DIR},target=/var/bigbluebutton blindsidenetwks/scalelite:${SCALELITE_TAG}-api
[Install]
WantedBy=scalelite.target

Y habilitarlo ejecutando

systemctl enable scalelite-api.service

Cree un archivo de unidad systemd /etc/systemd/system/scalelite-nginx.service con el siguiente contenido:

[Unit]
Description=Scalelite Nginx
After=network-online.target
Wants=network-online.target
Before=scalelite.target
PartOf=scalelite.target
After=scalelite-api.service
Requires=scalelite-api.service
After=remote-fs.target
[Service]
EnvironmentFile=/etc/default/scalelite
ExecStartPre=-/usr/bin/docker kill scalelite-nginx
ExecStartPre=-/usr/bin/docker rm scalelite-nginx
ExecStartPre=/usr/bin/docker pull blindsidenetwks/scalelite:${SCALELITE_TAG}-nginx
ExecStart=/usr/bin/docker run --name scalelite-nginx --env-file /etc/default/scalelite --network scalelite --publish 80:80 --publish 443:443 --mount type=bind,source=${SCALELITE_RECORDING_DIR}/published,target=/var/bigbluebutton/published,readonly $SCALELITE_NGINX_EXTRA_OPTS blindsidenetwks/scalelite:${SCALELITE_TAG}-nginx
[Install]
WantedBy=scalelite.target

Y habilítelo ejecutando

systemctl enable scalelite-nginx.service

Ahora puede reiniciar todos los servicios de scalelite ejecutando

systemctl restart scalelite.target

Luego, verifique el estado con:

systemctl status scalelite-api.service scalelite-nginx.service

para verificar que los contenedores comenzaron correctamente.

Error Obtenido: A partir de este punto me iniciaron los errores al ejecutar el comando anterior me arroja el siguiente resultado:

 scalelite-api.service - Scalelite API
   Loaded: loaded (/etc/systemd/system/scalelite-api.service; enabled; vendor preset: enabled)
   Active: failed (Result: exit-code) since Sat 2020-07-04 17:22:53 CEST; 1 day 5h ago
  Process: 25308 ExecStart=/usr/bin/docker run --name scalelite-api --env-file /etc/default/scalelite --network scalelite --mount type=bind,source=${SCALELITE_RECORDING_DIR},target=/var/bigbluebutton blindsidenetwks/scalelite:${SCALELITE_TAG}-api (code=exited, status=1/FAILURE)
  Process: 25281 ExecStartPre=/usr/bin/docker pull blindsidenetwks/scalelite:${SCALELITE_TAG}-api (code=exited, status=0/SUCCESS)
  Process: 25268 ExecStartPre=/usr/bin/docker rm scalelite-api (code=exited, status=0/SUCCESS)
  Process: 25238 ExecStartPre=/usr/bin/docker kill scalelite-api (code=exited, status=1/FAILURE)
 Main PID: 25308 (code=exited, status=1/FAILURE)

● scalelite-nginx.service - Scalelite Nginx
   Loaded: loaded (/etc/systemd/system/scalelite-nginx.service; enabled; vendor preset: enabled)
   Active: active (running) since Sat 2020-07-04 17:22:50 CEST; 1 day 5h ago
  Process: 25383 ExecStartPre=/usr/bin/docker pull blindsidenetwks/scalelite:${SCALELITE_TAG}-nginx (code=exited, status=0/SUCCESS)
  Process: 25346 ExecStartPre=/usr/bin/docker rm scalelite-nginx (code=exited, status=0/SUCCESS)
  Process: 25309 ExecStartPre=/usr/bin/docker kill scalelite-nginx (code=exited, status=1/FAILURE)
 Main PID: 25489 (docker)
    Tasks: 13
   Memory: 25.7M
      CPU: 13.762s
   CGroup: /system.slice/scalelite-nginx.service
           └─25489 /usr/bin/docker run --name scalelite-nginx --env-file /etc/default/scalelite --network scalelite --publish 80:80 --publish 443:443 --mount type=bind,source=/mnt/scalelite-recordings/var/bigbluebutton/published,target=/var/bigbluebutton/published,readonly --mount type=bind,source=/etc/letsencrypt,target=/etc/nginx/ssl,readonly blindsidenetwks/scalelite:v1-nginx
~
~

como se puede observar el scalelite-api.service en active esta dando un error failed en esta linea.

Process: 25308 ExecStart=/usr/bin/docker run --name scalelite-api --env-file /etc/default/scalelite --network scalelite --mount type=bind,source=${SCALELITE_RECORDING_DIR},target=/var/bigbluebutton blindsidenetwks/scalelite:${SCALELITE_TAG}-api (code=exited, status=1/FAILURE)

provocando que al ejecutar el comando:

docker exec -it scalelite-api bin/rake db:setup

para inicial el contenedor ScaleLite con docker me aparezca el siguiente error:

Error response from daemon: Container <<id_container>> is not running

y hasta aqui llegue querida comunidad y no logro saber por que no puedo continuar, les agradezco todo el apoyo que me puedan dar con respecto al ScaleLite y de este proceso sus comentarios en saber que hice mal y asi poder compartir una guia lo mas completa posible sobre como hacer funcionar esta opción tan necesaria para bigbluebutton.