Ricerca nel sito web

Come installare e configurare un ambiente JupyterLab su Rocky Linux 9

Su questa pagina

  1. Prerequisiti
  2. Passaggio 1: configurazione del firewall
  3. Passaggio 2 - Installa Nginx
  4. Passaggio 3 - Installa JupyterLab
  5. Passaggio 4 - Configura JupyterLab
  6. Passaggio 5 - Crea il file del servizio JupyterLab
  7. Passaggio 6 - Installa SSL
  8. Passaggio 7 - Configura Nginx
  9. Conclusione

JupyterLab è un ambiente di sviluppo basato sul Web di nuova generazione per Project Jupyter. Il progetto Jupyter è stato sviluppato con l'obiettivo di sviluppare open source, standard aperti e servizi per l'elaborazione interattiva in più linguaggi di programmazione. JupyterLab offre un'interfaccia flessibile che consente agli sviluppatori di lavorare con documenti e attività come notebook Jupyter, editor di testo, terminali e componenti personalizzati in modo flessibile, integrato ed estensibile. JupyterLab è la prossima generazione di Jupyter Notebook e dovrebbe eventualmente sostituirlo. Supporta oltre 40 linguaggi di programmazione, inclusi R, Python, Scala e Julia.

Questo tutorial ti insegnerà come installare e configurare JupyterLab su un server Rocky Linux 9.

Prerequisiti

  • A server running Rocky Linux 9.

  • A non-root user with sudo privileges.

  • A fully qualified domain name (FQDN) pointing to your server. For our purposes, we will use jupyterlab.example.com as the domain name.

  • SELinux is disabled.

  • Make sure everything is updated. 

    $ sudo dnf update

  • Install basic utility packages. Some of them may already be installed. 

    $ sudo dnf install wget curl nano unzip yum-utils -y

Passaggio 1: configurare il firewall

Il primo passo è configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controlla lo stato dei firewall.

$ sudo firewall-cmd --state
running

Il firewall funziona con zone diverse e la zona pubblica è quella predefinita che utilizzeremo. Elenca tutti i servizi e le porte attive sul firewall.

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

Dovrebbe mostrare il seguente output.

cockpit dhcpv6-client ssh

Wiki.js ha bisogno delle porte HTTP e HTTPS per funzionare. Aprili.

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

Ricarica il firewall per applicare le modifiche.

$ sudo firewall-cmd --reload

Passaggio 2: installa Nginx

Rocky Linux 9 viene fornito con una versione precedente di Nginx. Devi scaricare il repository Nginx ufficiale per installare l'ultima versione.

Crea e apri il file /etc/yum.repos.d/nginx.repo per creare il repository Nginx ufficiale.

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

Incolla il seguente codice al suo interno.

