ProHoster > Blog > Administration > Bringen Sie Jupyter auf die LXD-Orbit

Bringen Sie Jupyter auf die LXD-Orbit

Haben Sie schon einmal mit Code oder Systemtools in Linux experimentiert, ohne sich um das Basissystem sorgen zu mĂŒssen und das gesamte System bei einem Fehler, der mit Root-Rechten ausgefĂŒhrt werden muss, zu gefĂ€hrden?

Was ist, wenn Sie beispielsweise einen gesamten Cluster von verschiedenen Microservices auf einem einzigen Rechner testen oder starten mĂŒssen? Hundert oder sogar tausend?

Mit virtuellen Maschinen, die von einem Hypervisor verwaltet werden, können solche Aufgaben möglicherweise gelöst werden, aber zu welchem Preis? Ein Container in LXD basierend auf der Alpine Linux-Distribution benötigt minimal nur 7,60 MB RAM, und der Root-Bereich benötigt nach dem Start 9,5 MB! Wie finden Sie das, Elon Musk? Ich empfehle Ihnen, sich mit den Grundfunktionen von LXD — dem Containermanagementsystem in Linux — vertraut zu machen.

Nachdem wir nun eine gute Vorstellung davon haben, was LXD-Container sind, lass uns weitermachen und darĂŒber nachdenken, was wĂ€re, wenn es so eine Plattform gĂ€be, auf der man sicher Code fĂŒr den Host ausfĂŒhren, Diagramme erstellen und UI-Widgets dynamisch (interaktiv) mit deinem Code verbinden könnte – vielleicht mit Text und toller Formatierung? Etwas in der Art eines interaktiven Blogs? Wow... Ich möchte das! Ich möchte das! 🙂

Schau hinter den Kulissen, wo wir im Container starten werden JupyterLab – die nĂ€chste Generation der BenutzeroberflĂ€che anstelle des veralteten Jupyter Notebooks, und wir werden Python-Module installieren wie NumPy, Pandas, Matplotlib, IPyWidgets die all das oben Genannte ermöglichen und alles in einer speziellen Datei – einem IPython-Notebook – speichern.

Bringen Sie Jupyter auf die LXD-Orbit

Der Plan zum Start ins All ^

Bringen Sie Jupyter auf die LXD-Orbit

Lass uns einen kurzen Aktionsplan skizzieren, um die oben dargestellte Struktur einfacher umzusetzen:

  • Wir installieren und starten einen Container basierend auf der Distribution Alpine Linux. Wir werden dieses Distribution verwenden, da sie auf Minimalismus ausgelegt ist und nur die notwendigste Software installieren, ohne alles Weitere.
  • Wir fĂŒgen dem Container eine zusĂ€tzliche virtuelle Festplatte hinzu, der wir den Namen — hostfs geben und sie in das Wurzel-Dateisystem einbinden. Diese Festplatte ermöglicht es, Dateien vom Host aus einem bestimmten Verzeichnis innerhalb des Containers zu verwenden. Damit bleiben die Daten unabhĂ€ngig vom Container. Im Falle der Löschung des Containers bleiben die Daten auf dem Host. Dieses Schema ist auch nĂŒtzlich, um Daten zwischen mehreren Containern zu teilen, ohne die standardmĂ€ĂŸigen Netzwerkmechanismen des Container-Distributions zu verwenden.
  • Wir installieren Bash, sudo, die notwendigen Bibliotheken, und fĂŒgen einen Systembenutzer hinzu und konfigurieren ihn.
  • Wir installieren Python, die Module und kompilieren die dazugehörigen BinĂ€rabhĂ€ngigkeiten.
  • Wir installieren und starten JupyterLab, gestalten das Erscheinungsbild und installieren Erweiterungen dafĂŒr.

In diesem Artikel beginnen wir mit dem Start des Containers und lassen die Installation und Konfiguration von LXD außen vor; all dies finden Sie in einem anderen Artikel — Die Grundfunktionen von LXD — dem Container-System in Linux.

Installation und Konfiguration des Basissystems ^

Wir erstellen den Container mit dem Befehl, in dem wir das Abbild angeben — alpine3, die ID fĂŒr den Container — jupyterlab und bei Bedarf Konfigurationsprofile:

lxc init alpine3 jupyterlab --profile=default --profile=hddroot

