ProHoster > Blog > Administration > Wir starten Jupyter auf die LXD-Umgebung

Wir starten Jupyter auf die LXD-Umgebung

Haben Sie jemals mit Code oder Systemtools in Linux experimentiert, ohne sich um das Grundsystem zu sorgen und alles im Falle eines Fehlers, der mit Root-Rechten ausgefĂŒhrt werden sollte, zu ruinieren?

Wie sieht es aus, wenn man beispielsweise einen ganzen Cluster von verschiedenen Mikrodiensten auf einer Maschine testen oder starten muss? Hundert oder sogar tausend?

Mit virtuellen Maschinen können solche Aufgaben, die von einem Hypervisor verwaltet werden, möglicherweise gelöst werden, aber zu welchem Preis? Ein Beispiel: Ein Container in LXD auf der Basis der Alpine Linux-Distribution verbraucht minimal nur 7.60MB RAM, und wo das Root-Verzeichnis nach dem Start nur 9.5MB! Was hĂ€ltst du davon, Elon Musk? Ich empfehle, sich mit den Basisfunktionen von LXD — einem Containermanagement-System in Linux, vertraut zu machen.

Nachdem wir insgesamt klargestellt haben, was LXD-Container sind, lass uns weiterdenken und herausfinden, was wĂ€re, wenn es eine Plattform-Kombination gĂ€be, auf der man sicher Code fĂŒr den Host ausfĂŒhren, Diagramme generieren, UI-Widgets dynamisch (interaktiv) mit deinem Code verknĂŒpfen könnte, und den Code mit Text, mit Blackjack... und Formatierung ergĂ€nzen? Etwas wie ein interaktiver Blog? Wow... Ich will! Ich will! 🙂

Schau dir den Abschnitt unten an, wo wir in einem Container JupyterLab — der nĂ€chsten Generation der BenutzeroberflĂ€che anstelle des veralteten Jupyter Notebooks — starten und Module wie NumPy, Pandas, Matplotlib, IPyWidgets installieren, die alles oben Genannte ermöglichen und das alles in einer speziellen Datei — einem IPython-Notebook — speichern.

Wir starten Jupyter auf die LXD-Umgebung

Startplan fĂŒr den Orbit ^

Wir starten Jupyter auf die LXD-Umgebung

Lass uns einen kurzen Plan erstellen, damit wir das oben genannte Schema einfacher umsetzen können:

  • Wir werden einen Container auf Basis der Distribution installieren Alpine Linux. Wir werden diese Distribution verwenden, da sie auf Minimaleffizienz ausgerichtet ist und wir nur die notwendigste Software installieren werden, nichts ÜberflĂŒssiges.
  • Wir fĂŒgen dem Container eine zusĂ€tzliche virtuelle Festplatte hinzu, die wir benennen werden — hostfs und wir montieren es an das Root-Dateisystem. Diese Festplatte ermöglicht es, Dateien auf dem Host aus dem angegebenen Verzeichnis innerhalb des Containers zu nutzen. Somit sind die Daten unabhĂ€ngig vom Container. Im Falle der Löschung des Containers bleiben die Daten auf dem Host erhalten. Außerdem ist dieses Schema nĂŒtzlich, um bestimmte Daten zwischen vielen Containern zu teilen, ohne die standardmĂ€ĂŸigen Netzwerkmöglichkeiten des Container-Distributionssystems zu verwenden.
  • Wir installieren Bash, sudo, die erforderlichen Bibliotheken und fĂŒgen den Systembenutzer hinzu und konfigurieren ihn.
  • Wir installieren Python, die Module und kompilieren die BinĂ€rabhĂ€ngigkeiten dafĂŒr.
  • Wir installieren und starten. JupyterLab, gestalten das Aussehen und installieren Erweiterungen dafĂŒr.

In diesem Artikel werden wir mit dem Starten des Containers beginnen und die Installation und Konfiguration von LXD nicht betrachten; all dies finden Sie in einem anderen Artikel — Grundlegende Funktionen 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 Identifikation fĂŒr den Container — jupyterlab und bei Bedarf die Konfigurationsprofile:

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

