ProHoster > Blog > Verwaltung > Jupyter in die LXD-Umlaufbahn bringen

Jupyter in die LXD-Umlaufbahn bringen

Mussten Sie schon einmal mit Code oder Systemdienstprogrammen unter Linux experimentieren, um sich bei einem Fehler im Code, der mit Root-Rechten laufen sollte, keine Sorgen um das Basissystem zu machen und nicht alles abzureißen?

Aber was ist mit der Tatsache, dass Sie, sagen wir, einen ganzen Cluster verschiedener Microservices auf einer Maschine testen oder ausführen müssen? Hundert oder gar tausend?

Mit virtuellen Maschinen, die von einem Hypervisor verwaltet werden, können und werden solche Probleme gelöst, aber zu welchem ​​Preis? Beispielsweise verbraucht ein Container in LXD, der auf der Alpine-Linux-Distribution basiert, nur 7.60MB RAM und wo die Root-Partition nach dem Start belegt 9.5MB! Wie gefällt dir das, Elon Musk? Ich empfehle einen Check-in Grundfunktionen von LXD - einem Containersystem unter Linux

Nachdem allgemein klar geworden ist, was LXD-Container sind, gehen wir weiter und überlegen, was wäre, wenn es eine solche Harvester-Plattform gäbe, auf der Sie Code für den Host sicher ausführen, Diagramme generieren und UI-Widgets dynamisch (interaktiv) mit Ihrem Code verknüpfen könnten, Den Code mit Text mit Blackjack ergänzen... Formatierung? Eine Art interaktiver Blog? Wow... ich will es! Wollen! 🙂

Schauen Sie unter die Katze, wo wir in einem Container starten werden Jupyter-Labor - die nächste Generation der Benutzeroberfläche anstelle des veralteten Jupyter-Notebooks, und wir werden auch Python-Module installieren, wie z NumPy, Pandas, Matplotlib, IPyWidgets Dadurch können Sie alle oben aufgeführten Schritte ausführen und alles in einer speziellen Datei speichern – einem IPython-Laptop.

Jupyter in die LXD-Umlaufbahn bringen

Orbitaler Startplan ^

Jupyter in die LXD-Umlaufbahn bringen

Lassen Sie uns einen kurzen Aktionsplan skizzieren, der uns die Umsetzung des oben genannten Schemas erleichtern soll:

  • Lassen Sie uns einen Container basierend auf dem Distributionskit installieren und starten Alpines Linux. Wir werden diese Distribution verwenden, weil sie auf Minimalismus abzielt und nur die notwendigste Software darin installiert, nichts Überflüssiges.
  • Fügen wir dem Container eine zusätzliche virtuelle Festplatte hinzu und geben ihr einen Namen – hostfs und mounten Sie es im Root-Dateisystem. Dieser Datenträger ermöglicht die Nutzung von Dateien auf dem Host aus einem bestimmten Verzeichnis innerhalb des Containers. Somit sind unsere Daten unabhängig vom Container. Wird der Container gelöscht, verbleiben die Daten auf dem Host. Außerdem ist dieses Schema nützlich, um dieselben Daten zwischen vielen Containern zu teilen, ohne die Standardnetzwerkmechanismen der Containerverteilung zu verwenden.
  • Lassen Sie uns Bash, Sudo und die erforderlichen Bibliotheken installieren, einen Systembenutzer hinzufügen und konfigurieren
  • Lassen Sie uns Python und Module installieren und binäre Abhängigkeiten für sie kompilieren
  • Lassen Sie uns installieren und starten Jupyter-Labor, passen Sie das Erscheinungsbild an, installieren Sie Erweiterungen dafür.

In diesem Artikel beginnen wir mit dem Starten des Containers, die Installation und Konfiguration von LXD gehen wir nicht in Betracht, das alles finden Sie in einem anderen Artikel – Grundfunktionen von LXD – Linux-Containersystemen.

Installation und Konfiguration des Basissystems ^

Wir erstellen einen Container mit dem Befehl, in dem wir das Bild angeben - alpine3, Kennung für den Container - jupyterlab und ggf. Konfigurationsprofile:

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

Hier verwende ich ein Konfigurationsprofil hddroot Dies gibt an, dass ein Container mit einer Root-Partition erstellt werden soll Speicherpool befindet sich auf einer physischen Festplatte:

lxc profile show hddroot

config: {}
description: ""
devices:
  root:
    path: /
    pool: hddpool
    type: 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

