Anleitung zur Installation von JupyterLab unter Debian 12
Jupyter ist eine freie und quelloffene Webanwendung für interaktives Computing und Data Science. Jupyter unterstützt alle Programmiersprachen und bietet verschiedene Software an, wie z.B. JupyetrLab, das eine funktionsreiche Bearbeitungsumgebung für mehrere Notizbücher mit Registerkarten bietet, Notebook als leichtgewichtige und vereinfachte Notizbucherstellung, Qtconsole und viele mehr.
In dieser Anleitung führen wir dich Schritt für Schritt durch die Installation von JupyterLab unter Debian 12. Du wirst JupyterLab in einer virtuellen Python-Umgebung installieren, JupyterLab als systemd-Dienst ausführen und anschließend Nginx als Reverse-Proxy für JupyterLab installieren und einrichten.
Voraussetzungen
Bevor du beginnst, solltest du sicherstellen, dass du über die folgenden Voraussetzungen verfügst:
- Einen Debian 12 Server.
- Einen Nicht-Root-Benutzer mit Administrator-Rechten.
Installieren der Abhängigkeiten
Jupyter ist ein Ökosystem aus freier und quelloffener Python-Software für interaktive Berechnungen in allen Programmiersprachen. Um Jupyter zu installieren, musst du sicherstellen, dass Python auf deinem System installiert ist.
In diesem Abschnitt wirst du die Paketabhängigkeiten für Jupyter installieren. Dazu gehören Python3, der Paketmanager Pip, die virtuelle Umgebung Python venv und Node.js.
Bevor du beginnst, aktualisiere deinen Debian-Paketindex mit dem folgenden Befehl.
sudo apt update
Installiere nun die Abhängigkeiten, indem du den folgenden apt install-Befehl ausführst. Damit installierst du Python3, den Paketmanager Pip, die Verwaltung der virtuellen Umgebung venv und Node. js.
sudo apt install python3 python3-pip python3-venv nodejs
Bestätige mit y und fahre mit der Installation fort.
Nachdem die Abhängigkeiten installiert sind, führe den folgenden Befehl aus, um die Version der einzelnen Abhängigkeiten zu überprüfen, einschließlich Python3, Pip und Node.js
python3 --version pip3 --version node --version
Die folgende Ausgabe zeigt dir, dass Python 3.11, Pip 23 und Node.js 18.13 installiert sind.
Jupyter installieren
Nachdem du die Abhängigkeiten installiert hast, installierst du als Nächstes die Jupyter-Metapakete mit Hilfe der virtuellen Python-Umgebung auf dem Debian 12-Rechner. Dazu musst du die folgenden Schritte ausführen:
- Erstellen einer virtuellen Python-Umgebung
- Installieren von Jupyter
- JupyterLab konfigurieren
Los geht’s.
Virtuelle Python-Umgebung erstellen
In diesem Abschnitt erstellst du eine neue virtuelle Python-Umgebung, die für die Jupyter-Installation verwendet wird. Mit diesem Szenario hast du eine isolierte Entwicklungsumgebung, die dein gesamtes System nicht beeinträchtigt. Außerdem kannst du sie im Laufe der Zeit immer wieder neu erstellen.
Melde dich mit folgendem Befehl als Nicht-Root-Benutzer an.
su - user
Erstelle nun ein neues Verzeichnis ~/project und wechsle in dieses Verzeichnis. Dann erstellst du mit dem folgenden Befehl eine neue virtuelle Umgebung namens venv. Nachdem du den Befehl ausgeführt hast, wird das neue Verzeichnis venv erstellt.
mkdir -p ~/project; cd ~/project python3 -m venv venv
Als Nächstes führst du den folgenden Befehl aus, um die virtuelle Umgebung venv zu aktivieren. Sobald sie aktiviert ist, sieht deine Shell-Eingabeaufforderung wie folgt aus: „(venv) user@hostname:#…„.
source venv/bin/activate
Installation von Jupyter
Nachdem du eine virtuelle Python-Umgebung erstellt hast, installierst du das Jupyter-Paket über Pip. Das Jupyter-Paket ist ein Meta-Paket des Jupyter-Ökosystems, das IPython, JupyterLab, Jupyter Server, Jupyter Notebook, qtconsole und vieles mehr enthält.
Führe den folgenden pip3-Befehl aus, um Jupyter auf deinem Debian-System zu installieren.
pip3 install jupyter
Während der Installation wird die folgende Ausgabe in deinem Terminal angezeigt:
Nachdem die Installation abgeschlossen ist, überprüfe den Speicherort der Jupyter-Binärdatei und die Version mit dem folgenden Befehl.
which jupyter jupyter --version
In der folgenden Ausgabe solltest du sehen, dass sich die Jupyter-Binärdatei im Verzeichnis venv befindet. Außerdem solltest du die Version des Jupyter-Pakets sehen, die auf deinem System installiert ist.
JupyterLab konfigurieren
JupyterLab ist die webbasierte Benutzeroberfläche der nächsten Generation für das Jupyter-Ökosystem. Mit JupyterLab kannst du mit Dokumenten und Aktivitäten wie dem Jupyter Notebook, dem Texteditor und dem Terminal in einem einzigen Fenster arbeiten. Das JupyterLab bietet dir eine IDE-ähnliche Erfahrung für die Verwaltung und Entwicklung von Jupyter-Projekten.
In diesem Abschnitt wirst du das JupyterLab für dein Jupyter-Projekt einrichten. Zuvor musst du jedoch den Jupyter Server konfigurieren, um deine Installation zu sichern.
Führe zunächst den folgenden Befehl aus, um die Jupyter Server-Konfigurationsdatei zu erstellen und das Passwort einzurichten. Gib dein Passwort ein und wiederhole es.
jupyter server --generate-config jupyter server password
Nachdem du den Befehl ausgeführt hast, wird die Jupyter Server-Konfiguration im Verzeichnis ~/.jupyter/ erstellt.
Du kannst den Inhalt der Jupyter-Server-Konfiguration mit dem folgenden Befehl überprüfen.
jupyter server --show-config
Es wird eine ähnliche Ausgabe wie unten angezeigt:
Als Nächstes führst du den folgenden Befehl aus, um eine neue Konfiguration für JupyterLab zu erstellen. Die JupyterLab-Konfiguration wird im Verzeichnis ~/.jupyter/ erstellt.
jupyter lab --generate-config
Nachdem die Konfiguration erstellt wurde, überprüfe die JupyterLab-Konfiguration mit dem folgenden Befehl.
jupyter lab --show-config
Unten siehst du ein Beispiel für eine JupyterLab-Konfiguration:
Jetzt kannst du die JupyterLab-Installation mit dem folgenden Befehl ausführen. Achte darauf, dass du die IP-Adresse mit der IP-Adresse deines Servers vergleichst.
jupyter lab --ip 192.168.10.15
Das JupyterLab wird auf der IP-Adresse deines Servers mit dem Standardport 8888 ausgeführt. Das JupyterLab ist über den URL-Pfad /lab erreichbar.
Öffne deinen Webbrowser und rufe die IP-Adresse deines Servers gefolgt von Port 8888 und dem Pfad /lab auf, z. B. http://192.168.10.15:8888/lab. Gib dein Jupyter-Server-Passwort ein und klicke auf „Anmelden „, um fortzufahren.
Wenn du das richtige Passwort hast, solltest du das JupyterLab-Benutzer-Dashboard wie das folgende sehen:
Du kannst jetzt zweimal Strg+c drücken, um den JupyterLab-Prozess zu beenden.
JupyterLab als Systemd-Dienst ausführen
Im folgenden Schritt erstellst du eine neue systemd-Dienstdatei, die zum Ausführen von JupyterLab verwendet wird. Auf diese Weise läuft deine JupyterLab-Installation im Hintergrund als systemd-Dienst und du kannst JupyterLab einfach über das Dienstprogramm systemctl verwalten.
Erstelle eine neue systemd-Dienstdatei /etc/systemd/system/jupyterlab.service mit dem folgenden Befehl des nano-Editors.
sudo nano /etc/systemd/system/jupyterlab.service
Füge die folgende Konfiguration ein und achte darauf, dass du den Benutzernamen bob änderst.
[Unit] Description=JupyterLab Service [Service] Type=simple PIDFile=/run/jupyter.pid ExecStart=/home/bob/project/venv/bin/jupyter lab --config=/home/bob/.jupyter/jupyter_lab_config.py User=bob Group=bob WorkingDirectory=/home/bob/project Restart=always RestartSec=10 [Install] WantedBy=multi-user.target
Wenn du fertig bist, speichere und schließe die Datei.
Führe nun den folgenden systemctl-Befehl aus, um den systemd-Manager neu zu laden und die Änderungen zu übernehmen.
sudo systemctl daemon-reload
Starte und aktiviere dann den jupyterlab-Dienst mit dem folgenden Befehl.
sudo systemctl start jupyterlab sudo systemctl enable jupyterlab
Überprüfe abschließend den jupyterlab-Dienst, um sicherzustellen, dass er läuft.
sudo systemctl status jupyterlab
Die folgende Ausgabe bestätigt, dass der jupyterlab-Dienst läuft.
Nginx als Reverse Proxy für Jupyter konfigurieren
In diesem Leitfaden wirst du JupyterLab mit Nginx als Reverse Proxy betreiben. Um das zu erreichen, musst du Folgendes erledigen:
- Fernzugriff auf JupyterLab zulassen
- Installieren und Konfigurieren von Nginx als Reverse Proxy
Fernzugriff auf JupyterLab zulassen
Standardmäßig ist die JupyterLab-Installation nur über eine lokale IP-Adresse erreichbar. Um eine Fernverbindung zu ermöglichen, musst du die Standardkonfiguration von JupyterLab ändern.
Öffne die JupyterLab-Konfiguration ~/.jupyter/jupyter_lab_config.py mit dem folgenden nano-Editor-Befehl.
nano ~/.jupyter/jupyter_lab_config.py
Entferne den Kommentar in der Option c.ServerApp.allow_remote_access und ändere den Wert in True. Dadurch wird JupyterLab von einer Remote-Verbindung aus zugänglich gemacht, was auch bedeutet, dass JupyterLab hinter einem Reverse-Proxy läuft.
c.ServerApp.allow_remote_access = True
Speichere die Datei und beende den Editor, wenn du fertig bist.
Führe nun den folgenden systemctl-Befehl aus, um den jupyterlab-Dienst neu zu starten und die Änderungen zu übernehmen.
sudo systemctl restart jupyterlab
Überprüfe dann den jupyterlab-Dienst mit dem folgenden Befehl.
sudo systemctl status jupyterlab
In der unteren Ausgabe solltest du das generierte Token für den Zugriff auf deine JupyterLab-Installation sehen, das du für den nächsten Abschnitt kopieren solltest.
Installieren und Konfigurieren von Nginx als Reverse Proxy
Nachdem du den Fernzugriff auf JupyterLab erlaubt hast, installierst du als Nächstes Nginx und konfigurierst es als Reverse-Proxy für deine JupyterLab-Installation.
Installiere Nginx, indem du den unten stehenden apt install-Befehl ausführst.
sudo apt install nginx -y
Unten siehst du die Ausgabe während der Nginx-Installation.
Nachdem Nginx installiert ist, erstelle eine neue Serverblock-Konfiguration /etc/nginx/sites-available/jupyterlab mit dem folgenden nano-Editor.
sudo nano /etc/nginx/sites-available/jupyterlab
Füge die folgende Konfiguration ein und achte darauf, dass du den Domainnamen in der Option server_name änderst.
server {
listen 80;
server_name jupyterlab.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;
}
}
Speichere und beende die Datei, wenn du fertig bist.
Führe nun den folgenden Befehl aus, um die Serverblockdatei /etc/nginx/sites-available/jupyterlab zu aktivieren und die Nginx-Konfiguration zu überprüfen.
sudo ln -s /etc/nginx/sites-available/jupyterlab /etc/nginx/sites-enabled/ sudo nginx -t
Wenn du die Nginx-Syntax richtig eingestellt hast, solltest du die Ausgabe„syntax is ok – test is successful“ erhalten.
Führe abschließend den Befehl systemctl aus, um den Nginx-Dienst neu zu starten und die Änderungen zu übernehmen. Überprüfe anschließend, ob der Dienst läuft.
sudo systemctl restart nginx sudo systemctl status nginx
Wenn Nginx läuft, solltest du die Ausgabe active (läuft) erhalten.
Zugriff auf die JupyterLab-Installation über den lokalen Rechner
Um auf JupyterLab über den Domänennamen zuzugreifen, kannst du die Datei /etc/hosts für Linux-Clients oder die Datei C:\Windows\System32\drivers\etc\hosts für Windows-Benutzer verwenden.
Öffne die Datei /etc/hosts auf deinem Linux-Client mit dem nano-Editor.
sudo nano /etc/hosts
Füge die folgende Konfiguration in die Datei ein und achte darauf, dass du die IP-Adresse und den Domänennamen mit deinen Angaben änderst.
192.168.10.15 jupyterlab.hwdomain.io
Speichere und beende die Datei, wenn du fertig bist.
Als Nächstes öffnest du deinen Webbrowser und rufst den Domainnamen deiner JupyterLab-Installation auf, z. B. http://jupyterlab.hwdomain.io. Wenn deine Installation erfolgreich war, solltest du die Anmeldeseite von JupyterLab erhalten.
Auf der unteren Seite gibst du das generierte und das neue Passwort für deine JupyterLab-Installation ein. Klicke dann auf die Schaltfläche Anmelden und setze ein neues Passwort.
Wenn alles geklappt hat, solltest du zum JupyterLab-Dashboard weitergeleitet werden, wie im Folgenden zu sehen.
Damit ist deine JupyterLab-Installation abgeschlossen.
Fazit
Mit dieser Schritt-für-Schritt-Anleitung hast du die Installation von JupyterLab auf dem Debian 12 Server abgeschlossen. Du hast JupyterLab mithilfe der virtuellen Python-Umgebung installiert, JupyterLab als systemd-Dienst im Hintergrund laufen lassen und Nginx als Reverse-Proxy für JupyterLab konfiguriert. Jetzt kannst du dein Jupyter-Projekt erstellen und verwalten.