Hier verwende ich ein Konfigurationsprofil, hddroot das angibt, dass der Container mit einer Root-Partition in Storage Pool auf einer physischen HDD verfĂŒgbar gemacht wird:

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 die Ressourcen der SSD zu schonen, die ebenfalls in meinem System vorhanden ist 🙂, fĂŒr die ich ein separates Konfigurationsprofil erstellt habe. ssdroot.

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

lxc start jupyterlab

Wir zeigen die Liste der Container in LXD an, indem wir den Parameter verwenden, -c der angibt, welche cSpalten auf dem Bildschirm angezeigt werden sollen:

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

Beim Erstellen des Containers wurde die IP-Adresse zufĂ€llig ausgewĂ€hlt, da wir ein Konfigurationsprofil verwendet haben, default das zuvor in dem Artikel konfiguriert wurde, Grundlegende Funktionen 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 und nicht auf Profil-Ebene wie in der aktuellen Konfiguration erstellen. Dies ist nicht zwingend erforderlich, Sie können dies ĂŒberspringen.

Wir erstellen ein Netzwerkinterface eth0 das wir mit dem Switch (NetzwerkbrĂŒcke) verbinden lxdbr0 in dem wir NAT gemĂ€ĂŸ dem vorherigen Artikel eingeschaltet haben, wird der Container jetzt Zugang zum Internet haben, und 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 wir den Status des Containers:

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

Installation der Basissoftware und Systemkonfiguration ^

FĂŒr die Verwaltung unseres Containers mĂŒssen wir folgende Software installieren:

Package
Beschreibung

bash
Die GNU Bourne Again Shell

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

sudo
Bestimmten Benutzern erlauben, einige Befehle als Root auszufĂŒhren

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

tzdata
Quellen fĂŒr Zeitzonen- und Sommerzeitdaten

Viele haben darauf gewartet und viele haben sich dagegen ausgesprochen, aber es ist passiert: der standardmĂ€ĂŸige Konsolen-Texteditor in Fedora Workstation wird nano.
Pico-Editor-Klon mit Verbesserungen

ZusĂ€tzlich können Sie die UnterstĂŒtzung fĂŒr Man-Seiten installieren, indem Sie folgende 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, durchgehen:

  • lxc — Aufruf des LXD-Clients
  • exec — Methode des LXD-Clients, die einen Befehl im Container ausfĂŒhrt
  • jupyterlab — Container-ID
  • -- — Besondere Option, die angibt, dass die SchlĂŒssel nicht weiter als SchlĂŒssel interpretiert werden sollen lxc und den gesamten verbleibenden String so, wie er ist, an den Container ĂŒbergeben
  • apk — Paketmanager der Alpine Linux-Distribution
  • add — Methode des Paketmanagers, die die nach dem Befehl angegebenen Pakete installiert

Dann installieren wir die Zeitzone im System Europe/Moscow:

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

Nachdem die Zeitzone installiert wurde, wird das Paket tzdata im System nicht mehr benötigt, es wĂŒrde Platz beanspruchen, also entfernen wir es:

lxc exec jupyterlab -- apk del tzdata

ÜberprĂŒfen wir die Zeitzone:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Um nicht viel Zeit mit der Konfiguration von Bash fĂŒr neue Benutzer im Container zu verschwenden, werden wir in den nĂ€chsten Schritten die bereits fertigen Skel-Dateien aus dem Host-System hinein kopieren. Das wird es ermöglichen, die Bash im Container interaktiv zu gestalten. Mein Host-System ist Manjaro Linux und die kopierten Dateien /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors passen grundsĂ€tzlich zu Alpine Linux und verursachen keine kritischen Probleme, aber vielleicht haben Sie eine andere Distribution und mĂŒssen selbst herausfinden, wie Sie bei Problemen mit dem gestarteten Bash im Container vorgehen.

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

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 kopierten 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 fĂŒr Benutzer die System-Shell eingestellt /bin/sh, wir Ă€ndern sie bei root dem Benutzer auf Bash:

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