Hier verwende ich ein Konfigurationsprofil hddroot das angibt, einen Container mit einem Root-Volume in Storage-Pool auf einer physischen HDD zu erstellen:

lxc profile show hddroot

config: {}
beschreibung: ""
gerÀte:
  root:
    pfad: /
    pool: hddpool
    typ: disk
name: hddroot
used_by: []
lxc storage show hddpool

config:
  size: 10GB
  source: /dev/loop1
  volatile.initial_source: /dev/loop1
description: ""
name: hddpool
driver: btrfs
used_by:
- /1.0/images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
- /1.0/profiles/hddroot
status: Created
locations:
- none

Das gibt mir die Möglichkeit, mit Containern auf der HDD zu experimentieren und Ressourcen des SSD-Laufwerks zu schonen, das ich ebenfalls in meinem System habe 🙂 fĂŒr das ich ein separates Konfigurationsprofil erstellt habe. ssdroot.

Nach der Erstellung befindet sich der Container im Zustand STOPPED, daher mĂŒssen wir ihn starten, indem wir das Init-System darin ausfĂŒhren:

lxc start jupyterlab

Lassen Sie uns die Liste der Container in LXD ausgeben, indem wir den SchlĂŒssel verwenden, -c der angibt, welche cSpalten auf dem Bildschirm angezeigt werden:

lxc list -c ns4b
+------------+---------+-------------------+--------------+
|    NAME    |  STATE  |       IPV4        | STORAGE POOL |
+------------+---------+-------------------+--------------+
| jupyterlab | RUNNING | 10.0.5.198 (eth0) | hddpool      |
+------------+---------+-------------------+--------------+

Bei der Erstellung des Containers wurde die IP-Adresse zufĂ€llig ausgewĂ€hlt, da wir ein Konfigurationsprofil verwendet haben. default der zuvor im Artikel konfiguriert wurde Die Grundfunktionen von LXD — dem Container-System in Linux.

Wir werden diese IP-Adresse durch eine einprĂ€gsamere ersetzen, indem wir ein Netzwerk-Interface auf Container-Ebene erstellen, statt wie derzeit auf Konfigurationsebene. Dies ist nicht zwingend erforderlich, Sie können es auch ĂŒberspringen.

Erstellen eines Netzwerk-Interfaces eth0 das wir mit dem Switch (Netzwerk-BrĂŒcke) verknĂŒpfen lxdbr0 in dem wir NAT gemĂ€ĂŸ dem vorherigen Artikel aktiviert haben, sodass der Container jetzt Zugang zum Internet hat; außerdem weisen wir dem Interface eine statische IP-Adresse zu — 10.0.5.5:

lxc config device add jupyterlab eth0 nic name=eth0 nictype=bridged parent=lxdbr0 ipv4.address=10.0.5.5

Nach dem HinzufĂŒgen des GerĂ€ts muss der Container neu gestartet werden:

lxc restart jupyterlab

ÜberprĂŒfen Sie den Status des Containers:

lxc list -c ns4b
+------------+---------+------------------+--------------+
|    NAME    |  STATE  |       IPV4       | STORAGE POOL |
+------------+---------+------------------+--------------+
| jupyterlab | RUNNING | 10.0.5.5 (eth0)  | hddpool      |
+------------+---------+------------------+--------------+

Installation der grundlegenden Software und Systemkonfiguration ^

FĂŒr die Verwaltung unseres Containers muss die folgende Software installiert werden:

Package
Beschreibung

bash
Die GNU Bourne Again Shell

bash-completion
Programmierbare VervollstĂ€ndigung fĂŒr die Bash-Shell

sudo
Bestimmten Benutzern die Möglichkeit geben, einige Befehle als Root auszufĂŒhren

shadow
Suite fĂŒr Passwort- und Kontoverwaltung mit UnterstĂŒtzung fĂŒr Schatten-Dateien und PAM

tzdata
Ressourcen fĂŒr Zeitzonen- und Sommerzeitdaten

nano
Pico-Editor-Klon mit Verbesserungen

ZusĂ€tzlich können Sie die UnterstĂŒtzung des man-pages-Systems installieren, indem Sie die folgenden Pakete installieren — man man-pages mdocml-apropos less

lxc exec jupyterlab -- apk add bash bash-completion sudo shadow tzdata nano

