Installation JupyterLab · 8 min read · Oct 21, 2025

Comment installer et configurer un environnement JupyterLab sur Rocky Linux 9

JupyterLab est un environnement de développement basé sur le web de nouvelle génération pour le projet Jupyter. Le projet Jupyter a été développé dans le but de créer des logiciels open-source, des normes ouvertes et des services pour le calcul interactif à travers plusieurs langages de programmation. JupyterLab offre une interface flexible qui permet aux développeurs de travailler avec des documents et des activités telles que des notebooks Jupyter, des éditeurs de texte, des terminaux et des composants personnalisés de manière flexible, intégrée et extensible. JupyterLab est la prochaine génération de Jupyter Notebook et est censé le remplacer à terme. Il prend en charge plus de 40 langages de programmation, y compris R, Python, Scala et Julia.

Ce tutoriel vous apprendra comment installer et configurer JupyterLab sur un serveur Rocky Linux 9.

Prérequis

  • Un serveur exécutant Rocky Linux 9.
  • Un utilisateur non-root avec des privilèges sudo.
  • Un nom de domaine entièrement qualifié (FQDN) pointant vers votre serveur. Pour nos besoins, nous utiliserons jupyterlab.example.com comme nom de domaine.
  • SELinux est désactivé.
  • Assurez-vous que tout est à jour. $ sudo dnf update
  • Installez des paquets utilitaires de base. Certains d’entre eux peuvent déjà être installés. $ sudo dnf install wget curl nano unzip yum-utils -y

Étape 1 - Configurer le pare-feu

La première étape consiste à configurer le pare-feu. Rocky Linux utilise le pare-feu Firewalld. Vérifiez l’état du pare-feu.

$ sudo firewall-cmd --state
running

Le pare-feu fonctionne avec différentes zones, et la zone publique est celle par défaut que nous allons utiliser. Listez tous les services et ports actifs sur le pare-feu.

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

Il devrait afficher la sortie suivante.

cockpit dhcpv6-client ssh

Wiki.js a besoin des ports HTTP et HTTPS pour fonctionner. Ouvrez-les.

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

Rechargez le pare-feu pour appliquer les modifications.

$ sudo firewall-cmd --reload

Étape 2 - Installer Nginx

Rocky Linux 9 est livré avec une version plus ancienne de Nginx. Vous devez télécharger le dépôt officiel de Nginx pour installer la dernière version.

Créez et ouvrez le fichier /etc/yum.repos.d/nginx.repo pour créer le dépôt officiel de Nginx.

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

Collez le code suivant dedans.