Um root der Benutzer hatte kein Passwort, er muss ein Passwort setzen. Der folgende 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 ein Passwort fĂŒr ihn:

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

Anschließend fĂŒhren wir zwei Befehle aus, der erste erstellt die Systemgruppe sudo, und 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 — in Ordnung, wir machen weiter.

Erlauben wir allen Benutzern, die in der Gruppe sind, sudo den Befehl zu verwenden sudo. Dazu fĂŒhren Sie das folgende Skript aus, das sed die Zeile des Parameters in der Konfigurationsdatei auskommentiert. /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 — dies ist eine Python-Anwendung, daher mĂŒssen wir diesen Interpreter vorher installieren. Außerdem, JupyterLab werden wir dies mit dem Python-Paketmanager installieren pip, und nicht mit dem Systempaketmanager, da er im System-Repository veraltet sein kann, und daher mĂŒssen wir manuell die AbhĂ€ngigkeiten fĂŒr ihn installieren, indem wir die folgenden Pakete installieren — python3 python3-dev gcc libc-dev zeromq-dev:

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

Wir aktualisieren die Python-Module und den Paketmanager pip auf die aktuelle Version:

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

Installation JupyterLab ĂŒber den Paketmanager pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

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

Wir werden NodeJS und den Paketmanager dafĂŒr — NPM installieren, da JupyterLab sie fĂŒr ihre Erweiterungen verwendet:

lxc exec jupyterlab -- apk add nodejs npm

Damit die Erweiterungen fĂŒr 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 wir das Verzeichnis ĂŒbergeben können, die Anwendung erkennt nur die Umgebungsvariable, und deshalb mĂŒssen wir diese festlegen. Dazu werden wir den Befehl zur Exportierung der Variable JUPYTERLAB_DIR in der Benutzerumgebung jupyter, in die Datei .bashrc, die bei jedem Login des Benutzers 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/Notebook
  • jupyterlab-horizon-theme — UI-Theme
  • jupyterlab_neon_theme — UI-Theme
  • jupyterlab-ubu-theme — Ein weiteres Theme vom Autor dieses Artikels 🙂 Aber in diesem Fall wird die Installation aus dem GitHub-Repository gezeigt.

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 beim Installieren den SchlĂŒssel --no-build zum Zeit sparen verwendet haben. Jetzt werden wir sie wesentlich schneller zusammen 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. Man könnte ihn mit einem einzigen Befehl starten, aber in diesem Fall wĂŒrde der Startbefehl, den man im Kopf behalten muss, von bash im Container gespeichert und nicht auf dem Host, wo es ohnehin genĂŒgend Befehle gibt, um sie in der Geschichte zu speichern 🙂

Melden Sie sich im Container als Benutzer an jupyter:

lxc exec jupyterlab -- su -l jupyter

FĂŒhren Sie dann aus JupyterLab mit den Keys und Parametern wie angegeben:

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

Gehen Sie im Webbrowser zu der Adresse http://10.0.5.5:8888 und geben Sie auf der sich öffnenden Seite ein token Zugriff, den Sie in der Konsole sehen werden. Kopieren Sie ihn und fĂŒgen Sie ihn auf der Seite ein, und drĂŒcken Sie dann Anmelden. Nach dem Einloggen gehen Sie links im MenĂŒ der Erweiterungen, wie im Bild unten gezeigt, wo Ihnen bei der Aktivierung des Erweiterungsmanagers Sicherheitsrisiken auferlegt werden, wenn Sie Erweiterungen von Drittanbietern installieren, fĂŒr die das Team JupyterLab-Entwicklung keine Verantwortung ĂŒbernimmt:

Wir starten Jupyter auf die LXD-Umgebung