Lassen Sie uns die Befehle und Optionen, die wir verwendet haben, genauer betrachten:

  • lxc — Aufruf des LXD-Clients
  • exec — Methode des LXD-Clients, die einen Befehl im Container ausfĂŒhrt
  • jupyterlab — Container-ID
  • -- — Besonderer SchlĂŒssel, der angibt, dass die weiteren Optionen nicht als SchlĂŒssel interpretiert werden sollen lxc und die gesamte verbleibende Zeile unverĂ€ndert an den Container ĂŒbergeben wird
  • apk — Paketmanager der Alpine Linux-Distribution
  • add — Methode des Paketmanagers, die die nach dem Befehl angegebenen Pakete installiert

Als NĂ€chstes stellen wir die Zeitzone im System ein Europe/Moscow:

lxc exec jupyterlab -- cp /usr/share/zoneinfo/Europe/Moscow /etc/localtime

Nach der Einstellung der Zeitzone ist das Paket tzdata im System nicht mehr erforderlich, es nimmt Speicherplatz ein, also entfernen wir es:

lxc exec jupyterlab -- apk del tzdata

ÜberprĂŒfen Sie die Zeitzone:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Um die Einrichtung von Bash fĂŒr neue Benutzer im Container effizienter zu gestalten, kopieren wir die bereits vorbereiteten Skel-Dateien vom Hostsystem in den Container. So wird Bash im Container interaktiv gestaltet. Mein Hostsystem ist Manjaro Linux, und die zu kopierenden Dateien /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors sind grundsĂ€tzlich mit Alpine Linux kompatibel und sollten keine kritischen Probleme verursachen. Dennoch könnte Ihr System einen anderen Distributionstyp verwenden, und in diesem Fall mĂŒssen Sie selbst herausfinden, wie Sie eventuell auftretende Probleme beim Start von Bash im Container beheben.

Wir kopieren die Skel-Dateien in den Container. Der SchlĂŒssel --create-dirs erstellt die erforderlichen Verzeichnisse, falls diese nicht existieren:

lxc file push /etc/skel/.bash_profile jupyterlab/etc/skel/.bash_profile --create-dirs
lxc file push /etc/skel/.bashrc jupyterlab/etc/skel/.bashrc
lxc file push /etc/skel/.dir_colors jupyterlab/etc/skel/.dir_colors

FĂŒr den bereits existierenden Root-Benutzer kopieren wir die gerade in den Container ĂŒbertragenen Skel-Dateien in das Home-Verzeichnis:

lxc exec jupyterlab -- cp /etc/skel/.bash_profile /root/.bash_profile
lxc exec jupyterlab -- cp /etc/skel/.bashrc /root/.bashrc
lxc exec jupyterlab -- cp /etc/skel/.dir_colors /root/.dir_colors

In Alpine Linux wird die Standard-Shell fĂŒr Benutzer eingestellt, /bin/shwir Ă€ndern sie bei root dem Benutzer in Bash:

lxc exec jupyterlab -- usermod --shell=/bin/bash root

Um root Der Benutzer hatte noch kein Passwort, er muss ein Passwort festlegen. Der nĂ€chste Befehl generiert und setzt ein neues zufĂ€lliges Passwort, das Sie nach der AusfĂŒhrung im Konsolenbildschirm sehen werden:

lxc exec jupyterlab -- /bin/bash -c "PASSWD=$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 12); echo "root:$PASSWD" | chpasswd && echo "Neues Passwort: $PASSWD""

Neues Passwort: sFiXEvBswuWA

Außerdem erstellen wir einen neuen Systembenutzer — jupyter fĂŒr den wir spĂ€ter konfigurieren werden JupyterLab:

lxc exec jupyterlab -- useradd --create-home --shell=/bin/bash jupyter

Wir generieren und setzen ihm ein Passwort:

lxc exec jupyterlab -- /bin/bash -c "PASSWD=$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 12); echo "jupyter:$PASSWD" | chpasswd && echo "Neues Passwort: $PASSWD""

Neues Passwort: ZIcbzWrF8tki

Als nĂ€chstes fĂŒhren wir zwei Befehle aus, der erste erstellt eine Systemgruppe sudo, der zweite fĂŒgt den Benutzer hinzu jupyter:

lxc exec jupyterlab -- groupadd --system sudo
lxc exec jupyterlab -- groupmems --group sudo --add jupyter