[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

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Installez le serveur Nginx.

$ sudo dnf install nginx -y

Vérifiez l’installation.

$ nginx -v
nginx version: nginx/1.22.1

Activez et démarrez le serveur Nginx.

$ sudo systemctl enable nginx --now

Vérifiez l’état du serveur.

$ sudo systemctl status nginx
? nginx.service - nginx - serveur web haute performance
     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"

Étape 3 - Installer JupyterLab

Vérifions d’abord la version de Python.

$ python -V
Python 3.9.14

Installez le gestionnaire de paquets PIP.

$ sudo dnf install python3-pip

Créez un répertoire pour JupyterLab.

$ mkdir jupyterlab

Passez au répertoire nouvellement créé.

$ cd ~/jupyterlab

Configurez un environnement virtuel appelé jupyterlab_env.

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

Activez l’environnement.

$ source jupyterlab_env/bin/activate

Mettez à jour le gestionnaire de paquets Pip.

(jupyterlab_env) $ pip install --upgrade pip

Installez JupyterLab.

(jupyterlab_env) $ pip install jupyterlab

Étape 4 - Configurer JupyterLab

Par défaut, JupyterLab génère un nouveau jeton chaque fois que vous le démarrez pour accorder l’accès à l’interface. Remplaçons-le par une authentification par mot de passe.

Générez un hachage de mot de passe. Remplacez YOUR_PASSWORD par un mot de passe fort de votre choix.

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

La commande ci-dessus générera un long hachage de mot de passe. Il utilise la fonction de hachage de mot de passe Argon2. Notez le hachage.

Créez un fichier de configuration JupyterLab.

(jupyterlab_env) $ jupyter lab --generate-config

La commande ci-dessus générera un fichier de configuration avec des valeurs par défaut et l’enregistrera dans le répertoire ~/.jupyter.

Ouvrez le fichier pour l’éditer.

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

Trouvez les variables suivantes, décommentez-les et changez leur valeur comme ci-dessous. Remplacez PASSWORD_HASH par le hachage généré ci-dessus.

c.ServerApp.allow_remote_access = True

c.ServerApp.password = 'PASSWORD_HASH'

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Ouvrez le port 8888 dans le pare-feu.

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

Exécutez le serveur JupyterLab. Le paramètre --ip 0.0.0.0 lui permet d’écouter n’importe quelle adresse IP et pas seulement localhost.

$ jupyter lab --ip 0.0.0.0

La commande ci-dessus lance un serveur JupyterLab sur le port par défaut 8888 que nous avons ouvert. Lancez l’URL http://:8888/ dans votre navigateur et vous verrez l’écran suivant.

Écran de connexion JupyterLab

Entrez votre mot de passe et cliquez sur le bouton Connexion pour ouvrir l’interface JupyterLab.

Accueil JupyterLab

Maintenant que l’accès est confirmé, appuyez sur Ctrl + C pour arrêter le serveur et entrez y lorsque vous y êtes invité pour arrêter.

Étape 5 - Créer un fichier de service JupyterLab

Quittez l’environnement virtuel.

(jupyterlab_env) $ deactivate

Créez un nouveau fichier de service pour JupyterLab.

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

Collez le code suivant dedans.

[Unit]
Description=Serveur 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

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Remplacez USER par l’utilisateur actuellement connecté de votre système.

Initialisez le service JupyterLab.

$ sudo systemctl daemon-reload

Activez et démarrez le service JupyterLab.

$ sudo systemctl enable jupyterlab --now

Vérifiez l’état du service.

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

Étape 6 - Installer SSL

Avant de continuer, nous devons installer l’outil Certbot et un certificat SSL pour notre domaine.

Pour installer Certbot, nous utiliserons le gestionnaire de paquets Snapd. Snapd porte toujours la dernière version stable de Certbot et vous devriez l’utiliser.

L’outil Snapd nécessite le dépôt Epel pour fonctionner.

$ sudo dnf install epel-release -y

Nous utiliserons Snapd pour installer Certbot. Installez Snapd.

$ sudo dnf install snapd -y

Activez et démarrez le service Snap.

$ sudo systemctl enable snapd.socket --now

Créez les liens nécessaires pour que Snapd fonctionne.

$ 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

Assurez-vous que votre version de snapd est à jour.

$ sudo snap install core 
$ sudo snap refresh core

Installez Certbot.

$ sudo snap install --classic certbot

Utilisez la commande suivante pour vous assurer que la commande Certbot peut être exécutée en créant un lien symbolique vers le répertoire /usr/bin.

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

Générez un certificat SSL.

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

La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/jupyterlab.example.com sur votre serveur.

Générez un certificat de groupe Diffie-Hellman.

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

Faites un essai à blanc du processus pour vérifier si le renouvellement SSL fonctionne correctement.

$ sudo certbot renew --dry-run

Si vous ne voyez pas d’erreurs, vous êtes prêt. Votre certificat se renouvellera automatiquement.

Étape 7 - Configurer Nginx

Créez et ouvrez le fichier /etc/nginx/conf.d/jupyterlab.conf pour l’éditer.

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

Collez le code suivant dans le fichier jupyterlab.conf. Remplacez toutes les occurrences de jupyterlab.example.com par votre domaine.

## imposer 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; # Activer le serveur HTTP/2 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;

  # Activer les versions TLS (TLSv1.3 est requis pour le prochain HTTP/3 QUIC).
  ssl_protocols TLSv1.2 TLSv1.3;

  # Activer le 0-RTT de TLSv1.3. Utilisez $ssl_early_data lors du proxy inverse pour
  # prévenir les attaques de rejeu.
  #
  # @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 ---
  # récupérer les enregistrements OCSP à partir de l'URL dans ssl_certificate et les mettre en cache
  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;
  }
}

# Ce bloc est utile pour déboguer TLS v1.3. N'hésitez pas à le supprimer
# et à utiliser la variable `$ssl_early_data` exposée par NGINX directement si vous
# souhaitez le faire.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}
map $http_upgrade $connection_upgrade {
  default upgrade;
  '' close;
}

La configuration ci-dessus redirigera toutes les requêtes HTTP vers HTTPS et servira de proxy pour le service JupyterLab afin de le servir via votre domaine.

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Ouvrez le fichier /etc/nginx/nginx.conf pour l’éditer.

$ sudo nano /etc/nginx/nginx.conf

Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Vérifiez votre configuration Nginx.

$ sudo nginx -t

Si vous ne voyez pas d’erreurs, cela signifie que vous êtes prêt à partir. Rechargez le serveur Nginx.

$ sudo systemctl reload nginx

Vous pouvez maintenant accéder à JupyterLab en visitant l’URL https://jupyterlab.example.com dans votre navigateur.

Conclusion

Cela conclut notre tutoriel sur l’installation et la configuration de JupyterLab sur un serveur Rocky Linux 9 et son service via le serveur proxy Nginx. Si vous avez des questions, postez-les dans les commentaires ci-dessous.

Share: X/Twitter LinkedIn
#Installation JupyterLab

Recevez de nouveaux articles dans votre boîte de réception.

Aucun spam. Désabonnez-vous à tout moment.