HowtoForge

Anleitung zur Installation von JupyterLab unter Debian 12

von ·

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

Repo aktualisieren

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.

deps installieren

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.

python pip node.js prüfen

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

virtuelle Umgebung erstellen python

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:

jupyter installieren

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.

Jupyter prüfen

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.

sicherer Jupyter

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:

jupyter server config

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

Jupyterlab-Konfiguration erzeugen

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:

Jupyterlab-Konfiguration überprüfen

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.

jupyterlab ausführen

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

jupyterlab Anmeldung

Wenn du das richtige Passwort hast, solltest du das JupyterLab-Benutzer-Dashboard wie das folgende sehen:

jupyterlab Dashboard

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

jupyterlab als Dienstleistung

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

Überprüfung des Jupyterlab-Dienstes

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.

Token anzeigen

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.

nginx installieren

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.

nginx Reverse Proxy einrichten

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.

Setup-Passwort

Wenn alles geklappt hat, solltest du zum JupyterLab-Dashboard weitergeleitet werden, wie im Folgenden zu sehen.

jupyterlab Dashboard

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.

Das könnte dich auch interessieren …