So installieren Sie JupyterLab auf Rocky Linux 9

Jupyter ist eine kostenlose und Open-Source-Webanwendung für interaktive Berechnungen und Datenwissenschaft.

Jupyter unterstützt alle Programmiersprachen und bietet mehrere Softwarelösungen, wie JupyterLab, das eine funktionsreiche und tabbed Multi-Notebook-Bearbeitungsumgebung bietet, Notebook als leichtgewichtige und vereinfachte Notizbuchautoren, Qtconsole und viele mehr.

In diesem Leitfaden zeigen wir Ihnen Schritt-für-Schritt-Anleitungen zur Installation von JupyterLab auf dem Rocky Linux 9-Server. Sie werden JupyterLab installieren, die JupyterLab-Authentifizierung aktivieren und dann Nginx als Reverse-Proxy einrichten.

Voraussetzungen

Um diesen Leitfaden abzuschließen, stellen Sie sicher, dass Sie Folgendes haben:

Einen Rocky Linux 9-Server.
Einen Nicht-Root-Benutzer mit Sudo-Rechten.
Ein SELinux mit dem Status permissiv.

Abhängigkeiten installieren

Bevor Sie JupyterLab installieren, müssen Sie Abhängigkeiten auf Ihrem Rocky Linux-Server installieren. Dazu gehören Pip, Node.js und Entwicklungstools. Darüber hinaus installieren Sie auch Nginx für den Reverse-Proxy.

Um zu beginnen, führen Sie den folgenden Befehl aus, um Entwicklungspakete auf Ihrem System zu installieren.

sudo dnf -y groupinstall development

Installieren Sie dann Pip, Node.js und Nginx mit dem folgenden Befehl.

sudo dnf install -y python3-pip nodejs nginx

Sobald die Installation abgeschlossen ist, fahren Sie mit dem nächsten Schritt fort.

install deps

Python-Virtual-Umgebung einrichten

In diesem Beispiel installieren und führen Sie JupyterLab mit einem normalen Benutzer aus. Stellen Sie also sicher, dass Sie Ihren Benutzer mit Sudo-Rechten vorbereitet haben.

Melden Sie sich mit dem folgenden Befehl bei Ihrem Benutzer an.

su - user

Erstellen Sie ein neues Verzeichnis ~/project und wechseln Sie hinein. Erstellen Sie dann eine neue Python-Virtual-Umgebung venv.

mkdir -p ~/project; cd ~/project  
python3 -m venv venv

Sobald die venv-Virtual-Umgebung erstellt ist, können Sie sie mit dem folgenden Befehl aktivieren.

source venv/bin/activate

Hier sollte Ihre Eingabeaufforderung wie (venv) alice@hostname aussehen, was bedeutet, dass Ihre Python-Virtual-Umgebung aktiv ist.

setup venv

JupyterLab installieren

Jetzt, da Sie eine Python-Virtual-Umgebung erstellt haben, sind Sie bereit, JupyterLab zu installieren. In diesem Abschnitt installieren Sie JupyterLab, generieren die JupyterLab-Konfiguration, richten die Passwortauthentifizierung ein und überprüfen dann JupyterLab.

Um JupyterLab zu installieren, führen Sie den folgenden pip3-Befehl aus.

pip3 install jupyter

Sobald die Installation beginnt, sollten Sie eine Ausgabe wie diese erhalten:

install jupyterlab

Nachdem die Installation abgeschlossen ist, führen Sie den folgenden Befehl aus, um die Jupyter-Binärdatei zu finden und die JupyterLab-Version zu überprüfen.

which jupyter  
jupyter --version

Sie sollten die JupyterLab-Binärdatei in Ihrer Python-Virtual-Umgebung finden. Und die JupyterLab-Version ist 4.1.1.

verify jupyter

Führen Sie als Nächstes den folgenden Jupyter-Befehl aus, um die Jupyter-Serverkonfiguration zu generieren und die Passwortauthentifizierung einzurichten.

