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.com als 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.

JupyterLab Anmeldebildschirm

Gib dein Passwort ein und klicke auf die Schaltfläche Anmelden, um die JupyterLab-Oberfläche zu öffnen.

JupyterLab Startseite

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 [email protected] -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.

Das könnte dich auch interessieren …