JupyterLab · 8 min read · Oct 21, 2025

So installieren und konfigurieren Sie eine JupyterLab-Umgebung auf Rocky Linux 9

JupyterLab ist eine webbasierte Entwicklungsumgebung der nächsten Generation für Project Jupyter. Project Jupyter wurde mit dem Ziel entwickelt, Open-Source-, Open-Standards und Dienstleistungen für interaktive Berechnungen in mehreren Programmiersprachen zu entwickeln. JupyterLab bietet eine flexible Schnittstelle, die es Entwicklern ermöglicht, mit Dokumenten und Aktivitäten wie Jupyter-Notebooks, Texteditoren, Terminals und benutzerdefinierten Komponenten auf flexible, integrierte und erweiterbare Weise zu arbeiten. JupyterLab ist die nächste Generation von Jupyter Notebook und soll es schließlich ersetzen. Es unterstützt über 40 Programmiersprachen, darunter R, Python, Scala und Julia.

Dieses Tutorial zeigt Ihnen, wie Sie JupyterLab auf einem Rocky Linux 9-Server installieren und konfigurieren.

Voraussetzungen

  • Ein Server, der Rocky Linux 9 ausführt.
  • Ein Nicht-Root-Benutzer mit Sudo-Rechten.
  • Ein vollständig qualifizierter Domainname (FQDN), der auf Ihren Server verweist. Für unsere Zwecke verwenden wir jupyterlab.example.com als Domainnamen.
  • SELinux ist deaktiviert.
  • Stellen Sie sicher, dass alles aktualisiert ist. $ sudo dnf update
  • Installieren Sie grundlegende Dienstprogramme. Einige davon sind möglicherweise bereits installiert. $ sudo dnf install wget curl nano unzip yum-utils -y

Schritt 1 - Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld-Firewall. Überprüfen Sie den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, und die öffentliche Zone ist die Standardzone, die wir verwenden werden. Listen Sie alle Dienste und Ports auf, die aktiv sind.

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

Es sollte die folgende Ausgabe anzeigen.

cockpit dhcpv6-client ssh

Wiki.js benötigt HTTP- und HTTPS-Ports, um zu funktionieren. Öffnen Sie diese.

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

Laden Sie die Firewall neu, um die Änderungen anzuwenden.

$ sudo firewall-cmd --reload

Schritt 2 - Nginx installieren

Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Sie müssen das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.

Erstellen und öffnen Sie die Datei /etc/yum.repos.d/nginx.repo, um das offizielle Nginx-Repository zu erstellen.

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

Fügen Sie den folgenden Code ein.

