🥇 Jupyter auf die LXD-Orbit bringen

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.

Navigation

Der Plan zum Start ins All
Installation und Konfiguration des Basissystems
Installation der grundlegenden Software und Systemkonfiguration
Installation und Konfiguration von JupyterLab
Daten mit dem Host teilen
Hallo, Welt!
Python erweitern
Module in JupyterLab testen
Was noch?

Der Plan zum Start ins All ^

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:

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.
disk — 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:

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:

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:

Jupyter Notebook — http://10.0.5.5:8888/tree
Jupyter Lab — http://10.0.5.5:8888/lab

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:

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:

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