Wir isolieren es gerade dafĂŒr vollstĂ€ndig JupyterLab und setzen es in einen Container, damit Drittanbietererweiterungen, die NodeJS benötigen und verwenden, zumindest keine Daten auf der Festplatte stehlen können, außer denjenigen, die wir innerhalb des Containers öffnen. Es ist unwahrscheinlich, dass Prozesse aus dem Container auf Ihre privaten Dokumente auf dem Host zugreifen können, und wenn doch, benötigt man dafĂŒr Berechtigungen fĂŒr die Dateien im Host-System, da wir den Container in /home nicht privilegiertem Modus . Basierend auf diesen Informationen können Sie das Risiko der Aktivierung von Erweiterungen inDie erstellten IPython-NotizbĂŒcher (Seiten in JupyterLab.

) werden jetzt im Heimatverzeichnis des Benutzers erstellt — JupyterLab, aber wir planen, die Daten zwischen Host und Container zu teilen, also kehren Sie zur Konsole zurĂŒck und stoppen Sie /home/jupyterindem Sie die Hotkey-Taste — JupyterLab und auf die Anfrage antworten. Trennen Sie dann die interaktive Benutzersitzung CTRL+C indem Sie die Hotkey-Taste ausfĂŒhren y Um Daten mit dem Host zu teilen, mĂŒssen Sie im Container ein GerĂ€t erstellen, das dies ermöglicht, und fĂŒhren Sie dazu den folgenden Befehl aus, bei dem wir die folgenden SchlĂŒssel angeben: jupyter lxc config device add CTRL+D.

Daten mit dem Host teilen ^

— Befehl fĂŒgt die GerĂ€tekonfiguration hinzu

  • — Die ID des Containers, in den die Konfiguration hinzugefĂŒgt wird — Die ID des GerĂ€ts. Sie können einen beliebigen Namen wĂ€hlen.
  • jupyter — Der Typ des GerĂ€ts wird angegeben
  • hostfs — Der Pfad im Container, zu dem LXD dieses GerĂ€t mounten wird
  • disk — Der Pfad im Container, zu dem LXD dieses GerĂ€t mounten wird
  • path — Der Pfad im Container, zu dem LXD dieses GerĂ€t mounten wird
  • source — Die Quelle, der Pfad zum Verzeichnis auf dem Host, das Sie mit dem Container teilen möchten, wird angegeben. Geben Sie den Pfad nach Ihren WĂŒnschen 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 die Berechtigung fĂŒr den Containerbenutzer, der derzeit die UID gleich hat, eingestellt werden. SubUID + UID, siehe Kapitel Sicherheit. Berechtigungen von Containern in dem Artikel Grundlegende Funktionen von LXD — dem Container-System in Linux.

Die Berechtigung auf dem Host wird gesetzt, wobei der Containerbenutzer der EigentĂŒmer ist. jupyter, und die Variable $USER zeigt Ihren Hostbenutzer als Gruppe an:

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

Hallo, Welt! ^

Wenn Sie noch eine Konsolensitzung im Container mit JupyterLab, haben, starten Sie sie mit dem neuen SchlĂŒssel neu. --notebook-dir unter Festlegung des Wertes /mnt/hostfs als Pfad zum Stamm der Notebooks im Container 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 den Button auf der Seite klicken, wie im Bild unten angegeben:

Wir starten Jupyter auf die LXD-Umgebung

Geben Sie dann im Feld auf der Seite den Python-Code ein, der die klassische 4) Wechseln Sie in das Verzeichnis, in das Sie das Beispielprojekt heruntergeladen haben:. Nach der Eingabe drĂŒcken Sie CTRL+ENTER oder die „Play“-Taste in der oberen Symbolleiste, damit JupyterLab dies ausfĂŒhrt:

Wir starten Jupyter auf die LXD-Umgebung

Fast alles ist bereit zur Benutzung, aber es wĂ€re nicht interessant, wenn wir nicht zusĂ€tzliche Python-Module (vollwertige Anwendungen) installieren, die die Standardfunktionen von Python erheblich erweitern in JupyterLab, also machen wir weiter 🙂