Dies gibt mir die Möglichkeit, mit Containern auf der HDD-Festplatte zu experimentieren und so die Ressourcen der SSD-Festplatte zu schonen, die auch in meinem System verfügbar ist 🙂, für die ich ein separates Konfigurationsprofil erstellt habe ssdroot.

Nachdem der Container erstellt wurde, befindet er sich im Status STOPPED, also müssen wir es starten, indem wir das Init-System darin ausführen:

lxc start jupyterlab

Lassen Sie uns mit der Taste eine Liste der Container in LXD anzeigen -c was angibt, welches cSpaltenanzeige:

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 was zuvor im Artikel konfiguriert wurde Grundfunktionen von LXD – Linux-Containersystemen.

Wir werden diese IP-Adresse in eine einprägsamere ändern, indem wir eine Netzwerkschnittstelle auf Containerebene erstellen und nicht auf der Ebene des Konfigurationsprofils, wie es jetzt in der aktuellen Konfiguration der Fall ist. Sie müssen dies nicht tun, Sie können es auch überspringen.

Erstellen einer Netzwerkschnittstelle eth0 die wir mit dem Switch verknüpfen (Netzwerkbrücke) lxdbr0 in dem wir NAT gemäß dem vorherigen Artikel aktiviert haben und der Container nun Zugriff auf das Internet hat, außerdem weisen wir der Schnittstelle 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 eines Geräts muss der Container neu gestartet werden:

lxc restart jupyterlab

Überprüfen des Status des Containers:

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

Basissoftware installieren und System einrichten ^

Um unseren Container zu verwalten, müssen Sie folgende Software installieren:

Paket
Beschreibung

bash
Die GNU Bourne Again-Shell

Bash-Vervollständigung
Programmierbare Vervollständigung für die Bash-Shell

sudo
Geben Sie bestimmten Benutzern die Möglichkeit, einige Befehle als Root auszuführen

Schatten
Tool-Suite zur Passwort- und Kontoverwaltung mit Unterstützung für Schattendateien und PAM

tzdaten
Quellen für Zeitzonen- und Sommerzeitdaten

nano
Klon des Pico-Editors mit Verbesserungen

Darüber hinaus können Sie Unterstützung in den System-Manpages 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

Schauen wir uns die Befehle und Tasten an, die wir verwendet haben:

  • lxc — Rufen Sie den LXD-Client an
  • exec – LXD-Client-Methode, die einen Befehl im Container ausführt
  • jupyterlab — Container-ID
  • -- — Ein spezieller Schlüssel, der angibt, weitere Schlüssel nicht als Schlüssel für zu interpretieren lxc und übergeben Sie den Rest der Zeichenfolge unverändert an den Container
  • apk – Paketmanager für die Alpine-Linux-Distribution
  • add – Eine Paketmanagermethode, die nach dem Befehl angegebene Pakete installiert

Als nächstes legen wir eine Zeitzone im System fest Europe/Moscow:

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

Nach der Installation der Zeitzone wird das Paket tzdata wird im System nicht mehr benötigt, es wird Speicherplatz beanspruchen, also löschen wir es:

lxc exec jupyterlab -- apk del tzdata

Überprüfen der Zeitzone:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Um nicht viel Zeit damit zu verbringen, Bash für neue Benutzer im Container einzurichten, kopieren wir in den folgenden Schritten vorgefertigte Skel-Dateien vom Hostsystem dorthin. Dadurch können Sie Bash in einem Container interaktiv verschönern. Mein Hostsystem ist Manjaro Linux und die Dateien werden kopiert /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors Im Prinzip sind sie für Alpine Linux geeignet und verursachen keine kritischen Probleme. Möglicherweise haben Sie jedoch eine andere Distribution und müssen selbstständig herausfinden, ob beim Ausführen von Bash im Container ein Fehler vorliegt.

Kopieren Sie die Skel-Dateien in den Container. Schlüssel --create-dirs erstellt die erforderlichen 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 einen bereits vorhandenen Root-Benutzer kopieren Sie 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

Alpine Linux installiert eine System-Shell für Benutzer /bin/sh, wir werden es durch ersetzen root Benutzer in Bash:

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

Dass root Der Benutzer war nicht passwortlos, er muss ein Passwort festlegen. Der folgende Befehl generiert und legt ein neues zufälliges Passwort für ihn fest, das Sie nach seiner Ausführung auf dem Konsolenbildschirm sehen:

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