Sehen wir uns an, in welche Gruppen der Benutzer gehört jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Alles okay, machen wir weiter.

Erlauben wir allen Benutzern, die zur Gruppe gehören, sudo den Befehl zu verwenden sudo. Dazu fĂŒhren Sie das folgende Skript aus, das sed die Zeile des Parameters in der Konfigurationsdatei entkommentiert /etc/sudoers:

lxc exec jupyterlab -- /bin/bash -c "sed --in-place -e '/^#[ t]*%sudo[ t]*ALL=(ALL)[ t]*ALL$/ s/^[# ]*//' /etc/sudoers"

Installation und Konfiguration von JupyterLab ^

JupyterLab ist eine Python-Anwendung, daher mĂŒssen wir zuerst diesen Interpreter installieren. Außerdem, JupyterLab werden wir mit dem Python-Paketmanager installieren, pipnicht mit dem systemeigenen, da er in der systemeigenen Repository veraltet sein könnte. Deshalb mĂŒssen wir die AbhĂ€ngigkeiten manuell bereitstellen, indem wir folgende Pakete installieren — python3 python3-dev gcc libc-dev zeromq-dev:

lxc exec jupyterlab -- apk add python3 python3-dev gcc libc-dev zeromq-dev

Lassen Sie uns die Python-Module und den Paketmanager pip auf die neueste Version aktualisieren:

lxc exec jupyterlab -- python3 -m pip install --upgrade pip setuptools wheel

Installieren Sie JupyterLab ĂŒber den Paketmanager pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Da die Erweiterungen in JupyterLab experimentell sind und nicht offiziell mit dem Paket jupyterlab geliefert werden, mĂŒssen wir dies manuell installieren und konfigurieren.

Lassen Sie uns NodeJS und den Paketmanager dafĂŒr — NPM installieren, da JupyterLab sie fĂŒr ihre Erweiterungen benötigt:

lxc exec jupyterlab -- apk add nodejs npm

Damit die Erweiterungen von JupyterLab die wir installieren, funktionieren, mĂŒssen sie im Benutzerverzeichnis installiert werden, da die Anwendung als Benutzer ausgefĂŒhrt wird. jupyter. Das Problem ist, dass es keinen Parameter im Startbefehl gibt, mit dem ein Verzeichnis ĂŒbergeben werden könnte; die Anwendung erkennt nur die Umgebungsvariable, die wir definieren mĂŒssen. Daher werden wir den Exportbefehl fĂŒr die Variable festlegen. JUPYTERLAB_DIR in der Benutzerumgebung jupyter, in die Datei .bashrc, die bei jedem Benutzeranmelden ausgefĂŒhrt wird:

lxc exec jupyterlab -- su -l jupyter -c "echo -e "nexport JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab" >> .bashrc"

Mit dem nĂ€chsten Befehl installieren wir eine spezielle Erweiterung – den Erweiterungsmanager in JupyterLab:

lxc exec jupyterlab -- su -l jupyter -c "export JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab; jupyter labextension install --no-build @jupyter-widgets/jupyterlab-manager"

Jetzt ist alles bereit fĂŒr den ersten Start JupyterLab, aber wir können noch einige nĂŒtzliche Erweiterungen installieren:

  • toc — Inhaltsverzeichnis, generiert eine Liste von Überschriften im Artikel/Notizbuch
  • jupyterlab-horizon-theme — UI-Design-Thema
  • jupyterlab_neon_theme — UI-Design-Thema
  • jupyterlab-ubu-theme — Ein weiteres Design-Thema vom Autor dieses Artikels 🙂 Aber in diesem Fall wird die Installation aus dem GitHub-Repository angezeigt.

FĂŒhren Sie also nacheinander die folgenden Befehle aus, um diese Erweiterungen zu installieren:

lxc exec jupyterlab -- su -l jupyter -c "export JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab; jupyter labextension install --no-build @jupyterlab/toc @mohirio/jupyterlab-horizon-theme @yeebc/jupyterlab_neon_theme"
lxc exec jupyterlab -- su -l jupyter -c "wget -c https://github.com/microcoder/jupyterlab-ubu-theme/archive/master.zip"
lxc exec jupyterlab -- su -l jupyter -c "unzip -q master.zip && rm master.zip"
lxc exec jupyterlab -- su -l jupyter -c "export JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab; jupyter labextension install --no-build jupyterlab-ubu-theme-master"
lxc exec jupyterlab -- su -l jupyter -c "rm -r jupyterlab-ubu-theme-master"