jupyter server --generate-config  
jupyter server password

Wenn Sie nach dem Passwort gefragt werden, geben Sie Ihr neues Passwort ein und wiederholen Sie es.

generate password jupyter server

Führen Sie als Nächstes den folgenden Befehl aus, um JupyterLab zu generieren, und geben Sie y ein, wenn Sie gefragt werden, ob Sie überschreiben möchten. Überprüfen Sie dann Ihre JupyterLab-Konfiguration.

jupyter lab --generate-config  
jupyter lab --show-config

Wie Sie unten sehen können, ist die Passwortauthentifizierung gehasht und der Pfad zu Ihrer JupyterLab-Installation sollte zugänglich sein.

generate config file jupyter lab

Sie können jetzt den folgenden Befehl ausführen, um den Port 8888 für JupyterLab zu öffnen. Starten Sie dann Ihr JupyterLab auf der lokalen IP 192.168.5.120 und stellen Sie sicher, dass Sie die IP-Adresse ändern.

sudo firewall-cmd --add-port=8888/tcp  
jupyter lab --ip 192.168.5.120

Sobald es gestartet ist, sollten Sie eine ähnliche Ausgabe wie diese erhalten:

test jupyterlab install

Öffnen Sie jetzt Ihren Webbrowser und besuchen Sie Ihre lokale IP-Adresse mit Port 8888, http://192.168.5.120:8888/. Sie werden mit der JupyterLab-Anmeldeseite aufgefordert.

Geben Sie Ihr Passwort ein und drücken Sie Anmelden.

Wenn es erfolgreich ist, sollten Sie das JupyterLab-Dashboard wie folgt erhalten:

jupyterlab dashboard

Zuletzt kehren Sie zu Ihrem Terminal zurück und drücken Sie Ctrl+c, um den JupyterLab-Prozess zu beenden. Im nächsten Schritt richten Sie JupyterLab als systemd-Dienst ein.

JupyterLab als Systemd-Dienst ausführen

Nachdem JupyterLab installiert ist, erstellen Sie nun einen neuen systemd-Dienst für JupyterLab. Dies ermöglicht es Ihnen, JupyterLab einfach über das Systemdienstprogramm zu verwalten. Außerdem können Sie JupyterLab beim Booten starten, indem Sie den Dienst aktivieren.

Führen Sie jetzt den folgenden nano-Editor-Befehl aus, um einen neuen jupyterlab-Dienst /etc/systemd/system/jupyterlab.service zu erstellen.

sudo nano /etc/systemd/system/jupyterlab.service

Fügen Sie die folgende Konfiguration in die Datei ein und stellen Sie sicher, dass Sie die Benutzerdetails mit Ihrem Benutzer ändern. Dazu gehört 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 Sie fertig sind, speichern Sie die Datei und beenden Sie den Editor.

Führen Sie als Nächstes den folgenden Befehl aus, um den systemd-Manager neu zu laden und die systemd-Änderungen anzuwenden.

sudo systemctl daemon-reload

Starten und aktivieren Sie dann den jupyterlab-Dienst mit dem folgenden Befehl.

sudo systemctl start jupyterlab  
sudo systemctl enable jupyterlab

jupyterlab systemd

Sobald es gestartet ist, führen Sie den folgenden Befehl aus, um Ihren jupyterlab-Dienst zu überprüfen.

sudo systemctl status jupyterlab

Wenn der jupyterlab-Dienst läuft, sollten Sie eine Ausgabe wie die folgende erhalten:

check jupyterlab service

Remote-Zugriff für JupyterLab konfigurieren

Um JupyterLab hinter einem Reverse-Proxy auszuführen, müssen Sie den Remote-Zugriff auf Ihrer JupyterLab-Installation aktivieren. Sie müssen das Standard-JupyterLab-Konfigurationsskript ändern und den Remote-Zugriff von dort aktivieren.

