Cómo instalar y configurar un entorno JupyterLab en Rocky Linux 9

JupyterLab es un entorno de desarrollo basado en la web de nueva generación para el Proyecto Jupyter. El Proyecto Jupyter fue desarrollado con el objetivo de crear software de código abierto, estándares abiertos y servicios para la computación interactiva en múltiples lenguajes de programación. JupyterLab ofrece una interfaz flexible que permite a los desarrolladores trabajar con documentos y actividades como cuadernos Jupyter, editores de texto, terminales y componentes personalizados de manera flexible, integrada y extensible. JupyterLab es la próxima generación de Jupyter Notebook y se supone que eventualmente lo reemplazará. Soporta más de 40 lenguajes de programación, incluyendo R, Python, Scala y Julia.

Este tutorial te enseñará cómo instalar y configurar JupyterLab en un servidor Rocky Linux 9.

Prerrequisitos

• Un servidor que ejecute Rocky Linux 9.
• Un usuario no root con privilegios sudo.
• Un nombre de dominio completamente calificado (FQDN) que apunte a tu servidor. Para nuestros propósitos, usaremos jupyterlab.example.com como el nombre de dominio.
• SELinux está deshabilitado.
• Asegúrate de que todo esté actualizado. $ sudo dnf update
• Instala paquetes de utilidad básicos. Algunos de ellos pueden ya estar instalados. $ sudo dnf install wget curl nano unzip yum-utils -y

Paso 1 - Configurar el Firewall

El primer paso es configurar el firewall. Rocky Linux utiliza Firewalld Firewall. Verifica el estado del firewall.

$ sudo firewall-cmd --state
running

El firewall trabaja con diferentes zonas, y la zona pública es la predeterminada que utilizaremos. Lista todos los servicios y puertos activos en el firewall.

$ sudo firewall-cmd --permanent --list-services

Debería mostrar la siguiente salida.

cockpit dhcpv6-client ssh

Wiki.js necesita puertos HTTP y HTTPS para funcionar. Ábrelos.

$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent

Recarga el firewall para aplicar los cambios.

$ sudo firewall-cmd --reload

Paso 2 - Instalar Nginx

Rocky Linux 9 viene con una versión más antigua de Nginx. Necesitas descargar el repositorio oficial de Nginx para instalar la última versión.

Crea y abre el archivo /etc/yum.repos.d/nginx.repo para crear el repositorio oficial de Nginx.

$ sudo nano /etc/yum.repos.d/nginx.repo

Pega el siguiente código en él.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Instala el servidor Nginx.

$ sudo dnf install nginx -y

Verifica la instalación.

$ nginx -v
nginx version: nginx/1.22.1

Habilita e inicia el servidor Nginx.

$ sudo systemctl enable nginx --now

Verifica el estado del servidor.

$ sudo systemctl status nginx
? nginx.service - nginx - servidor web de alto rendimiento
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
     Active: active (running) since Tue 2022-12-13 06:07:05 UTC; 31s ago
       Docs: http://nginx.org/en/docs/
    Process: 146475 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 146476 (nginx)
      Tasks: 2 (limit: 5911)
     Memory: 1.9M
        CPU: 15ms
     CGroup: /system.slice/nginx.service
             ??146476 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??146477 "nginx: worker process"

Paso 3 - Instalar JupyterLab

Primero verifiquemos la versión de Python.

$ python -V
Python 3.9.14

Instala el gestor de paquetes PIP.

$ sudo dnf install python3-pip

Crea un directorio para JupyterLab.

$ mkdir jupyterlab

Cambia al directorio recién creado.

$ cd ~/jupyterlab

Configura un entorno virtual llamado jupyterlab_env.

$ python3 -m venv --system-site-packages jupyterlab_env

Activa el entorno.

$ source jupyterlab_env/bin/activate

Actualiza el gestor de paquetes Pip.

(jupyterlab_env) $ pip install --upgrade pip

Instala JupyterLab.

(jupyterlab_env) $ pip install jupyterlab

Paso 4 - Configurar JupyterLab

Por defecto, JupyterLab genera un nuevo token cada vez que lo inicias para otorgar acceso a la interfaz. Reemplacémoslo con autenticación por contraseña.

