So installierst du JupyterLab auf Rocky Linux 9
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 zeigen wir dir Schritt für Schritt, wie du JupyterLab auf dem Rocky Linux 9 Server installierst. Du wirst JupyterLab installieren, die JupyterLab-Authentifizierung aktivieren und dann Nginx als Reverse Proxy einrichten.
Voraussetzungen
Um diesen Leitfaden zu erstellen, musst du folgende Voraussetzungen erfüllen
- Einen Rocky Linux 9 Server.
- Einen Nicht-Root-Benutzer mit sudo-Rechten.
- Ein SELinux mit dem Status permissive.
Abhängigkeiten installieren
Bevor du JupyterLab installierst, musst du die Abhängigkeiten auf deinem Rocky Linux Server installieren. Dazu gehören Pip, Node.js und die Entwicklungswerkzeuge. Außerdem musst du Nginx für den Reverse Proxy installieren.
Um zu beginnen, führe den unten stehenden Befehl aus, um die Entwicklungspakete auf deinem System zu installieren.
sudo dnf -y groupinstall development
Anschließend installierst du Pip, Node.js und Nginx mit dem folgenden Befehl.
sudo dnf install -y python3-pip nodejs nginx
Sobald die Installation abgeschlossen ist, fährst du mit dem nächsten Schritt fort.
Einrichten der virtuellen Python-Umgebung
In diesem Beispiel wirst du JupyterLab mit einem normalen Benutzer installieren und ausführen. Stelle also sicher, dass du deinen Benutzer mit sudo-Rechten vorbereitet hast.
Melde dich mit dem unten stehenden Befehl bei deinem Benutzer an.
su - user
Erstelle ein neues ~/project-Verzeichnis und wechsle dorthin. Dann erstellst du eine neue virtuelle Python-Umgebung venv.
mkdir -p ~/project; cd ~/project python3 -m venv venv
Sobald die virtuelle Umgebung venv erstellt ist, kannst du sie mit dem unten stehenden Befehl aktivieren.
source venv/bin/activate
Die Eingabeaufforderung sollte nun wie (venv) alice@hostname aussehen, was bedeutet, dass deine virtuelle Python-Umgebung aktiv ist.
JupyterLab installieren
Nachdem du nun eine virtuelle Python-Umgebung erstellt hast, kannst du JupyterLab installieren. In diesem Abschnitt installierst du JupyterLab, erstellst die JupyterLab-Konfiguration, richtest die Passwortauthentifizierung ein und verifizierst JupyterLab.
Um JupyterLab zu installieren, führst du den folgenden pip3-Befehl aus.
pip3 install jupyter
Sobald die Installation beginnt, solltest du eine Ausgabe wie diese erhalten:
Nachdem die Installation abgeschlossen ist, führe den folgenden Befehl aus, um die Jupyter-Binärdatei zu finden und die JupterLab-Version zu überprüfen.
which jupyter jupyter --version
Du solltest die JupyterLab-Binärdatei in deiner virtuellen Python-Umgebung vorfinden. Und die JupyterLab-Version ist 4.1.1.
Als Nächstes führst du den folgenden Jupyter-Befehl aus, um die Jupyter-Serverkonfiguration zu erstellen und die Passwortauthentifizierung einzurichten.
jupyter server --generate-config jupyter server password
Wenn du nach dem Passwort gefragt wirst, gib dein neues Passwort ein und wiederhole es.
Als Nächstes führst du den unten stehenden Befehl aus, um JupyterLab zu erstellen und gibst y ein, wenn du zum Überschreiben aufgefordert wirst. Überprüfe dann deine JupyterLab-Konfiguration.
jupyter lab --generate-config jupyter lab --show-config
Wie du unten sehen kannst, ist die Passwortauthentifizierung gehasht und der Pfad zu deinem JupyterLab sollte zugänglich sein.
Du kannst nun den unten stehenden Befehl ausführen, um Port 8888 für JupyterLab zu öffnen. Starte dann dein JupyterLab auf der lokalen IP 192.168.5.120 und stelle sicher, dass du die IP-Adresse änderst.
sudo firewall-cmd --add-port=8888/tcp jupyter lab --ip 192.168.5.120
Sobald es gestartet ist, solltest du eine ähnliche Ausgabe wie diese erhalten:
Öffne nun deinen Webbrowser und besuche deine lokale IP-Adresse mit Port 8888, http://192.168.5.120:8888/. Du wirst mit der Anmeldeseite von JupyterLab konfrontiert.
Gib dein Passwort ein und klicke auf Anmelden.
Wenn du erfolgreich warst, solltest du das JupyterLab-Dashboard wie folgt sehen:
Gehe zurück zu deinem Terminal und drücke Strg+c, um den JupyterLab-Prozess zu beenden. Im nächsten Schritt wirst du JupyterLab als systemd-Dienst einrichten.
JupyterLab als Systemd-Dienst ausführen
Nachdem du JupyterLab installiert hast, erstellst du nun einen neuen systemd-Dienst für JupyterLab. So kannst du JupyterLab einfach über das Systemdienstprogramm verwalten. Außerdem kannst du JupyterLab beim Booten starten, indem du den Dienst aktivierst.
Führe nun den folgenden Befehl im nano-Editor aus, um einen neuen Jupyterlab-Dienst /etc/systemd/system/jupyterlab.service zu erstellen.
sudo nano /etc/systemd/system/jupyterlab.service
Füge die unten stehende Konfiguration in die Datei ein und stelle sicher, dass du den Detailbenutzer durch deinen Benutzer ersetzt. Dazu gehören auch der Binärpfad des Jupyter-Programms und die generierte Konfiguration.
[Unit] Description=JupyterLab Service [Service] Type=simple PIDFile=/run/jupyter.pid ExecStart=/home/alice/project/venv/bin/jupyter lab --config=/home/alice/.jupyter/jupyter_lab_config.py User=alice Group=alice WorkingDirectory=/home/alice/project Restart=always RestartSec=10 [Install] WantedBy=multi-user.target
Wenn du fertig bist, speichere und beende die Datei.
Als Nächstes führst du den unten stehenden Befehl aus, um den systemd-Manager neu zu laden und die systemd-Änderungen anzuwenden.
sudo systemctl daemon-reload
Starte und aktiviere dann den jupyterlab-Dienst mit dem folgenden Befehl.
sudo systemctl start jupyterlab sudo systemctl enable jupyterlab
Sobald er gestartet ist, führe den folgenden Befehl aus, um deinen jupyterlab-Dienst zu überprüfen.
sudo systemctl status jupyterlab
Wenn der jupyterlab-Dienst läuft, solltest du eine Ausgabe wie die folgende erhalten:
Fernzugriff für JupyterLab konfigurieren
Um JupyterLab hinter einem Reverse Proxy zu betreiben, musst du den Fernzugriff für deine JupyterLab-Installation aktivieren. Du musst das standardmäßige JupyterLab-Konfigurationsskript ändern und den Fernzugriff dort aktivieren.
Öffne mit dem Editor nano das JupyterLab-Konfigurationsskript ~/.jupyter/jupyter_lab_config.py.
nano ~/.jupyter/jupyter_lab_config.py
Entferne den Kommentar zu dem Parameter c.ServerApp.allow_remote_access und ändere den Wert in True. Damit wird der Fernzugriff für den Reverse Proxy in der JupyterLab-Installation aktiviert.
c.ServerApp.allow_remote_access = True
Wenn du fertig bist, speichere und beende die Datei.
Als Nächstes führst du den folgenden Befehl aus, um den JupyterLab-Dienst neu zu starten und das erzeugte Token zu überprüfen. Dieses Token wird für die Anmeldung bei JupyterLab über den Reverse-Proxy verwendet.
sudo systemctl restart jupyterlab sudo systemctl status jupyterlab
Am Ende des Dienstprotokolls kannst du das JupyterLab-Token sehen.
Nginx Reverse Proxy einrichten
Nachdem du den Fernzugriff in JupyterLab erlaubt hast, kannst du nun Nginx als Reverse Proxy für deine JupyterLab-Installation konfigurieren.
Führe zunächst den folgenden Befehl im Editor nano aus, um eine neue Nginx-Konfiguration /etc/nginx/conf.d/jupyterlab.conf zu erstellen.
sudo nano /etc/nginx/conf.d/jupyterlab.conf
Füge die unten stehende Konfiguration ein und achte darauf, dass du den Domainnamen mit deiner lokalen JupyterLab-Installation vergleichst.
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 unten stehenden Befehl aus, um deine Nginx-Syntax zu überprüfen. Wenn er erfolgreich ist, solltest du die Ausgabe „Syntax ist ok – Test ist erfolgreich“ erhalten.
sudo nginx -t
Starte und aktiviere als Nächstes den Nginx-Dienst mit dem folgenden Befehl.
sudo systemctl start nginx sudo systemctl enable nginx
Sobald Nginx gestartet ist, überprüfe den Dienst mit dem folgenden Befehl. Stelle sicher, dass der Nginx-Dienst läuft.
sudo systemctl status nginx
Führe abschließend den folgenden Befehl aus, um den HTTP-Port auf deinem System zu öffnen und den Datenverkehr zu deiner JupyterLab-Installation zuzulassen.
sudo firewall-cmd --add-service={http,https} --permanent
sudo firewall-cmd --reload
Damit sollte deine JupyterLab-Installation über den Reverse-Proxy erreichbar sein.
Einloggen in JupyterLab
Öffne einen neuen Tab in deinem Webbrowser und rufe den Domainnamen deiner JupyterLab-Installation auf, z. B. http://jupyterlab.hwdomain.io/. Wenn deine Installation erfolgreich war, wirst du zur JupyterLab-Anmeldeseite weitergeleitet.
Scrolle zur unteren Seite und füge dein JupyterLab-Token ein. Gib dann das neue Passwort für deine JupyterLab-Installation ein, drücke auf Login und richte das neue Passwort ein.
Wenn du den richtigen Token hast, solltest du das JupyterLab-Dashboard erhalten und dein Passwort sollte ebenfalls geändert werden.
Fazit
Herzlichen Glückwunsch! Du hast JupyterLab erfolgreich auf Rocky Linux 9 installiert, die JupyetrLab-Authentifizierung konfiguriert und Nginx als Reverse-Proxy für deine JupyterLab-Installation eingerichtet.