P.S. Interessant ist, dass die alte Implementierung Jupyter unter dem Codenamen Jupyter Notebook nicht verschwunden ist und parallel zu JupyterLabexistiert. Um zur alten Version zu wechseln, folgen Sie dem Link und fĂŒgen Sie am Ende der Adresse das Suffix hinzu./tree, wĂ€hrend der Zugang zur neuen Version mit dem Suffix erfolgt /lab, aber es ist nicht zwingend erforderlich, es anzugeben:

Die Möglichkeiten von Python erweitern ^

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

Bevor wir die aufgefĂŒhrten Python-Module ĂŒber den Paketmanager installieren, pip mĂŒssen wir zuerst systemabhĂ€ngige Anforderungen in Alpine Linux zulassen:

  • g++ — Wird fĂŒr die Kompilierung von Modulen benötigt, da einige von ihnen in der Sprache C++ implementiert sind und zur Laufzeit als BinĂ€rmodule mit Python verbunden 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: In der aktuellen Version des Alpine Linux-Distributions kann ich eine neue Version von NumPy nicht kompilieren, da ein Kompilierungsfehler auftritt, den ich nicht beheben konnte:

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

Deshalb werden wir dieses Modul als Systempaket installieren, das eine bereits kompilierte, aber etwas Ă€ltere Version bereitstellt als die derzeit auf der Website verfĂŒgbare:

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

Danach installieren wir die Python-Module ĂŒber den Paketmanager pip. Haben Sie Geduld, da einige Module kompiliert werden und dies mehrere Minuten in Anspruch nehmen kann. Auf meinem GerĂ€t dauerte die Kompilierung ca. 15 Minuten:

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

Wir leeren 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 JupyterLabausgefĂŒhrt haben, starten Sie es neu, damit die neu installierten Module aktiviert werden. DrĂŒcken Sie dazu in der Konsolensitzung CTRL+C wo es laufend ist, und geben Sie ein y bei der Abfrage zum Stoppen, und starten Sie dann wieder JupyterLab indem Sie die AufwĂ€rtstaste auf der 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 Bild unten erhalten, wo IPyWidgets ein UI-Element auf der Seite erzeugt, das interaktiv mit dem Quellcode interagiert, und auch Matplotlib das Ergebnis des Codes in Form eines Diagramms wie einer Funktion anzeigt:

Wir starten Jupyter auf die LXD-Umgebung

Viele Beispiele IPyWidgets finden Sie in den Tutorials hier

Was ist noch? ^

Gut gemacht, wenn Sie geblieben sind und bis zum Ende des Artikels gekommen sind. Ich habe absichtlich kein fertiges Skript am Ende des Artikels bereitgestellt, das JupyterLab mit 'einem Klick' installiert, um die Arbeit zu belohnen 🙂 Aber Sie können es selbst tun, da Sie bereits wissen, wie, indem Sie die Befehle in ein einzelnes Bash-Skript zusammenstellen 🙂

Außerdem können Sie:

  • einen Netzwerknamen fĂŒr den Container anstelle der IP-Adresse angeben, indem Sie ihn einfach in die /etc/hosts eingeben und die Adresse im Browser eingeben http://jupyter.local:8888
  • Mit der Ressourcenkontrolle fĂŒr den Container experimentieren, dazu lesen Sie das Kapitel ĂŒber die grundlegenden Funktionen von LXD oder erhalten Sie weitere Informationen auf der Website des Entwicklers von LXD.
  • Das Design wechseln:

Wir starten Jupyter auf die LXD-Umgebung

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

AKTUALISIERUNG: 15.04.2020 18:30 — Fehler im Kapitel „Hallo, Welt!“ behoben
AKTUALISIERUNG: 16.04.2020 10:00 — Text im Beschreibung zur Aktivierung des Erweiterungsmanagers angepasst und hinzugefĂŒgt JupyterLab
AKTUALISIERUNG: 16.04.2020 10:40 — Gefundene Fehler im Text korrigiert und das Kapitel „Installation der Basissoftware und Systemkonfiguration“ etwas verbessert

Quelle: habr.com

60GB SSD 8Gb DDR4