Nach der Installation der Erweiterungen mĂŒssen wir sie kompilieren, da wir zuvor bei der Installation den SchlĂŒssel angegeben haben --no-build um Zeit zu sparen. Jetzt können wir den Prozess erheblich beschleunigen, indem wir sie zusammen auf einmal kompilieren:

lxc exec jupyterlab -- su -l jupyter -c "export JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab; jupyter lab build"

FĂŒhren Sie jetzt die folgenden zwei Befehle fĂŒr den ersten Start aus JupyterLab. Es wĂ€re möglich, es mit einem Befehl zu starten, aber in diesem Fall wird der Startbefehl, den man sich merken sollte, im Bash des Containers gespeichert und nicht auf dem Host, wo ohnehin bereits viele Befehle in der Historie stehen 🙂

Loggen Sie sich im Container als Benutzer ein jupyter:

lxc exec jupyterlab -- su -l jupyter

FĂŒhren Sie dann aus JupyterLab mit den angegebenen SchlĂŒsseln und Parametern:

[jupyter@jupyterlab ~]$ jupyter lab --ip=0.0.0.0 --no-browser

Öffnen Sie Ihren Webbrowser und gehen Sie zu der Adresse http://10.0.5.5:8888 und geben Sie auf der sich öffnenden Seite ein Token fĂŒr den Zugriff ein, den Sie in der Konsole sehen werden. Kopieren Sie ihn und fĂŒgen Sie ihn auf der Seite ein, und klicken Sie dann auf Anmelden. Nach der Anmeldung gehen Sie im linken MenĂŒ der Erweiterungen, wie im folgenden Bild gezeigt, wo Sie beim Aktivieren des Erweiterungsmanagers aufgefordert werden, das Sicherheitsrisiko durch die Installation von Erweiterungen von Drittanbietern zu ĂŒbernehmen, fĂŒr die das Team JupyterLab-Entwicklung keine Verantwortung ĂŒbernimmt:

Bringen Sie Jupyter auf die LXD-Orbit

Wir isolieren dies jedoch vollstĂ€ndig JupyterLab und platzieren es in einem Container, damit Drittanbieterverweiterungen, die NodeJS erfordern und verwenden, zumindest keine Daten auf der Festplatte stehlen können, außer denjenigen, die wir innerhalb des Containers öffnen. Es wird schwierig sein, auf Ihre privaten Dokumente auf dem Host zuzugreifen /home aus Prozessen im Container, und selbst wenn es gelingt, benötigt man dafĂŒr Zugriffsrechte auf die Dateien im Wirtssystem, da wir den Container in unprivilegiertem Modus. Basierend auf diesen Informationen können Sie das Risiko der Aktivierung von Erweiterungen in JupyterLab.

Die erstellten IPython-Notebooks (Seiten in JupyterLab) werden jetzt im Heimatverzeichnis des Benutzers erstellt — /home/jupyter, aber wir planen, die Daten zwischen dem Host und dem Container zu teilen. Bitte kehren Sie zur Konsole zurĂŒck und stoppen Sie JupyterLab indem Sie die Hotkey-Taste drĂŒcken — CTRL+C und auf die Anfrage antworten. y Trennen Sie dann die interaktive Benutzersitzung jupyter indem Sie den Hotkey verwenden CTRL+D.

Daten mit dem Host teilen ^

Um die Daten mit dem Host zu teilen, mĂŒssen Sie im Container ein GerĂ€t erstellen, das dies ermöglicht. FĂŒhren Sie dazu den folgenden Befehl aus, wobei Sie die folgenden SchlĂŒssel angeben:

  • lxc config device add — Dieser Befehl fĂŒgt die GerĂ€tekonfiguration hinzu.
  • jupyter — Identifikator des Containers, in den die Konfiguration hinzugefĂŒgt wird.
  • hostfs — Identifikator des GerĂ€ts. Sie können einen beliebigen Namen festlegen.
  • Festplatte — Gibt den GerĂ€tetyp an.
  • der Pfad. — Gibt den Pfad im Container an, wo LXD dieses GerĂ€t einhĂ€ngt.
  • source — Gibt die Quelle an, den Pfad zum Verzeichnis auf dem Host, den Sie mit dem Container teilen möchten. Geben Sie den Pfad entsprechend Ihren Vorlieben an.
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