Genera un hash de contraseña. Reemplaza YOUR_PASSWORD con una contraseña fuerte de tu elección.

(jupyterlab_env) $ python3 -c "from jupyter_server.auth import passwd; print(passwd('YOUR_PASSWORD'))"

El comando anterior generará un largo hash de contraseña. Utiliza la función de hash de contraseña Argon2. Toma nota del hash.

Crea un archivo de configuración de JupyterLab.

(jupyterlab_env) $ jupyter lab --generate-config

El comando anterior generará un archivo de configuración con valores predeterminados y lo guardará en el directorio ~/.jupyter.

Abre el archivo para editarlo.

(jupyterlab_env) $ nano ~/.jupyter/jupyter_lab_config.py

Encuentra las siguientes variables, descoméntalas y cambia su valor como se indica a continuación. Reemplaza PASSWORD_HASH con el hash generado anteriormente.

c.ServerApp.allow_remote_access = True

c.ServerApp.password = 'PASSWORD_HASH'

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Abre el puerto 8888 en el firewall.

$ sudo firewall-cmd --add-port=8888/tcp --permanent
$ sudo firewall-cmd --reload

Ejecuta el servidor JupyterLab. El parámetro --ip 0.0.0.0 permite que escuche en cualquier dirección IP y no solo en localhost.

$ jupyter lab --ip 0.0.0.0

El comando anterior inicia un servidor JupyterLab en el puerto predeterminado 8888 que hemos abierto. Lanza la URL http://:8888/ en tu navegador y verás la siguiente pantalla.

Ingresa tu contraseña y haz clic en el botón Iniciar sesión para abrir la interfaz de JupyterLab.

Ahora que se ha confirmado el acceso, presiona Ctrl + C para detener el servidor y entra y cuando se te pida detener.

Paso 5 - Crear archivo de servicio JupyterLab

Sal del entorno virtual.

(jupyterlab_env) $ deactivate

Crea un nuevo archivo de servicio para JupyterLab.

$ sudo nano /lib/systemd/system/jupyterlab.service

Pega el siguiente código en él.

[Unit]
Description=Servidor JupyterLab

[Service]
User=USER
Group=USER
Type=simple
WorkingDirectory=/home/USER/jupyterlab
ExecStart=/home/USER/jupyterlab/jupyterlab_env/bin/jupyter-lab --config=/home/USER/.jupyter/jupyter_lab_config.py
StandardOutput=null
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Reemplaza USER con el usuario actualmente conectado en tu sistema.

Inicializa el servicio JupyterLab.

$ sudo systemctl daemon-reload

Habilita e inicia el servicio JupyterLab.

$ sudo systemctl enable jupyterlab --now

Verifica el estado del servicio.

$ sudo systemctl status jupyterlab
? jupyterlab.service - Servidor JupyterLab
     Loaded: loaded (/usr/lib/systemd/system/jupyterlab.service; disabled; vendor preset: disabled)
     Active: active (running) since Tue 2022-12-13 11:45:26 UTC; 5s ago
   Main PID: 151675 (jupyter-lab)
      Tasks: 1 (limit: 5911)
     Memory: 59.0M
        CPU: 1.943s
     CGroup: /system.slice/jupyterlab.service
             ??151675 /home/navjot/jupyterlab/jupyterlab_env/bin/python3 /home/navjot/jupyterlab/jupyterlab_env/bin/jupyter-lab --config=/home/navjot/.jupyter/jupyter_lab_config.py

Dec 13 11:45:26 jupyter.example.com systemd[1]: Started JupyterLab Server.

Paso 6 - Instalar SSL

Antes de continuar, necesitamos instalar la herramienta Certbot y un certificado SSL para nuestro dominio.

Para instalar Certbot, utilizaremos el instalador de paquetes Snapd. Snapd siempre lleva la última versión estable de Certbot y deberías usar esa.

La herramienta Snapd requiere el repositorio Epel para funcionar.

$ sudo dnf install epel-release -y

Usaremos Snapd para instalar Certbot. Instala Snapd.

$ sudo dnf install snapd -y

