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

octubre 8, 2023

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.

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

Requisitos previos

Paso 1 – Configurar el cortafuegos

Paso 2 – Instalar Nginx

Paso 3 – Instalar JupyterLab

Paso 4 – Configurar JupyterLab

Paso 5 – Crear el archivo de servicio de JupyterLab

Paso 6 – Instalar SSL

Paso 7 – Configurar Nginx

Conclusión

También te podría gustar...

Entradas recientes

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

Requisitos previos

Paso 1 – Configurar el cortafuegos

Paso 2 – Instalar Nginx

Paso 3 – Instalar JupyterLab

Paso 4 – Configurar JupyterLab

Paso 5 – Crear el archivo de servicio de JupyterLab

Paso 6 – Instalar SSL

Paso 7 – Configurar Nginx

Conclusión

También te podría gustar...

Cómo instalar y utilizar Portainer para la gestión de Docker con Nginx Proxy Manager

Cómo instalar la Biblioteca de Visión por Computador de Código Abierto (OpenCV) en Ubuntu 22.04

Cómo monitorizar archivos de registro con Graylog v3.1 en Debian

Entradas recientes