FĂŒr das Verzeichnis /home/dv/projects/ipython-notebooks muss das Containerbenutzerkonto, das derzeit die UID hat, gleich SubUID + UID, siehe Kapitel Sicherheit. Containerprivilegien im Artikel Die Grundfunktionen von LXD — dem Container-System in Linux.

Wir setzen die Berechtigung auf dem Host, wo der Containerbenutzer EigentĂŒmer sein wird. jupyter, und die Variable $USER wird Ihren Host-Benutzer als Gruppe angeben:

sudo chown 1001000:$USER /home/dv/projects/ipython-notebooks

Hallo, Welt! ^

Wenn Sie noch eine Konsolensitzung im Container geöffnet haben mit JupyterLab, starten Sie diese mit dem neuen SchlĂŒssel neu --notebook-dir und geben Sie den Wert /mnt/hostfs als Pfad zum Wurzelverzeichnis der Notebooks im Container an, fĂŒr das GerĂ€t, das wir im vorherigen Schritt erstellt haben:

jupyter lab --ip=0.0.0.0 --no-browser --notebook-dir=/mnt/hostfs

Gehen Sie dann zur Seite http://10.0.5.5:8888 und erstellen Sie Ihr erstes Notebook, indem Sie auf die SchaltflÀche auf der Seite klicken, wie im Bild unten gezeigt:

Bringen Sie Jupyter auf die LXD-Orbit

Geben Sie dann im Feld auf der Seite den Python-Code ein, der die klassische Hallo Welt!ausgeben wird. DrĂŒcken Sie nach der Eingabe CTRL+ENTER oder die SchaltflĂ€che „Play“ in der oberen Symbolleiste, damit JupyterLab dies ausfĂŒhrt:

Bringen Sie Jupyter auf die LXD-Orbit

Damit ist fast alles bereit zur Nutzung, aber es wird nicht spannend sein, wenn wir keine zusĂ€tzlichen Python-Module (vollwertige Anwendungen) installieren, die die Standardfunktionen von Python erheblich erweitern. JupyterLab, also machen wir weiter 🙂

P.S. Interessant ist, dass die alte Implementierung Jupyter unter dem Codenamen Jupyter Notebook nirgendwo hingegangen ist und parallel existiert. JupyterLab. Um zur alten Version zu gelangen, fĂŒgen Sie der Adresse den Suffix hinzu./tree, und der Übergang zur neuen Version erfolgt mit dem Suffix. /lab, aber es ist nicht erforderlich, diesen anzugeben:

Python erweitern ^

In diesem Abschnitt installieren wir leistungsstarke Python-Module wie NumPy, Pandas, Matplotlib, IPyWidgets deren Ergebnisse in die Notebooks integriert werden. JupyterLab.

Bevor wir die genannten Python-Module ĂŒber den Paketmanager installieren, pip mĂŒssen wir zunĂ€chst die SystemabhĂ€ngigkeiten in Alpine Linux klĂ€ren:

  • g++ — Wird zur Kompilierung der Module benötigt, da einige von ihnen in der Sprache C++ realisiert sind und zur Laufzeit als BinĂ€rmodule an Python angeschlossen werden.
  • freetype-dev — AbhĂ€ngigkeit fĂŒr das Python-Modul. Matplotlib

AbhÀngigkeiten installieren:

lxc exec jupyterlab -- apk add g++ freetype-dev

Es gibt ein Problem: Im aktuellen Zustand der Alpine Linux-Distribution kann die neue Version von NumPy nicht kompiliert werden, ein Kompilierungsfehler tritt auf, den ich nicht lösen konnte:

FEHLER: Konnte keine Wheels fĂŒr numpy erstellen, die PEP 517 verwenden und nicht direkt installiert werden können.

Darum installieren wir dieses Modul als Systempaket, das bereits eine vorkompilierte Version bereitstellt, die jedoch etwas Ă€lter ist als die aktuell auf der Website verfĂŒgbare:

lxc exec jupyterlab -- apk add py3-numpy py3-numpy-dev

