JupyterLab · 8 min read · Oct 21, 2025

Come installare e configurare un ambiente JupyterLab su Rocky Linux 9

JupyterLab è un ambiente di sviluppo web di nuova generazione per il Progetto Jupyter. Il Progetto Jupyter è stato sviluppato con l’obiettivo di sviluppare software open-source, standard aperti e servizi per il calcolo interattivo attraverso 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 nuova generazione di Jupyter Notebook e dovrebbe eventualmente sostituirlo. Supporta oltre 40 linguaggi di programmazione, tra cui R, Python, Scala e Julia.

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

Prerequisiti

  • Un server che esegue Rocky Linux 9.
  • Un utente non root con privilegi sudo.
  • Un nome di dominio completamente qualificato (FQDN) che punta al tuo server. Per i nostri scopi, utilizzeremo jupyterlab.example.com come nome di dominio.
  • SELinux è disabilitato.
  • Assicurati che tutto sia aggiornato. $ sudo dnf update
  • Installa pacchetti di utilità di base. Alcuni di essi potrebbero essere già installati. $ sudo dnf install wget curl nano unzip yum-utils -y

Passo 1 - Configurare il Firewall

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

$ sudo firewall-cmd --state
running

Il firewall funziona con diverse zone, 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. Aprile.

$ 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

Passo 2 - Installare Nginx

Rocky Linux 9 viene fornito con una versione più vecchia di Nginx. Devi scaricare il repository ufficiale di Nginx per installare l’ultima versione.

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

$ 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 inserendo Y quando richiesto.

Installa il server Nginx.

$ sudo dnf install nginx -y

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

Passo 3 - Installare JupyterLab

Controlliamo prima la versione di Python.

$ python -V
Python 3.9.14

Installa il gestore 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 pacchetti Pip.

(jupyterlab_env) $ pip install --upgrade pip

Installa JupyterLab.

(jupyterlab_env) $ pip install jupyterlab

Passo 4 - Configurare JupyterLab

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

Genera un hash della password. Sostituisci YOUR_PASSWORD con una password forte a tua scelta.

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

Il comando sopra genererà un lungo hash della password. Utilizza la funzione di hashing della password Argon2. Annotati l’hash.

Crea un file di configurazione per JupyterLab.

(jupyterlab_env) $ jupyter lab --generate-config

Il comando sopra genererà un file di configurazione con 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 cambia il loro valore come segue. 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 inserendo Y quando richiesto.

Apri la porta 8888 nel firewall.

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

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

$ jupyter lab --ip 0.0.0.0

Il comando sopra avvia un server JupyterLab sulla porta predefinita 8888 che abbiamo aperto. Lancia l’URL http://:8888/ nel tuo browser e vedrai la seguente schermata.

Schermata di accesso JupyterLab

Inserisci la tua password e fai clic sul pulsante Login per aprire l’interfaccia di JupyterLab.

Home di JupyterLab

Ora che l’accesso è confermato, premi Ctrl + C per fermare il server e inserisci y quando richiesto per fermarlo.

Passo 5 - Creare il file di servizio JupyterLab

Esci 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 inserendo 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.

Passo 6 - Installare SSL

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

Per installare Certbot, utilizzeremo l’installatore di pacchetti Snapd. Snapd porta sempre l’ultima versione stabile di Certbot e dovresti usarla.

Lo strumento Snapd richiede il repository Epel per funzionare.

$ sudo dnf install epel-release -y

Utilizzeremo 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 Certbot.

$ sudo snap install --classic certbot

Usa il seguente comando per assicurarti 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 [email protected] -d jupyterlab.example.com

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

Genera un certificato Diffie-Hellman group.

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

Fai una prova del processo per controllare se il rinnovo SSL funziona correttamente.

$ sudo certbot renew --dry-run

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

Passo 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 inserendo Y quando richiesto.

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

$ sudo nano /etc/nginx/nginx.conf

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

server_names_hash_bucket_size  64;

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

Verifica la tua configurazione 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 su come installare e configurare JupyterLab su un server Rocky Linux 9 e servirlo utilizzando il server proxy Nginx. Se hai domande, pubblicale nei commenti qui sotto.

Share: X/Twitter LinkedIn
#JupyterLab

Ricevi i nuovi post nella tua casella di posta.

Nessuno spam. Disiscriviti in qualsiasi momento.