So installierst du JupyterLab unter Ubuntu 24.04
JupyterLab ist eine Open-Source-Web-basierte interaktive Entwicklungsumgebung, die das klassische Jupyter Notebook erweitert und eine flexiblere und leistungsfähigere Schnittstelle für Data Science und wissenschaftliche Berechnungen bietet. Es unterstützt verschiedene Programmiersprachen, wobei der Schwerpunkt auf Python liegt, und bietet Funktionen wie Codebearbeitung, Datenvisualisierung und interaktive Ausgabe in einem einzigen, integrierten Arbeitsbereich. Mit JupyterLab können Nutzer/innen Notizbücher, Texteditoren, Terminals und andere benutzerdefinierte Komponenten in einem Registerkarten-Layout erstellen und verwalten, um die Produktivität und Zusammenarbeit zu verbessern. Unter Ubuntu kann JupyterLab ganz einfach über Paketmanager wie apt oder das Python-Paketinstallationsprogramm pip installiert werden, was es zu einem leicht zugänglichen Werkzeug für Entwickler und Forscher macht, die diese beliebte Linux-Distribution nutzen.
In dieser Anleitung erfährst du, wie du Jupyter unter Ubuntu 24.04 installierst. Du installierst und sicherst Jupyter mit einer Passwortauthentifizierung. Dann installierst du Nginx und konfigurierst es als Reverse Proxy.
Voraussetzungen
Bevor du beginnst, solltest du sicherstellen, dass du die folgenden Voraussetzungen erfüllst:
- Ein Ubuntu 24.04.
- Einen Nicht-Root-Benutzer mit Administrator-Rechten.
- Ein Domainname, der auf eine Server-IP-Adresse zeigt (öffentliche oder private Domain).
Installation der Abhängigkeiten
In diesem Abschnitt installierst du die Abhängigkeiten für Jupyter, darunter Python, Pip, venv und Node.js. Diese Pakete sind standardmäßig im Ubuntu-Repository verfügbar und du installierst sie über den APT-Paketmanager.
Um zu beginnen, führe den folgenden Befehl aus, um deinen Ubuntu-Paketindex zu aktualisieren.
sudo apt update
Installiere nun Python3 und Node.js über das Ubuntu-Repository mit folgendem Befehl – gib Y ein, um die Installation zu bestätigen:
sudo apt install python3-dev python3-pip python3-venv nodejs npm
Nachdem die Installation abgeschlossen ist, überprüfe die Version von Python, Node.js und Pip mit folgendem Befehl:
python3 -v
pip3 -v
node -v
Wie du unten siehst, sind Python 3.12, Node.js 18 und Pip 24 installiert.
Installation von Jupyter
Nachdem du die Abhängigkeiten installiert hast, installierst du Jupyter über Pip in der virtuellen Python-Umgebung. Du wirst Jupyter als Nicht-Root-Benutzer ausführen, also stelle sicher, dass du ihn angelegt hast.
Melde dich mit dem folgenden Befehl bei deinem Benutzer an – im folgenden Beispiel wird der Benutzer alice verwendet:
su – alice
Führe den folgenden Befehl aus, um ein neues Verzeichnis ~/Dev zu erstellen und in dieses Verzeichnis zu wechseln. Erstelle dann eine neue virtuelle Python-Umgebung venv.
mkdir -p ~/Dev; cd ~/Dev
python3 -v venv venv
Aktiviere nun die virtuelle Umgebung venv mit dem folgenden Befehl. Nach der Aktivierung wird deine Shell wie (venv) user@hostname aussehen.
source venv/bin/activate
Als Nächstes führst du den folgenden pip3 Befehl aus, um Jupyter über das PyPi-Repository zu installieren:
pip3 install jupyter
Unten siehst du die Installation von jupyter mit dem Befehl pip3:
Nachdem der Prozess abgeschlossen ist, überprüfe die Jupyter-Version mit dem folgenden Befehl:
jupyter –version
Du siehst die Version der einzelnen Jupyter-Komponenten, wie z.B. jupyterlab, jupyter_server, jupyter_client, jupyter_core, und iPython.
Jupyter konfigurieren
In diesem Abschnitt konfigurierst du die beiden Hauptkomponenten von Jupyter, nämlich jupyter_server und jupyterlab. Du erstellst die Konfiguration und richtest die Passwortauthentifizierung für beide Komponenten ein. Anschließend startest du Jupyter über die Kommandozeile.
Führe zunächst den Befehl jupyter aus, um die Konfiguration und das Passwort für jupyter_server zu erstellen. Gib dein Passwort ein, wenn du dazu aufgefordert wirst und wiederhole den Vorgang.
jupyter server –generate-config
jupyter server password
Wie du unten siehst, wird die jupyter_server Konfiguration auf ~/.jupyter/jupyter_server_config.py generiert und die Passwortdatei wird auf ~/.jupyter/jupyter_server_config.json geschrieben.
Überprüfe die jupyter_server Konfiguration mit dem folgenden Befehl.
jupyter server –show-config
Du wirst eine ähnliche Ausgabe wie die folgende sehen:
Als Nächstes führst du den Befehl jupyter aus, um die Konfiguration von jupyterlab auf ~/.jupyter/jupyter_lab_config.py zu generieren. Überprüfe dann die Konfiguration von jupyterlab.
jupyter lab –generate-config
jupyter lab –show-config
In der folgenden Ausgabe ist der Standard-URL-Pfad für jupyterlab /lab .
Führe nun den folgenden Befehl jupyter aus, um jupyterlab von der Kommandozeile aus zu starten. Die jupyterlab sollte auf Port 8888 und dem URL-Pfad lab laufen.
jupyter lab –ip 0.0.0.0
Besuche http://server-ip:8888/lab, um auf deine jupyterlab Installation zuzugreifen. Du wirst das folgende Jupyter-Dashboard sehen.
Drücke nun Strg+c und gib yes ein, um den jupyterlab Prozess zu beenden.
JupyterLab als Dienst ausführen
In dieser Anleitung wirst du Jupyter als Dienst im Hintergrund laufen lassen. Deshalb musst du jetzt eine neue systemd-Dienstdatei für Jupyter erstellen.
Erstelle eine neue systemd-Dienstdatei /etc/systemd/system/jupyterlab.service mit dem folgenden nano-Editor-Befehl.
sudo nano /etc/systemd/system/jupyterlab.service
Gib die folgende Konfiguration ein und stelle sicher, dass du den Benutzer alice durch deinen Benutzernamen ersetzt.
[Unit]
Description=JupyterLab Service
[Service]
Type=simple
PIDFile=/run/jupyter.pid
ExecStart=/home/alice/Dev/venv/bin/jupyter lab --config=/home/alice/.jupyter/jupyter_lab_config.py
User=alice
Group=alice
WorkingDirectory=/home/alice/Dev
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.target
Speichere die Datei und beende den Editor, wenn du fertig bist.
Führe nun den folgenden Befehl aus, um den systemd Manager neu zu laden und deine neue Dienstdatei zu aktivieren.
sudo systemctl daemon-reload
Als Nächstes startest und aktivierst du den Dienst jupyterlab mit dem folgenden Befehl.
sudo systemctl start jupyterlab
sudo systemctl enable jupyterlab
Führe abschließend den folgenden Befehl aus, um den Status des Dienstes jupyterlab zu überprüfen. Du wirst sehen, dass der jupyterlab Dienst läuft und auf deinem System aktiviert ist.
sudo systemctl status jupyterlab
Fernzugriff auf Jupyter zulassen
Bevor du Nginx als Reverse Proxy einrichtest, musst du den Fernzugriff auf jupyterlab erlauben. Jetzt wirst du die Datei ~/.jupyter/jupyter_lab_config.py ändern und den Fernzugriff aktivieren.
Öffne zunächst die Konfigurationsdatei jupyterlab ~/.jupyter/jupyter_lab_config.py mit dem folgenden nano-Editor.
nano ~/.jupyter/jupyter_lab_config.py
Entferne den Kommentar in der Option c.ServerApp.allow_remote_access und ändere ihn in True. Dadurch wird der Fernzugriff für jupyterlab aktiviert.
c.ServerApp.allow_remote_access = True
Speichere und beende die Datei, wenn du fertig bist.
Führe nun den folgenden Befehl aus, um den Dienst jupyterlab neu zu starten und deine Änderungen zu übernehmen. Nachdem der Fernzugriff in Jupyter aktiviert wurde, wird ein neues Token zum Einrichten eines Passworts generiert.
sudo systemctl restart jupyterlab
Wirf einen Blick auf den unteren Teil der Meldung und kopiere das generierte Token für Jupyter.
Nginx als Reverse Proxy einrichten
In diesem Abschnitt wirst du Nginx als Reverse-Proxy für deine Jupyter-Installation installieren und konfigurieren. Vergewissere dich, dass du deinen Domainnamen hast, egal ob öffentlich oder privat.
Installiere den Nginx-Webserver mit dem folgenden Befehl – gib Y ein, um mit der Installation fortzufahren.
sudo apt install nginx
Nachdem die Installation abgeschlossen ist, erstelle mit dem folgenden nano-Editor eine neue Nginx-Serverblockkonfiguration /etc/nginx/sites-available/jupyterlab.
sudo nano /etc/nginx/sites-available/jupyterlab
Füge die folgende Konfiguration in die Datei ein und achte darauf, dass du den Domainnamen in der Option server_name änderst.
server {
listen 80;
server_name lab.hwdomain.io;
access_log /var/log/nginx/hwdomain.io.access.log;
error_log /var/log/nginx/hwdomain.io.error.log;
location / {
proxy_pass http://127.0.0.1:8888;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $http_host;
proxy_http_version 1.1;
proxy_redirect off;
proxy_buffering off;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_read_timeout 86400;
}
}
Wenn du fertig bist, speichere und beende die Datei.
Führe nun den folgenden Befehl aus, um den jupyterlab Serverblock zu aktivieren und deine Nginx-Syntax zu überprüfen. Wenn du die richtige Konfiguration hast, erhältst du eine Ausgabe syntax is ok ... test is successful.
sudo ln -s /etc/nginx/sites-available/jupyterlab /etc/nginx/sites-enabled/
sudo nginx -t
Zum Schluss führst du den unten stehenden Befehl aus, um Nginx neu zu starten und deine neue jupyterlab Serverblockkonfiguration anzuwenden. Nachdem der Befehl ausgeführt wurde, läuft dein Jupyter unter dem Nginx Reverse Proxy.
sudo systemctl restart nginx
Zugriff auf Jupyter
Wenn du Linux oder MacOS verwendest, bearbeite die Datei /etc/hosts. Unter Windows bearbeitest du die Datei C:\System32\drivers\etc\hosts als Administrator.
Füge die IP-Adresse deines Servers und den Domainnamen Jupyter wie folgt hinzu:
192.168.5.65 lab.hwdomain.io
Speichere und beende die Datei.
Öffne nun deinen Webbrowser und rufe deinen Jupyter-Domainnamen auf, z. B. http://lab.hwdomain.io/. Wenn deine Konfiguration erfolgreich war, siehst du die Jupyter-Anmeldeseite.
Scrolle ganz nach unten und füge das Token für deine Jupyter-Installation ein. Gib dann das neue Passwort für Jupyter ein und klicke auf Log in and set new password.
Wenn du erfolgreich warst, siehst du das Jupyter-Dashboard wie folgt – und dein Passwort für Jupyter hat sich auch geändert.
Fazit
Herzlichen Glückwunsch! Du hast die Installation von Jupyter auf Ubuntu 24.04 abgeschlossen. Jupyter läuft jetzt mit Nginx als Reverse Proxy und ist mit einer Passwortauthentifizierung gesichert. Wenn du Jupyter auf einem öffentlichen Server oder einem VPS (Virtual Private Server) betreibst, musst du HTTPS auf deinem Nginx-Reverse-Proxy implementieren. Das kannst du mit Certbot und Letsencrypt erreichen.