So installierst und konfigurierst du eine JupyterLab-Umgebung auf Rocky Linux 9
JupyterLab ist eine webbasierte Entwicklungsumgebung der nächsten Generation für das Projekt Jupyter. Project Jupyter wurde mit dem Ziel entwickelt, quelloffene, offene Standards und Dienste für interaktives Computing in verschiedenen Programmiersprachen zu entwickeln. JupyterLab bietet eine flexible Schnittstelle, die es Entwicklern ermöglicht, mit Dokumenten und Aktivitäten wie Jupyter-Notizbüchern, Texteditoren, Terminals und benutzerdefinierten Komponenten auf flexible, integrierte und erweiterbare Weise zu arbeiten. JupyterLab ist die nächste Generation von Jupyter Notebook und soll es irgendwann ablösen. Es unterstützt über 40 Programmiersprachen, darunter R, Python, Scala und Julia.
In diesem Lernprogramm lernst du, wie du JupyterLab auf einem Rocky Linux 9 Server installierst und konfigurierst.
Voraussetzungen
- Ein Server, auf dem Rocky Linux 9 läuft.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein vollständig qualifizierter Domainname (FQDN), der auf deinen Server verweist. Für unsere Zwecke verwenden wir
jupyterlab.example.comals Domänennamen. - SELinux ist deaktiviert.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo dnf update
- Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon installiert.
$ sudo dnf install wget curl nano unzip yum-utils -y
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.
$ sudo firewall-cmd --state running
Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.
$ sudo firewall-cmd --permanent --list-services
Es sollte die folgende Ausgabe angezeigt werden.
cockpit dhcpv6-client ssh
Wiki.js braucht HTTP- und HTTPS-Ports, um zu funktionieren. Öffne sie.
$ sudo firewall-cmd --add-service=http --permanent $ sudo firewall-cmd --add-service=https --permanent
Lade die Firewall neu, um die Änderungen zu übernehmen.
$ sudo firewall-cmd --reload
Schritt 2 – Nginx installieren
Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zur Erstellung des offiziellen Nginx-Repositorys.
$ sudo nano /etc/yum.repos.d/nginx.repo
Füge den folgenden Code in die Datei ein.
[nginx-stable] name=nginx stable repo baseurl=http://nginx.org/packages/centos/$releasever/$basearch/ gpgcheck=1 enabled=1 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true [nginx-mainline] name=nginx mainline repo baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/ gpgcheck=1 enabled=0 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere den Nginx-Server.
$ sudo dnf install nginx -y
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.22.1
Aktiviere und starte den Nginx-Server.
$ sudo systemctl enable nginx --now
Überprüfe den Status des Servers.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
Active: active (running) since Tue 2022-12-13 06:07:05 UTC; 31s ago
Docs: http://nginx.org/en/docs/
Process: 146475 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 146476 (nginx)
Tasks: 2 (limit: 5911)
Memory: 1.9M
CPU: 15ms
CGroup: /system.slice/nginx.service
??146476 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??146477 "nginx: worker process"
Schritt 3 – JupyterLab installieren
Überprüfe zuerst die Python-Version.
$ python -V Python 3.9.14
Installiere den PIP-Paketmanager.
$ sudo dnf install python3-pip
Erstelle ein Verzeichnis für JupyterLab.
$ mkdir jupyterlab
Wechsle in das neu erstellte Verzeichnis.
$ cd ~/jupyterlab
Richte eine virtuelle Umgebung namens jupyterlab_env ein.
$ python3 -m venv --system-site-packages jupyterlab_env
Aktiviere die Umgebung.
$ source jupyterlab_env/bin/activate
Aktualisiere den Pip-Paketmanager.
(jupyterlab_env) $ pip install --upgrade pip
Installiere JupyterLab.
(jupyterlab_env) $ pip install jupyterlab
Schritt 4 – JupyterLab konfigurieren
Standardmäßig erzeugt JupyterLab bei jedem Start ein neues Token, um den Zugriff auf die Schnittstelle zu ermöglichen. Ersetzen wir dies durch eine Passwortauthentifizierung.
Erstelle einen Passwort-Hash. Ersetze YOUR_PASSWORD durch ein sicheres Passwort deiner Wahl.
(jupyterlab_env) $ python3 -c "from jupyter_server.auth import passwd; print(passwd('YOUR_PASSWORD'))"
Mit dem obigen Befehl wird ein langer Passwort-Hash erzeugt. Er verwendet die Passwort-Hash-Funktion von Argon2. Notiere dir den Hash.
Erstelle eine JupyterLab-Konfigurationsdatei.
(jupyterlab_env) $ jupyter lab --generate-config
Der obige Befehl erstellt eine Konfigurationsdatei mit Standardwerten und speichert sie im Verzeichnis ~/.jupyter.
Öffne die Datei zum Bearbeiten.
(jupyterlab_env) $ nano ~/.jupyter/jupyter_lab_config.py
Finde die folgenden Variablen, entkommentiere sie und ändere ihren Wert wie unten angegeben. Ersetze PASSWORD_HASH durch die oben generierte Raute.
c.ServerApp.allow_remote_access = True c.ServerApp.password = 'PASSWORD_HASH'
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne Port 8888 in der Firewall.
$ sudo firewall-cmd --add-port=8888/tcp --permanent $ sudo firewall-cmd --reload
Starte den JupyterLab-Server. Der Parameter --ip 0.0.0.0 ermöglicht es, dass er auf jede IP-Adresse hört und nicht nur auf localhost.
$ jupyter lab --ip 0.0.0.0
Der obige Befehl startet einen JupyterLab-Server auf dem Standardport 8888, den wir geöffnet haben. Rufe die URL http://<yourserverIP>:8888/ in deinem Browser auf und du siehst den folgenden Bildschirm.
Gib dein Passwort ein und klicke auf die Schaltfläche Anmelden, um die JupyterLab-Oberfläche zu öffnen.
Nachdem der Zugriff bestätigt wurde, drücke Strg + C, um den Server zu stoppen, und gib y ein, wenn du dazu aufgefordert wirst.
Schritt 5 – JupyterLab-Dienstdatei erstellen
Beende die virtuelle Umgebung.
(jupyterlab_env) $ deactivate
Erstelle eine neue Servicedatei für JupyterLab.
$ sudo nano /lib/systemd/system/jupyterlab.service
Füge den folgenden Code in die Datei ein.
[Unit] Description=JupyterLab Server [Service] User=USER Group=USER Type=simple WorkingDirectory=/home/USER/jupyterlab ExecStart=/home/USER/jupyterlab/jupyterlab_env/bin/jupyter-lab --config=/home/USER/.jupyter/jupyter_lab_config.py StandardOutput=null Restart=always RestartSec=10 [Install] WantedBy=multi-user.target
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Ersetze USER durch den aktuell angemeldeten Benutzer deines Systems.
Initialisiere den JupyterLab-Dienst.
$ sudo systemctl daemon-reload
Aktiviere und starte den JupyterLab-Dienst.
$ sudo systemctl enable jupyterlab --now
Überprüfe den Status des Dienstes.
$ sudo systemctl status jupyterlab
? jupyterlab.service - JupyterLab Server
Loaded: loaded (/usr/lib/systemd/system/jupyterlab.service; disabled; vendor preset: disabled)
Active: active (running) since Tue 2022-12-13 11:45:26 UTC; 5s ago
Main PID: 151675 (jupyter-lab)
Tasks: 1 (limit: 5911)
Memory: 59.0M
CPU: 1.943s
CGroup: /system.slice/jupyterlab.service
??151675 /home/navjot/jupyterlab/jupyterlab_env/bin/python3 /home/navjot/jupyterlab/jupyterlab_env/bin/jupyter-lab --config=/home/navjot/.jupyter/jupyter_lab_config.py
Dec 13 11:45:26 jupyter.example.com systemd[1]: Started JupyterLab Server.
Schritt 6 – SSL installieren
Bevor wir fortfahren, müssen wir das Tool Certbot und ein SSL-Zertifikat für unsere Domain installieren.
Um Certbot zu installieren, verwenden wir den Snapd-Paketinstaller. Snapd enthält immer die neueste stabile Version von Certbot und du solltest diese verwenden.
Das Snapd-Tool benötigt das Epel-Repository, um zu funktionieren.
$ sudo dnf install epel-release -y
Wir werden Snapd verwenden, um Certbot zu installieren. Installiere Snapd.
$ sudo dnf install snapd -y
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd.socket --now
Erstelle die notwendigen Links, damit Snapd funktioniert.
$ sudo ln -s /var/lib/snapd/snap /snap $ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
Stelle sicher, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core $ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden Befehl sicher, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Erstelle ein SSL-Zertifikat.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d jupyterlab.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/jupyterlab.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 7 – Nginx konfigurieren
Erstelle und öffne die Datei /etc/nginx/conf.d/jupyterlab.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/jupyterlab.conf
Füge den folgenden Code in die Datei jupyterlab.conf ein. Ersetze alle Instanzen von jupyterlab.example.com durch deine Domain.
## enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name jupyterlab.example.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name jupyterlab.example.com;
access_log /var/log/nginx/jupyterlab.access.log;
error_log /var/log/nginx/jupyterlab.error.log;
client_max_body_size 20m;
http2_push_preload on; # Enable HTTP/2 Server Push
ssl_certificate /etc/letsencrypt/live/jupyterlab.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/jupyterlab.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/jupyterlab.example.com/chain.pem;
ssl_session_timeout 1d;
# Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
ssl_protocols TLSv1.2 TLSv1.3;
# Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
# prevent replay attacks.
#
# @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
ssl_early_data on;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
ssl_prefer_server_ciphers on;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
# OCSP Stapling ---
# fetch OCSP records from URL in ssl_certificate and cache them
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
add_header X-Early-Data $tls1_3_early_data;
location / {
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $host;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $connection_upgrade;
proxy_set_header X-Scheme $scheme;
proxy_buffering off;
proxy_set_header X-Forwarded-Proto https;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass http://127.0.0.1:8888;
}
}
# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
"~." $ssl_early_data;
default "";
}
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
Die obige Konfiguration leitet alle HTTP-Anfragen auf HTTPS um und dient als Proxy für den JupyterLab-Dienst, um ihn über deine Domain zu bedienen.
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe deine Nginx-Konfiguration.
$ sudo nginx -t
Wenn du keine Fehler siehst, bist du startklar. Lade den Nginx-Server neu.
$ sudo systemctl reload nginx
Du kannst jetzt auf JupyterLab zugreifen, indem du die URL https://jupyterlab.example.com in deinem Browser aufrufst.
Fazit
Damit ist unsere Anleitung zur Installation und Konfiguration von JupyterLab auf einem Rocky Linux 9 Server und zur Nutzung des Nginx-Proxyservers abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.