[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

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Installa il server Nginx.

$ sudo dnf install nginx -y

Verificare l'installazione.

$ nginx -v
nginx version: nginx/1.22.1

Abilita e avvia il server Nginx.

$ sudo systemctl enable nginx --now

Controlla lo stato del server.

$ 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"

Passaggio 3: installa JupyterLab

Controlliamo prima la versione di Python.

$ python -V
Python 3.9.14

Installa il gestore di pacchetti PIP.

$ sudo dnf install python3-pip

Crea una directory per JupyterLab.

$ mkdir jupyterlab

Passa alla directory appena creata.

$ cd ~/jupyterlab

Imposta un ambiente virtuale chiamato jupyterlab_env.

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

Attiva l'ambiente.

$ source jupyterlab_env/bin/activate

Aggiorna il gestore di pacchetti Pip.

(jupyterlab_env) $ pip install --upgrade pip

Installa JupyterLab.

(jupyterlab_env) $ pip install jupyterlab

Passaggio 4: configurare JupyterLab

Per impostazione predefinita, JupyterLab genera un nuovo token ogni volta che lo avvii per concedere l'accesso all'interfaccia. Sostituiamolo con l'autenticazione della password.

Genera un hash della password. Sostituisci LA TUA_PASSWORD con una password complessa di tua scelta.

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

Il comando precedente genererà un lungo hash della password. Utilizza la funzione di hashing della password di Argon2. Annota l'hash.

Crea un file di configurazione JupyterLab.

(jupyterlab_env) $ jupyter lab --generate-config

Il comando precedente genererà un file di configurazione con i valori predefiniti e lo salverà nella directory ~/.jupyter.

Apri il file per la modifica.

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

Trova le seguenti variabili, decommentale e modifica il loro valore come di seguito. Sostituisci PASSWORD_HASH con l'hash generato sopra.

c.ServerApp.allow_remote_access = True

c.ServerApp.password = 'PASSWORD_HASH'

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Apri la porta 8888 nel firewall.

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

Eseguire il server JupyterLab. Il parametro --ip 0.0.0.0 gli consente di ascoltare qualsiasi indirizzo IP e non solo localhost.

$ jupyter lab --ip 0.0.0.0

Il comando precedente genera un server JupyterLab sulla porta predefinita 8888 che abbiamo aperto. Avvia l'URL http://:8888/ nel tuo browser e vedrai la seguente schermata.

Immettere la password e fare clic sul pulsante Accedi per aprire l'interfaccia di JupyterLab.

Ora che l'accesso è confermato, premi Ctrl + C per fermare il server e inserisci y quando ti viene chiesto di fermarti.

Passaggio 5: creare il file del servizio JupyterLab

Uscire dall'ambiente virtuale.

(jupyterlab_env) $ deactivate

Crea un nuovo file di servizio per JupyterLab.

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

Incolla il seguente codice al suo interno.

[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

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Sostituisci USER con l'utente attualmente connesso al tuo sistema.

Inizializza il servizio JupyterLab.

$ sudo systemctl daemon-reload

Abilita e avvia il servizio JupyterLab.

$ sudo systemctl enable jupyterlab --now

Controlla lo stato del servizio.

$ 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.

Passaggio 6: installa SSL

Prima di procedere, dobbiamo installare lo strumento Certbot e un certificato SSL per il nostro dominio.

Per installare Certbot, utilizzeremo il programma di installazione del pacchetto Snapd. Snapd porta sempre con sé l'ultima versione stabile di Certbot e dovresti usarla.

Lo strumento Snapd richiede il repository Epel per funzionare.

$ sudo dnf install epel-release -y

Useremo Snapd per installare Certbot. Installa Snapd.

$ sudo dnf install snapd -y

Abilita e avvia il servizio Snap.

$ sudo systemctl enable snapd.socket --now

Crea i collegamenti necessari affinché Snapd funzioni.

$ 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

Assicurati che la tua versione di snapd sia aggiornata.

$ sudo snap install core 
$ sudo snap refresh core

Installa Cerbot.

$ sudo snap install --classic certbot

Utilizzare il seguente comando per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.

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

Genera un certificato SSL.

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

Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/jupyterlab.example.com sul tuo server.

Genera un certificato di gruppo Diffie-Hellman.

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

Esegui un'esecuzione a secco del processo per verificare se il rinnovo SSL funziona correttamente.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passaggio 7: configurare Nginx

Crea e apri il file /etc/nginx/conf.d/jupyterlab.conf per la modifica.

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

Incolla il seguente codice nel file jupyterlab.conf. Sostituisci tutte le istanze di jupyterlab.example.com con il tuo 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 configurazione sopra reindirizzerà tutte le richieste HTTP a HTTPS e fungerà da proxy per il servizio JupyterLab per servirlo tramite il tuo dominio.

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e immettendo Y quando richiesto.

Verifica la configurazione di Nginx.

$ sudo nginx -t

Se non vedi errori, significa che sei a posto. Ricarica il server Nginx.

$ sudo systemctl reload nginx

Ora puoi accedere a JupyterLab visitando l'URL https://jupyterlab.example.com nel tuo browser.

Conclusione

Questo conclude il nostro tutorial sull'installazione e la configurazione di JupyterLab su un server Rocky Linux 9 e sul suo servizio utilizzando il server proxy Nginx. Se hai domande, pubblicale nei commenti qui sotto.