Führen Sie den folgenden nano-Editor-Befehl aus, um das JupyterLab-Konfigurationsskript ~/.jupyter/jupyter_lab_config.py zu öffnen.

nano ~/.jupyter/jupyter_lab_config.py

Kommentieren Sie den Parameter c.ServerApp.allow_remote_access aus und ändern Sie den Wert auf True. Dies aktiviert den Remote-Zugriff für den Reverse-Proxy in der JupyterLab-Installation.

c.ServerApp.allow_remote_access = True

Wenn Sie fertig sind, speichern Sie die Datei und beenden Sie den Editor.

Führen Sie als Nächstes den folgenden Befehl aus, um den JupyterLab-Dienst neu zu starten und das generierte Token zu überprüfen. Dieses Token wird verwendet, um sich unter dem Reverse-Proxy bei JupyterLab anzumelden.

sudo systemctl restart jupyterlab  
sudo systemctl status jupyterlab

Am Ende des Dienstprotokolls können Sie das JupyterLab-Token sehen.

Nginx Reverse-Proxy einrichten

Jetzt, da Sie den Remote-Zugriff in JupyterLab erlaubt haben, sind Sie bereit, Nginx als Reverse-Proxy für Ihre JupyterLab-Installation zu konfigurieren.

Führen Sie zuerst den folgenden nano-Editor-Befehl aus, um eine neue Nginx-Konfiguration /etc/nginx/conf.d/jupyterlab.conf zu erstellen.

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

Fügen Sie die folgende Konfiguration ein und stellen Sie sicher, dass Sie den Domainnamen mit Ihrer lokalen JupyterLab-Installation ändern.

server {  
listen 80;  
server_name jupyterlab.howtoforge.local;  
  
access_log /var/log/nginx/howtoforge.local.access.log;  
error_log /var/log/nginx/howtoforge.local.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;  
}  
}

Speichern Sie die Datei und beenden Sie den Editor, wenn Sie fertig sind.

Führen Sie jetzt den folgenden Befehl aus, um Ihre Nginx-Syntax zu überprüfen. Wenn erfolgreich, sollten Sie eine Ausgabe ‘Syntax ist ok - Test war erfolgreich’ erhalten.

sudo nginx -t

Starten und aktivieren Sie dann den Nginx-Dienst mit dem folgenden Befehl.

sudo systemctl start nginx  
sudo systemctl enable nginx

setup nginx

Sobald Nginx gestartet ist, überprüfen Sie den Dienst mit dem folgenden Befehl. Stellen Sie sicher, dass der Nginx-Dienst läuft.

sudo systemctl status nginx

verify nginx

Führen Sie zuletzt den folgenden Befehl aus, um den HTTP-Port auf Ihrem System zu öffnen und den Datenverkehr zu Ihrer JupyterLab-Installation zuzulassen.

sudo firewall-cmd --add-service={http,https} --permanent  
sudo firewall-cmd --reload

Damit sollte Ihre JupyterLab-Installation über den Reverse-Proxy zugänglich sein.

Anmelden bei JupyterLab

Öffnen Sie einen neuen Tab in Ihrem Webbrowser und besuchen Sie den Domainnamen Ihrer JupyterLab-Installation, z. B. http://jupyterlab.howtoforge.local/. Wenn Ihre Installation erfolgreich ist, werden Sie mit der JupyterLab-Anmeldeseite aufgefordert.

Scrollen Sie zum Ende der Seite und fügen Sie Ihr JupyterLab-Token ein. Geben Sie dann das neue Passwort für Ihre JupyterLab-Installation ein und drücken Sie Anmelden und neues Passwort festlegen.

Wenn Sie das richtige Token haben, sollten Sie das JupyterLab-Dashboard erhalten und Ihr Passwort sollte ebenfalls geändert werden.