HowtoForge

Tutoriales de Linux

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

JupyterLab es un entorno de desarrollo de nueva generación basado en la web para el Proyecto Jupyter. El Proyecto Jupyter se desarrolló con el objetivo de desarrollar estándares y servicios de código abierto para la informática 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 forma flexible, integrada y extensible. JupyterLab es la próxima generación de Jupyter Notebook y se supone que acabará sustituyéndolo. Es compatible con más de 40 lenguajes de programación, incluidos R, Python, Scala y Julia.

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

Requisitos previos

  • Un servidor con Rocky Linux 9.
  • Un usuario no root con privilegios sudo.
  • Un nombre de dominio completo (FQDN) que apunte a tu servidor. Para nuestros propósitos, utilizaremos jupyterlab.example.com como nombre de dominio.
  • SELinux está desactivado.
  • Asegúrate de que todo está actualizado.
    $ sudo dnf update
  • Instala los paquetes de utilidades básicas. Puede que algunos ya estén instalados.
    $ sudo dnf install wget curl nano unzip yum-utils -y

Paso 1 – Configurar el cortafuegos

El primer paso es configurar el cortafuegos. Rocky Linux utiliza el cortafuegos Firewalld. Comprueba el estado del cortafuegos.

$ sudo firewall-cmd --state
running

El cortafuegos funciona con diferentes zonas, y la zona pública es la que utilizaremos por defecto. Enumera todos los servicios y puertos activos en el cortafuegos.

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

Debería mostrar la siguiente salida.

cockpit dhcpv6-client ssh

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

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

Recarga el cortafuegos para aplicar los cambios.

$ sudo firewall-cmd --reload

Paso 2 – Instalar Nginx

Rocky Linux 9 viene con una versión 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 en él el siguiente código.

[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 pulsando Ctrl + X e introduciendo 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

Comprueba el estado del servidor.

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     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

Comprueba primero 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 dar acceso a la interfaz. Vamos a sustituirlo por la autenticación mediante contraseña.

Genera un hash de contraseña. Sustituye YOUR_PASSWORD por una contraseña segura de tu elección.

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

El comando anterior generará un hash de contraseña largo. Utiliza la función de hash de contraseñas Argon2. Anota el 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 por defecto y lo guardará en el directorio ~/.jupyter.

Abre el archivo para editarlo.

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

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

c.ServerApp.allow_remote_access = True

c.ServerApp.password = 'PASSWORD_HASH'

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Abre el puerto 8888 en el cortafuegos.

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

Ejecuta el servidor de JupyterLab. El parámetro --ip 0.0.0.0 le permite escuchar cualquier dirección IP y no sólo localhost.

$ jupyter lab --ip 0.0.0.0

El comando anterior genera un servidor JupyterLab en el puerto 8888 que hemos abierto por defecto. Inicia la URL http://<yourserverIP>:8888/ en tu navegador y verás la siguiente pantalla.

Pantalla de inicio de sesión de JupyterLab

Introduce tu contraseña y pulsa el botón Acceder para abrir la interfaz de JupyterLab.

Inicio de JupyterLab

Ahora que el acceso está confirmado, pulsa Ctrl + C para detener el servidor e introduce y cuando se te pida que lo detengas.

Paso 5 – Crear el archivo de servicio de JupyterLab

Sal del entorno virtual.

(jupyterlab_env) $ deactivate

Crea un nuevo archivo de servicio para JupyterLab.

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

Pega en él el siguiente código.

[Unit]
Description=JupyterLab Server

[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 pulsando Ctrl + X e introduciendo Y cuando se te pida.

Sustituye USER por el usuario conectado actual de tu sistema.

Inicializa el servicio JupyterLab.

$ sudo systemctl daemon-reload

Habilita e inicia el servicio JupyterLab.

$ sudo systemctl enable jupyterlab --now

Comprueba el estado del servicio.

$ sudo systemctl status jupyterlab
? jupyterlab.service - JupyterLab Server
     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 utilizarla.

La herramienta Snapd necesita el repositorio Epel para funcionar.

$ sudo dnf install epel-release -y

Utilizaremos 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

Asegúrate de que se puede ejecutar el comando Certbot 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 de tu servidor.

Genera un certificado de grupo Diffie-Hellman.

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

Realiza un simulacro del proceso para comprobar si la renovación SSL funciona correctamente.

$ sudo certbot renew --dry-run

Si no ves ningún error, ya está todo 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. Sustituye todas las instancias de jupyterlab.example.com por tu dominio.

## enforce 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; # Enable 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;

  # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
  ssl_protocols TLSv1.2 TLSv1.3;

  # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
  # prevent replay attacks.
  #
  # @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 ---
  # fetch OCSP records from URL in ssl_certificate and cache them
  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;
  }
}

# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
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 peticiones HTTP a HTTPS y servirá como proxy para el servicio JupyterLab para servirlo a través de tu dominio.

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

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

$ sudo nano /etc/nginx/nginx.conf

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

server_names_hash_bucket_size  64;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Comprueba la configuración de Nginx.

$ sudo nginx -t

Si no ves ningún error, significa que puedes 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

Con esto concluye nuestro tutorial sobre la instalación y configuración de JupyterLab en un servidor Rocky Linux 9 y cómo servirlo utilizando el servidor proxy Nginx. Si tienes alguna pregunta, publícala en los comentarios a continuación.

También te podría gustar...