[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

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Installieren Sie den Nginx-Server.

$ sudo dnf install nginx -y

Überprüfen Sie die Installation.

$ nginx -v
nginx version: nginx/1.22.1

Aktivieren und starten Sie den Nginx-Server.

$ sudo systemctl enable nginx --now

Überprüfen Sie den Status des Servers.

$ sudo systemctl status nginx
? nginx.service - nginx - Hochleistungs-Webserver
     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"

Schritt 3 - JupyterLab installieren

Lassen Sie uns zuerst die Python-Version überprüfen.

$ python -V
Python 3.9.14

Installieren Sie den PIP-Paketmanager.

$ sudo dnf install python3-pip

Erstellen Sie ein Verzeichnis für JupyterLab.

$ mkdir jupyterlab

Wechseln Sie in das neu erstellte Verzeichnis.

$ cd ~/jupyterlab

Richten Sie eine virtuelle Umgebung namens jupyterlab_env ein.

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

Aktivieren Sie die Umgebung.

$ source jupyterlab_env/bin/activate

Aktualisieren Sie den Pip-Paketmanager.

(jupyterlab_env) $ pip install --upgrade pip

Installieren Sie JupyterLab.

(jupyterlab_env) $ pip install jupyterlab

Schritt 4 - JupyterLab konfigurieren

Standardmäßig generiert JupyterLab jedes Mal ein neues Token, wenn Sie es starten, um den Zugriff auf die Schnittstelle zu gewähren. Lassen Sie uns dies durch eine Passwortauthentifizierung ersetzen.

Generieren Sie einen Passwort-Hash. Ersetzen Sie YOUR_PASSWORD durch ein starkes Passwort Ihrer Wahl.

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

Der obige Befehl generiert einen langen Passwort-Hash. Er verwendet die Argon2-Passwort-Hashing-Funktion. Notieren Sie sich den Hash.

Erstellen Sie eine JupyterLab-Konfigurationsdatei.

(jupyterlab_env) $ jupyter lab --generate-config

Der obige Befehl generiert eine Konfigurationsdatei mit Standardwerten und speichert sie im Verzeichnis ~/.jupyter.

Öffnen Sie die Datei zur Bearbeitung.

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

Suchen Sie die folgenden Variablen, entfernen Sie das Kommentarzeichen und ändern Sie deren Wert wie unten. Ersetzen Sie PASSWORD_HASH durch den oben generierten Hash.

c.ServerApp.allow_remote_access = True

c.ServerApp.password = 'PASSWORD_HASH'

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Öffnen Sie den Port 8888 in der Firewall.

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

Führen Sie den JupyterLab-Server aus. Der Parameter --ip 0.0.0.0 ermöglicht es ihm, auf jede IP-Adresse zu hören und nicht nur auf localhost.

$ jupyter lab --ip 0.0.0.0

Der obige Befehl startet einen JupyterLab-Server auf dem Standardport 8888, den wir geöffnet haben. Starten Sie die URL http://:8888/ in Ihrem Browser und Sie sehen den folgenden Bildschirm.

JupyterLab-Anmeldescreen

Geben Sie Ihr Passwort ein und klicken Sie auf die Schaltfläche Login, um die JupyterLab-Oberfläche zu öffnen.

JupyterLab-Startseite

Jetzt, da der Zugriff bestätigt ist, drücken Sie Ctrl + C, um den Server zu stoppen, und geben Sie y ein, wenn Sie dazu aufgefordert werden, um zu stoppen.

Schritt 5 - JupyterLab-Dienstdatei erstellen

Verlassen Sie die virtuelle Umgebung.

(jupyterlab_env) $ deactivate

Erstellen Sie eine neue Dienstdatei für JupyterLab.

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

Fügen Sie den folgenden Code ein.

[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

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Ersetzen Sie USER durch den aktuell angemeldeten Benutzer Ihres Systems.

Initialisieren Sie den JupyterLab-Dienst.

$ sudo systemctl daemon-reload

Aktivieren und starten Sie den JupyterLab-Dienst.

$ sudo systemctl enable jupyterlab --now

Überprüfen Sie den Status des Dienstes.

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

Schritt 6 - SSL installieren

Bevor wir fortfahren, müssen wir das Certbot-Tool und ein SSL-Zertifikat für unsere Domain installieren.

Um Certbot zu installieren, verwenden wir den Snapd-Paketinstaller. Snapd hat immer die neueste stabile Version von Certbot und Sie sollten diese verwenden.

Das Snapd-Tool benötigt das Epel-Repository, um zu funktionieren.

$ sudo dnf install epel-release -y

Wir werden Snapd verwenden, um Certbot zu installieren. Installieren Sie Snapd.

$ sudo dnf install snapd -y

Aktivieren und starten Sie den Snap-Dienst.

$ sudo systemctl enable snapd.socket --now

Erstellen Sie die erforderlichen Links, damit Snapd funktioniert.

$ 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

Stellen Sie sicher, dass Ihre Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core 
$ sudo snap refresh core

Installieren Sie Certbot.

$ sudo snap install --classic certbot

Verwenden Sie den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem Sie einen symbolischen Link zum Verzeichnis /usr/bin erstellen.

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

Generieren Sie ein SSL-Zertifikat.

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

Der obige Befehl lädt ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/jupyterlab.example.com auf Ihrem Server herunter.

Generieren Sie ein Diffie-Hellman-Gruppe-Zertifikat.

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

Führen Sie einen Testlauf des Prozesses durch, um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert.

$ sudo certbot renew --dry-run

Wenn Sie keine Fehler sehen, sind Sie bereit. Ihr Zertifikat wird automatisch erneuert.

Schritt 7 - Nginx konfigurieren

Erstellen und öffnen Sie die Datei /etc/nginx/conf.d/jupyterlab.conf zur Bearbeitung.

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

Fügen Sie den folgenden Code in die Datei jupyterlab.conf ein. Ersetzen Sie alle Vorkommen von jupyterlab.example.com durch Ihre Domain.

## HTTPS erzwingen
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; # HTTP/2 Server Push aktivieren

  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;

  # TLS-Versionen aktivieren (TLSv1.3 ist für das kommende HTTP/3 QUIC erforderlich).
  ssl_protocols TLSv1.2 TLSv1.3;

  # TLSv1.3's 0-RTT aktivieren. Verwenden Sie $ssl_early_data, wenn Sie einen Reverse-Proxy verwenden,
  # um Wiederholungsangriffe zu verhindern.
  #
  # @siehe: 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 ---
  # OCSP-Datensätze von der URL im ssl_certificate abrufen und cachen
  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;
  }
}

# Dieser Block ist nützlich zur Fehlersuche von TLS v1.3. Bitte entfernen Sie dies
# und verwenden Sie die von NGINX direkt bereitgestellte `$ssl_early_data`-Variable, wenn Sie
# dies wünschen.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}
map $http_upgrade $connection_upgrade {
  default upgrade;
  '' close;
}

Die obige Konfiguration leitet alle HTTP-Anfragen zu HTTPS um und dient als Proxy für den JupyterLab-Dienst, um ihn über Ihre Domain bereitzustellen.

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Öffnen Sie die Datei /etc/nginx/nginx.conf zur Bearbeitung.

$ sudo nano /etc/nginx/nginx.conf

Fügen Sie die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; hinzu.

server_names_hash_bucket_size  64;

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Überprüfen Sie Ihre Nginx-Konfiguration.

$ sudo nginx -t

Wenn Sie keine Fehler sehen, sind Sie bereit. Laden Sie den Nginx-Server neu.

$ sudo systemctl reload nginx

Sie können jetzt auf JupyterLab zugreifen, indem Sie die URL https://jupyterlab.example.com in Ihrem Browser besuchen.

Fazit

Damit endet unser Tutorial zur Installation und Konfiguration von JupyterLab auf einem Rocky Linux 9-Server und zur Bereitstellung über den Nginx-Proxy-Server. Wenn Sie Fragen haben, stellen Sie diese bitte in den Kommentaren unten.

Share: X/Twitter LinkedIn
#JupyterLab

Erhalte neue Beiträge in deinem Posteingang.

Kein Spam. Jederzeit abmelden.