New Password: sFiXEvBswuWA

Erstellen wir außerdem einen neuen Systembenutzer – jupyter für die wir später konfigurieren werden Jupyter-Labor:

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

Lassen Sie uns ein Passwort dafür generieren und festlegen:

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

New Password: ZIcbzWrF8tki

Als nächstes führen wir zwei Befehle aus, der erste erstellt eine Systemgruppe sudo, und der zweite fügt einen Benutzer hinzu jupyter:

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

Sehen wir uns an, zu welchen Gruppen der Benutzer gehört jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Alles ist in Ordnung, lass uns weitermachen.

Alle Benutzer zulassen, die Mitglieder der Gruppe sind sudo Befehl verwenden sudo. Führen Sie dazu das folgende Skript aus: sed Kommentiert die Parameterzeile in der Konfigurationsdatei aus /etc/sudoers:

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

JupyterLab installieren und konfigurieren ^

Jupyter-Labor ist eine Python-Anwendung, daher müssen wir zuerst diesen Interpreter installieren. Auch, Jupyter-Labor Wir werden mit dem Python-Paketmanager installieren pip, und nicht das Systempaket, da es im System-Repository möglicherweise veraltet ist und wir daher die Abhängigkeiten dafür manuell auflösen müssen, 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

Lassen Sie uns die Python-Module und den Paketmanager aktualisieren pip zur aktuellen Version:

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

Setzen Jupyter-Labor über den Paketmanager pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Seit den Erweiterungen in Jupyter-Labor sind experimentell und werden nicht offiziell mit dem Jupyterlab-Paket ausgeliefert, daher müssen wir es manuell installieren und konfigurieren.

Installieren wir NodeJS und den Paketmanager dafür – NPM, seitdem Jupyter-Labor verwendet sie für seine Erweiterungen:

lxc exec jupyterlab -- apk add nodejs npm

Zu Erweiterungen für Jupyter-Labor die wir installieren werden, hat funktioniert, sie müssen im Benutzerverzeichnis installiert werden, da die Anwendung vom Benutzer gestartet wird jupyter. Das Problem besteht darin, dass es im Startbefehl keinen Parameter gibt, der an ein Verzeichnis übergeben werden kann; die Anwendung akzeptiert nur eine Umgebungsvariable und wir müssen sie daher definieren. Dazu schreiben wir den Variablenexportbefehl JUPYTERLAB_DIR in der Umgebung des Benutzers jupyter, einordnen .bashrcdie jedes Mal ausgeführt wird, wenn sich der Benutzer anmeldet:

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

Der nächste Befehl installiert eine spezielle Erweiterung – Extension Manager in Jupyter-Labor:

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 Jupyter-Labor, aber wir können trotzdem ein paar nützliche Erweiterungen installieren:

  • toc – Inhaltsverzeichnis, generiert eine Liste der Überschriften in einem Artikel/Notizbuch
  • jupyterlab-horizon-theme – UI-Theme
  • jupyterlab_neon_theme – UI-Theme
  • jupyterlab-ubu-theme - Noch eine Thema vom Autor Dieser Artikel :) Aber in diesem Fall wird die Installation aus dem GitHub-Repository angezeigt

Führen Sie daher 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 diese kompilieren, da wir zuvor bei der Installation den Schlüssel angegeben haben --no-build um Zeit zu sparen. Jetzt beschleunigen wir deutlich, indem wir sie in einem Rutsch zusammenstellen:

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

Führen Sie nun die folgenden beiden Befehle aus, um es zum ersten Mal auszuführen Jupyter-Labor. Es wäre möglich, es mit einem Befehl zu starten, aber in diesem Fall wird der Startbefehl, den Sie sich nur schwer merken können, von Bash im Container gespeichert und nicht auf dem Host, wo es bereits genügend Befehle gibt um sie in der Geschichte festzuhalten :)

Melden Sie sich als Benutzer beim Container an jupyter:

lxc exec jupyterlab -- su -l jupyter

Als nächstes führen Sie aus Jupyter-Labor mit Tasten und Parametern wie angegeben:

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

Rufen Sie die Adresse in Ihrem Webbrowser auf http://10.0.5.5:8888 und geben Sie auf der sich öffnenden Seite ein Zeichen Zugriff, den Sie in der Konsole sehen. Kopieren Sie es, fügen Sie es auf der Seite ein und klicken Sie dann Login. Gehen Sie nach der Anmeldung zum Erweiterungsmenü auf der linken Seite, wie in der Abbildung unten gezeigt. Dort werden Sie beim Aktivieren des Erweiterungsmanagers aufgefordert, Sicherheitsrisiken einzugehen, indem Sie Erweiterungen von Drittanbietern installieren, für die der Befehl gilt JupyterLab-Entwicklung ist nicht verantwortlich:

Jupyter in die LXD-Umlaufbahn bringen

Allerdings isolieren wir das Ganze Jupyter-Labor und platzieren Sie es in einem Container, damit Erweiterungen von Drittanbietern, die NodeJS erfordern und verwenden, zumindest keine anderen Daten auf der Festplatte stehlen können als diejenigen, die wir im Container öffnen. Holen Sie sich Ihre privaten Dokumente auf dem Host in /home Es ist unwahrscheinlich, dass Prozesse aus dem Container erfolgreich sind. Wenn dies der Fall ist, müssen Sie über Berechtigungen für Dateien auf dem Hostsystem verfügen, da wir den Container ausführen unprivilegierter Modus. Anhand dieser Informationen können Sie das Risiko der Einbeziehung von Erweiterungen einschätzen Jupyter-Labor.

Erstellte IPython-Notizbücher (Seiten in Jupyter-Labor) wird nun im Home-Verzeichnis des Benutzers erstellt - /home/jupyter, aber unsere Pläne bestehen darin, die Daten (Freigabe) zwischen dem Host und dem Container aufzuteilen, also kehren Sie zur Konsole zurück und stoppen Sie Jupyter-Labor durch Ausführen des Hotkeys - CTRL+C und antworten y auf Anfrage. Beenden Sie dann die interaktive Sitzung des Benutzers jupyter Ausfüllen eines Hotkeys CTRL+D.

Daten mit dem Host teilen ^

Um Daten mit dem Host zu teilen, müssen Sie im Container ein Gerät erstellen, das Ihnen dies ermöglicht. Führen Sie dazu den folgenden Befehl aus, in dem wir die folgenden Schlüssel angeben:

  • lxc config device add — Der Befehl fügt die Gerätekonfiguration hinzu
  • jupyter – ID des Containers, dem die Konfiguration hinzugefügt wird
  • hostfs - Geräte ID. Sie können einen beliebigen Namen festlegen.
  • disk — Der Gerätetyp wird angezeigt
  • path – Gibt den Pfad im Container an, in den LXD dieses Gerät einbindet
  • source – Geben Sie die Quelle und den Pfad zum Verzeichnis auf dem Host an, das Sie mit dem Container teilen möchten. 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 den Katalog /home/dv/projects/ipython-notebooks Die Berechtigung muss auf den Containerbenutzer festgelegt werden, der derzeit eine UID von hat SubUID + UID, siehe Kapitel Sicherheit. Containerprivilegien Artikel Grundfunktionen von LXD – Linux-Containersystemen.

Legen Sie die Berechtigung auf dem Host fest, wobei der Eigentümer der Containerbenutzer ist jupyter, und die Variable $USER gibt Ihren Host-Benutzer als Gruppe an:

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

Hallo Welt! ^

Wenn im Container noch eine Konsolensitzung geöffnet ist Jupyter-Labor, und starten Sie es dann mit einem neuen Schlüssel neu --notebook-dir durch Einstellen des Wertes /mnt/hostfs als Pfad zum Stammverzeichnis der Laptops 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 auf die Seite http://10.0.5.5:8888 und erstellen Sie Ihren ersten Laptop, indem Sie auf die Schaltfläche auf der Seite klicken, wie im Bild unten gezeigt:

Jupyter in die LXD-Umlaufbahn bringen

Geben Sie dann im Feld auf der Seite den Python-Code ein, der den Klassiker anzeigt Hello World!. Wenn Sie mit der Eingabe fertig sind, drücken Sie CTRL+ENTER oder die Schaltfläche „Play“ in der Symbolleiste oben, damit JupyterLab Folgendes ausführt:

Jupyter in die LXD-Umlaufbahn bringen

Zu diesem Zeitpunkt ist fast alles einsatzbereit, aber es wird uninteressant, wenn wir nicht zusätzliche Python-Module (vollwertige Anwendungen) installieren, die die Standardfunktionen von Python erheblich erweitern können Jupyter-Labor, also lasst uns weitermachen :)