Dann installieren wir die Python-Module ĂŒber den Paketmanager. pip. Bitte haben Sie Geduld, da einige Module kompiliert werden und dies einige Minuten dauern kann. Auf meinem Computer hat die Kompilierung etwa 15 Minuten gedauert:

lxc exec jupyterlab -- python3 -m pip install pandas ipywidgets matplotlib

Wir bereinigen die Installations-Caches:

lxc exec jupyterlab -- rm -rf /home/*/.cache/pip/*
lxc exec jupyterlab -- rm -rf /root/.cache/pip/*

Module in JupyterLab testen ^

Wenn Sie einen JupyterLab, starten Sie ihn neu, damit die neuen installierten Module aktiviert werden. DrĂŒcken Sie dazu in der Konsolensitzung CTRL+C dort, wo er lĂ€uft, und geben Sie ein y auf die Stop-Anfrage, und starten Sie ihn dann erneut JupyterLab , indem Sie die AufwĂ€rtspfeiltaste auf Ihrer Tastatur drĂŒcken, um den Befehl nicht erneut eingeben zu mĂŒssen und dann Enter um zu starten:

jupyter lab --ip=0.0.0.0 --no-browser --notebook-dir=/mnt/hostfs

Gehen Sie zur Seite http://10.0.5.5:8888/lab oder aktualisieren Sie die Seite im Browser und geben Sie dann den folgenden Code in eine neue Notebook-Zelle ein:

%matplotlib inline

from ipywidgets import interactive
import matplotlib.pyplot as plt
import numpy as np

def f(m, b):
    plt.figure(2)
    x = np.linspace(-10, 10, num=1000)
    plt.plot(x, m * x + b)
    plt.ylim(-5, 5)
    plt.show()

interactive_plot = interactive(f, m=(-2.0, 2.0), b=(-3, 3, 0.5))
output = interactive_plot.children[-1]
output.layout.height = '350px'
interactive_plot

Sie sollten ein Ergebnis wie im unteren Bild erhalten, wobei IPyWidgets ein UI-Element auf der Seite generiert wird, das interaktiv mit dem Quellcode interagiert, sowie Matplotlib gibt das Ergebnis des Codes als Bild in Form einer Funktionsgrafik aus:

Bringen Sie Jupyter auf die LXD-Orbit

Viele Beispiele IPyWidgets finden Sie in den Tutorials hier

Was noch? ^

Herzlichen GlĂŒckwunsch, dass Sie bis zum Ende des Artikels geblieben sind. Ich habe absichtlich das fertige Skript nicht am Ende des Artikels bereitgestellt, das man mit JupyterLab „einem Klick“ installieren könnte, um die engagierten Leser zu ermutigen 🙂 Aber das können Sie selbst tun, da Sie bereits wissen, wie, indem Sie die Befehle zu einem einzigen Bash-Skript zusammenfĂŒgen 🙂

Außerdem können Sie:

  • einen Netzwerkname fĂŒr den Container anstelle der IP-Adresse festlegen, indem Sie ihn einfach /etc/hosts eingeben und die Adresse im Browser aufrufen http://jupyter.local:8888
  • mit den RessourcenbeschrĂ€nkungen fĂŒr den Container experimentieren; dazu lesen Sie das Kapitel ĂŒber die grundlegenden Möglichkeiten von LXD oder erhalten Sie weitere Informationen auf der LXD-Entwicklerseite.
  • Das Design Ă€ndern:

Bringen Sie Jupyter auf die LXD-Orbit

Und vieles mehr können Sie tun! Das ist alles. Ich wĂŒnsche Ihnen viel Erfolg!

UPDATE: 15.04.2020 18:30 — Fehler im Kapitel „Hello, World!“ behoben
UPDATE: 16.04.2020 10:00 — Text im Abschnitt zur Aktivierung des Erweiterungsmanagers angepasst und ergĂ€nzt JupyterLab
UPDATE: 16.04.2020 10:40 — Fehler im Text korrigiert und das Kapitel „Installation der Basissoftware und Einrichtung des Systems“ etwas verbessert

Quelle: habr.com

Erwerben Sie zuverlĂ€ssiges Hosting fĂŒr Websites mit DDoS-Schutz, VPS VDS-Server đŸ”„ Kaufen Sie zuverlĂ€ssiges Hosting fĂŒr Websites mit DDoS-Schutz, VPS VDS-Server | ProHoster