Habilita e inicia el servicio Snap.

$ sudo systemctl enable snapd.socket --now

Crea los enlaces necesarios para que Snapd funcione.

$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh

Asegúrate de que tu versión de snapd esté actualizada.

$ sudo snap install core 
$ sudo snap refresh core

Instala Certbot.

$ sudo snap install --classic certbot

Usa el siguiente comando para asegurarte de que el comando Certbot se pueda ejecutar creando un enlace simbólico al directorio /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Genera un certificado SSL.

$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d jupyterlab.example.com

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/jupyterlab.example.com en tu servidor.

Genera un certificado de grupo Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Haz una prueba del proceso para verificar si la renovación de SSL está funcionando correctamente.

$ sudo certbot renew --dry-run

Si no ves errores, estás listo. Tu certificado se renovará automáticamente.

Paso 7 - Configurar Nginx

Crea y abre el archivo /etc/nginx/conf.d/jupyterlab.conf para editarlo.

$ sudo nano /etc/nginx/conf.d/jupyterlab.conf

Pega el siguiente código en el archivo jupyterlab.conf. Reemplaza todas las instancias de jupyterlab.example.com con tu dominio.

## forzar HTTPS
server {
  listen 80;
  listen [::]:80;
  server_name jupyterlab.example.com;
  return 301 https://$server_name$request_uri;
}

server {
  listen 443 ssl http2;
  listen [::]:443 ssl http2;
  server_name jupyterlab.example.com;

  access_log /var/log/nginx/jupyterlab.access.log;
  error_log /var/log/nginx/jupyterlab.error.log;
  client_max_body_size 20m;

  http2_push_preload on; # Habilitar HTTP/2 Server Push

  ssl_certificate     /etc/letsencrypt/live/jupyterlab.example.com/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/jupyterlab.example.com/privkey.pem;
  ssl_trusted_certificate /etc/letsencrypt/live/jupyterlab.example.com/chain.pem;
  ssl_session_timeout 1d;

  # Habilitar versiones TLS (TLSv1.3 es requerido para el próximo HTTP/3 QUIC).
  ssl_protocols TLSv1.2 TLSv1.3;

  # Habilitar 0-RTT de TLSv1.3. Usa $ssl_early_data al hacer proxy inverso para
  # prevenir ataques de repetición.
  #
  # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
  ssl_early_data on;

  ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
  ssl_prefer_server_ciphers on;
  ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
  ssl_session_cache shared:SSL:50m;
  ssl_session_tickets off;

  # OCSP Stapling ---
  # obtener registros OCSP de la URL en ssl_certificate y almacenarlos en caché
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_dhparam /etc/ssl/certs/dhparam.pem;

  add_header X-Early-Data $tls1_3_early_data;

  location / {
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Host $host;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection $connection_upgrade;
    proxy_set_header X-Scheme $scheme;
    proxy_buffering off;
    proxy_set_header X-Forwarded-Proto https;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass http://127.0.0.1:8888;
  }
}

# Este bloque es útil para depurar TLS v1.3. Siéntete libre de eliminar esto
# y usar la variable `$ssl_early_data` expuesta por NGINX directamente si así lo
# deseas.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}
map $http_upgrade $connection_upgrade {
  default upgrade;
  '' close;
}

La configuración anterior redirigirá todas las solicitudes HTTP a HTTPS y servirá como un proxy para el servicio JupyterLab para servirlo a través de tu dominio.

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Abre el archivo /etc/nginx/nginx.conf para editarlo.

$ sudo nano /etc/nginx/nginx.conf

Agrega la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.

Verifica tu configuración de Nginx.

$ sudo nginx -t

Si no ves errores, significa que estás listo para continuar. Recarga el servidor Nginx.

$ sudo systemctl reload nginx

Ahora puedes acceder a JupyterLab visitando la URL https://jupyterlab.example.com en tu navegador.

Conclusión

Esto concluye nuestro tutorial sobre la instalación y configuración de JupyterLab en un servidor Rocky Linux 9 y su servicio utilizando el servidor proxy Nginx. Si tienes alguna pregunta, publícalas en los comentarios a continuación.