PS: Das Interessante ist, dass die alte Implementierung Jupiter unter dem Codenamen Jupyter Notizbuch ist nicht verschwunden und existiert parallel dazu Jupyter-Labor. Um zur alten Version zu wechseln, folgen Sie dem Link und fügen Sie das Suffix in die Adresse ein/tree, und der Übergang zu einer neuen Version erfolgt mit dem Suffix /lab, aber es muss nicht angegeben werden:

Erweiterung der Funktionen von Python ^

In diesem Abschnitt werden wir so leistungsstarke Python-Sprachmodule installieren wie NumPy, Pandas, Matplotlib, IPyWidgets deren Ergebnisse in Laptops integriert werden Jupyter-Labor.

Vor der Installation der aufgelisteten Python-Module über den Paketmanager pip Wir müssen zuerst Systemabhängigkeiten in Alpine Linux auflösen:

  • g++ — Wird zum Kompilieren von Modulen benötigt, da einige davon in der Sprache implementiert sind C + + und zur Laufzeit als Binärmodule eine Verbindung zu Python herstellen
  • 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 Stand der Alpine-Linux-Distribution wird es nicht möglich sein, die neue Version von NumPy zu kompilieren; es erscheint ein Kompilierungsfehler, den ich nicht beheben konnte:

ERROR: Es konnten keine Räder für Numpy erstellt werden, die PEP 517 verwenden und nicht direkt installiert werden können

Daher werden wir dieses Modul als Systempaket installieren, das eine bereits kompilierte Version verteilt, die jedoch etwas älter ist als die, die derzeit auf der Website verfügbar ist:

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

Als nächstes installieren Sie Python-Module über den Paketmanager pip. Bitte haben Sie etwas Geduld, da die Kompilierung einiger Module einige Minuten dauern kann. Auf meinem Rechner dauerte die Kompilierung etwa 15 Minuten:

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

Installationscaches löschen:

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

Testmodule in JupyterLab ^

Wenn Sie laufen Jupyter-Labor, starten Sie es neu, damit die neu installierten Module aktiviert werden. Klicken Sie dazu in einer Konsolensitzung auf CTRL+C wo Sie es laufen lassen und betreten y um die Anfrage zu stoppen und dann erneut zu starten Jupyter-Labor indem Sie den Aufwärtspfeil auf der Tastatur drücken, um den Befehl nicht erneut einzugeben Enter Um es zu starten:

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

Перейдите на страницу http://10.0.5.5:8888/lab Oder aktualisieren Sie die Seite in Ihrem 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 IPyWidgets generiert ein UI-Element auf der Seite, das interaktiv mit dem Quellcode interagiert, und außerdem Matplotlib zeigt das Ergebnis des Codes in Form eines Bildes als Funktionsgraph an:

Jupyter in die LXD-Umlaufbahn bringen

Viele Beispiele IPyWidgets Sie können es in Tutorials finden hier

Was sonst? ^

Gut gemacht, wenn Sie geblieben sind und das Ende des Artikels erreicht haben. Ich habe am Ende des Artikels bewusst kein fertiges Skript gepostet, das installiert werden würde Jupyter-Labor mit „einem Klick“, um Mitarbeiter zu ermutigen :) Aber Sie können es auch selbst tun, da Sie bereits wissen, wie es geht, indem Sie die Befehle in einem einzigen Bash-Skript zusammengefasst haben :)

Du kannst auch:

  • Legen Sie einen Netzwerknamen für den Container anstelle einer IP-Adresse fest, indem Sie ihn einfach schreiben /etc/hosts und geben Sie die Adresse in den Browser ein http://jupyter.local:8888
  • Spielen Sie mit dem Ressourcenlimit für den Container herum, lesen Sie dazu das Kapitel in grundlegende LXD-Funktionen oder erhalten Sie weitere Informationen auf der LXD-Entwicklerseite.
  • Ändern Sie das Thema:

Jupyter in die LXD-Umlaufbahn bringen

Und Sie können noch viel mehr tun! Das ist alles. Ich wünsche Ihnen Erfolg!

UPDATE: 15.04.2020 18:30 – Fehler im Kapitel „Hello, World!“ korrigiert.
UPDATE: 16.04.2020 10:00 – Text in der Beschreibung der Erweiterungsmanager-Aktivierung korrigiert und hinzugefügt Jupyter-Labor
UPDATE: 16.04.2020 10:40 — Im Text gefundene Fehler korrigiert und das Kapitel „Basissoftware installieren und System einrichten“ leicht zum Besseren geändert.

Source: habr.com

Kommentar hinzufügen