ProHoster > Blog > Administratioun > Lancéiere Jupyter an LXD Ëmlafbunn

Lancéiere Jupyter an LXD Ëmlafbunn

Hutt Dir jeemools missen experimentéieren mat Code oder System Utilities am Linux fir Iech keng Suergen iwwer de Basissystem ze maachen an net alles erof ze räissen am Fall vun engem Fehler am Code dee mat Root Privilegien lafen soll?

Awer wat iwwer d'Tatsaach datt loosst eis soen datt Dir e ganze Stärekoup vu verschiddene Mikroservicer op enger Maschinn testen oder ausféiert? Honnert oder souguer dausend?

Mat virtuelle Maschinnen, déi vun engem Hypervisor geréiert ginn, kënnen esou Probleemer a wäerte geléist ginn, awer zu wéi engem Präis? Zum Beispill, e Container am LXD baséiert op der Alpine Linux Verdeelung verbraucht nëmmen 7.60MB RAM, a wou d'Root Partition nom Startup besetzt 9.5MB! Wéi gefällt Dir dat, Elon Musk? Ech recommandéieren erauszekréien Basis Fäegkeeten vun LXD - e Container System am Linux

Nodeems et allgemeng kloer gouf wat LXD Container sinn, loosst eis méi wäit goen an denken, wat wann et sou eng Ernteplattform wier, wou Dir sécher Code fir den Host lafe kënnt, Grafike generéieren, dynamesch (interaktiv) UI- Widgets mat Ärem Code verbannen, ergänzen de Code mat Text mat Blackjack ... Formatéieren? Eng Zort interaktiv Blog? Wow ... ech wëll et! Wëllt! 🙂

Kuckt ënnert der Kaz wou mir an engem Container starten Jupyter Labo - déi nächst Generatioun vu Benotzerinterface amplaz vum alen Jupyter Notizbuch, a mir wäerten och Python Moduler installéieren wéi z. NummPy, Pandas, matplotlib, IPyWidgets wat Iech erlaabt alles uewen opgezielt ze maachen an alles an enger spezieller Datei ze späicheren - en IPython Laptop.

Lancéiere Jupyter an LXD Ëmlafbunn

Orbital Startplang ^

Lancéiere Jupyter an LXD Ëmlafbunn

Loosst eis e kuerzen Handlungsplang skizzéieren fir et méi einfach ze maachen fir de Schema hei uewen ëmzesetzen:

  • Loosst eis e Container installéieren a starten op Basis vum Verdeelungskit Alpine Linux. Mir wäerten dës Verdeelung benotzen well se op Minimalismus zielt a wäert nëmmen déi néideg Software dran installéieren, näischt iwwerflësseg.
  • Loosst eis eng zousätzlech virtuell Scheif am Container derbäi a ginn et en Numm - hostfs a montéiert et op de Root Dateisystem. Dës Disk wäert et méiglech maachen Dateien um Host aus engem bestëmmte Verzeechnes am Container ze benotzen. Sou wäerten eis Donnéeën onofhängeg vum Container sinn. Wann de Container geläscht gëtt, bleiwen d'Donnéeën um Host. Och dëst Schema ass nëtzlech fir déiselwecht Donnéeën tëscht ville Container ze deelen ouni d'Standard Netzwierkmechanismen vun der Containerverdeelung ze benotzen.
  • Loosst eis Bash, sudo, déi néideg Bibliothéiken installéieren, e System Benotzer addéieren a konfiguréieren
  • Loosst eis Python, Moduler installéieren a binär Ofhängegkeete fir si kompiléieren
  • Loosst eis installéieren a starten Jupyter Labo, d'Erscheinung personaliséieren, Extensiounen dofir installéieren.

An dësem Artikel fänke mir mam Container unzefänken, mir betruechten net d'LXD z'installéieren an ze konfiguréieren, Dir kënnt dat alles an engem aneren Artikel fannen - Basis Features vun LXD - Linux Container Systemer.

Installatioun an Configuratioun vun der Basis System ^

Mir erstellen e Container mam Kommando an deem mir d'Bild spezifizéieren - alpine3, Identifizéierer fir de Container - jupyterlab an, wann néideg, Konfiguratiounsprofile:

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

Hei benotzen ech e Konfiguratiounsprofil hddroot déi spezifizéiert fir e Container mat enger Root-Partition ze kreéieren Stockage Pool op enger kierperlecher HDD Disk läit:

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

Dëst gëtt mir d'Méiglechkeet fir mat Container op der HDD Disk ze experimentéieren, d'Ressourcen vun der SSD Disk ze spueren, déi och a mengem System verfügbar ass 🙂 fir deen ech e separaten Konfiguratiounsprofil erstallt hunn ssdroot.

Nodeems de Container erstallt ass, ass et am Staat STOPPED, also musse mir et starten andeems Dir den Init System dran leeft:

lxc start jupyterlab

Loosst eis eng Lëscht vu Container am LXD mat dem Schlëssel weisen -c wat weist wéi eng columnen weisen:

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

Wann Dir de Container erstellt, gouf d'IP Adress zoufälleg gewielt, well mir e Konfiguratiounsprofil benotzt hunn default déi virdru am Artikel konfiguréiert war Basis Features vun LXD - Linux Container Systemer.

Mir wäerten dës IP Adress op eng méi memorablen änneren andeems en Netzwierk Interface um Containerniveau erstellt, an net um Konfiguratiounsprofilniveau wéi et elo an der aktueller Konfiguratioun ass. Dir musst dat net maachen, Dir kënnt et iwwersprangen.

Schafen engem Netzwierk Interface eth0 déi mir un de Schalter verlinken (Netzbréck) lxdbr0 an deem mir NAT no dem viregten Artikel aktivéiert hunn an de Container elo Zougang zum Internet huet, a mir ginn och eng statesch IP Adress un d'Interface zou - 10.0.5.5:

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

Nodeems Dir en Apparat bäigefüügt hutt, muss de Container nei gestart ginn:

lxc restart jupyterlab

Iwwerpréift de Status vum Container:

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

Basis Software installéieren an de System opbauen ^

Fir eise Container ze administréieren, musst Dir déi folgend Software installéieren:

Pak
description

ze brong
D'GNU Bourne Again Shell

bash-Vervollstännegung
Programméierbar Fäerdegstellung fir d'Bash Shell

sudo
Gitt bestëmmte Benotzer d'Fäegkeet fir e puer Kommandoen als Root auszeféieren

Schied
Passwuert a Kontemanagement Tool Suite mat Ënnerstëtzung fir Schattendateien a PAM

tzdaten
Quelle fir Zäitzone an Dagesliichtzäitdaten

Nanotechnike sinn
Pico Editor Klon mat Verbesserungen

Zousätzlech kënnt Dir Ënnerstëtzung an de System Man-Säiten installéieren andeems Dir déi folgend Packagen installéiert - man man-pages mdocml-apropos less

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

Loosst eis d'Befehle an d'Schlësselen kucken, déi mir benotzt hunn:

  • lxc - Call LXD Client
  • exec - LXD Client Method déi e Kommando am Container leeft
  • jupyterlab - Container ID
  • -- - E spezielle Schlëssel datt spezifizéiert net weider Schlësselen als Schlëssel interpretéieren fir lxc a gitt de Rescht vun der String wéi et an de Container
  • apk - Alpine Linux Verdeelungs Package Manager
  • add - Eng Package Manager Method déi Packagen installéiert déi nom Kommando spezifizéiert sinn

Als nächst wäerte mir eng Zäitzone am System setzen Europe/Moscow:

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

No der Installatioun vun der Zäitzone, de Package tzdata ass net méi am System gebraucht, et wäert Plaz ophuelen, also loosse mer et läschen:

lxc exec jupyterlab -- apk del tzdata

Iwwerpréift vun der Zäitzone:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Fir net vill Zäit ze verbréngen Bash fir nei Benotzer am Container Ariichten, an de folgende Schrëtt wäerte mir prett-feieren skel Fichier'en aus dem Gaascht System bis et Kopie. Dëst erlaabt Iech de Bash an engem Container interaktiv ze prettify. Mäi Hostsystem ass Manjaro Linux an d'Dateien déi kopéiert ginn /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors am Prinzip si si fir Alpine Linux gëeegent a verursaache keng kritesch Problemer, awer Dir kënnt eng aner Verdeelung hunn an Dir musst onofhängeg erausfannen ob et e Feeler ass wann Dir Bash am Container leeft.

Kopie der skel Fichier'en op de Container. Schlëssel --create-dirs wäert déi néideg Verzeichnisser erstellen wa se net existéieren:

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

Fir eng bestehend root Benotzer, Kopie der skel Fichier'en just an de Container an d'Haus Verzeechnes kopéiert:

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 installéiert e System Shell fir Benotzer /bin/sh, mir ersetzen et mat root Benotzer am Bash:

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

datt root de Benotzer war net ouni Passwuert, hie muss e Passwuert astellen. De folgende Kommando generéiert a setzt en neit zoufälleg Passwuert fir hien, dat Dir op der Konsolebildschierm no senger Ausféierung gesitt:

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

Loosst eis och en neie System Benotzer erstellen - jupyter fir déi mir spéider konfiguréieren Jupyter Labo:

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

Loosst eis e Passwuert generéieren an setzen:

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ächst wäerte mir zwee Kommandoen ausféieren, déi éischt wäert e Systemgrupp erstellen sudo, an déi zweet wäert e Benotzer dobäi ginn jupyter:

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

Loosst eis kucken wéi eng Gruppen de Benotzer gehéiert jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Alles ass ok, loosst eis weidergoen.

Erlaabt all Benotzer déi Member vum Grupp sinn sudo benotzen Kommando sudo. Fir dëst ze maachen, lafen déi folgend Skript, wou sed decommentéiert d'Parameterlinn an der Konfiguratiounsdatei /etc/sudoers:

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

JupyterLab installéieren an konfiguréieren ^

Jupyter Labo ass eng Python Applikatioun, also musse mir als éischt dësen Dolmetscher installéieren. Och, Jupyter Labo mir installéiere mam Python Package Manager pip, an net de System eent, well et am Systemrepository verännert ka sinn an dofir musse mir d'Ofhängegkeete fir et manuell léisen andeems Dir déi folgend Packagen installéiert - python3 python3-dev gcc libc-dev zeromq-dev:

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

Loosst eis Python Moduler a Package Manager aktualiséieren pip op déi aktuell Versioun:

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

Installéieren Jupyter Labo iwwer Package Manager pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Zënter den Extensiounen an Jupyter Labo sinn experimentell a ginn net offiziell mam Jupyterlab Package verschéckt, also musse mir et manuell installéieren an konfiguréieren.

Loosst eis NodeJS an de Package Manager fir et installéieren - NPM, zënter Jupyter Labo benotzt se fir seng Extensiounen:

lxc exec jupyterlab -- apk add nodejs npm

Zu Erweiderunge fir Jupyter Labo déi mir installéieren geschafft hunn, mussen se am Benotzerverzeichnis installéiert ginn, well d'Applikatioun vum Benotzer lancéiert gëtt jupyter. De Problem ass datt et kee Parameter am Startbefehl gëtt deen an e Verzeechnes weidergeleet ka ginn; d'Applikatioun akzeptéiert nëmmen eng Ëmfeldvariabel an dofir musse mir se definéieren. Fir dëst ze maachen, schreiwen mir de Variabel Export Kommando JUPYTERLAB_DIR an der Ëmwelt vum Benotzer jupyter, ze Fichier .bashrcdéi ausgefouert gëtt all Kéier wann de Benotzer aloggen:

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

De nächste Kommando wäert eng speziell Extensioun installéieren - Extensioun Manager an Jupyter Labo:

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

Elo ass alles prett fir den éischte Start Jupyter Labo, awer mir kënnen nach ëmmer e puer nëtzlech Extensiounen installéieren:

  • toc - Inhaltsverzeechnes, generéiert eng Lëscht vun Rubriken an engem Artikel / Notizbuch
  • jupyterlab-horizon-theme - UI Thema
  • jupyterlab_neon_theme - UI Thema
  • jupyterlab-ubu-theme - Eng aner Thema vum Auteur dësen Artikel :) Awer an dësem Fall gëtt d'Installatioun vum GitHub Repository gewisen

Also, lafen déi folgend Kommandoen sequenziell fir dës Extensiounen ze installéieren:

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"

Nodeems mir d'Extensiounen installéiert hunn, musse mir se kompiléieren, well virdrun, während der Installatioun, hu mir de Schlëssel uginn --no-build Zäit ze spueren. Elo wäerte mir däitlech beschleunegen andeems se se an engem Go kompiléieren:

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

Elo lafen déi folgend zwee Kommandoen fir et fir d'éischte Kéier auszeféieren Jupyter Labo. Et wier méiglech et mat engem Kommando ze lancéieren, awer an dësem Fall gëtt de Startbefehl, dee schwéier an Ärem Kapp ze erënneren ass, duerch Bash am Container erënnert ginn, an net um Host, wou et scho genuch Kommandoen sinn fir se an d'Geschicht opzehuelen :)

Aloggen op de Container als Benotzer jupyter:

lxc exec jupyterlab -- su -l jupyter

Als nächst, lafen Jupyter Labo mat Schlësselen a Parameteren wéi uginn:

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

Gitt op d'Adress an Ärem Webbrowser http://10.0.5.5:8888 an op der Säit déi opmaacht gitt Token Zougang deen Dir an der Konsole gesitt. Kopéiert a paste se op d'Säit, da klickt Login. Nodeems Dir Iech ugemellt hutt, gitt op d'Extensiounsmenü op der lénker Säit, wéi an der Figur hei ënnendrënner, wou Dir gefuerdert gëtt, wann Dir den Extensiounsmanager aktivéiert, Sécherheetsrisiken ze huelen andeems Dir Extensiounen vun Drëtt Parteien installéiert fir déi de Kommando JupyterLab Entwécklung ass net verantwortlech:

Lancéiere Jupyter an LXD Ëmlafbunn

Mir isoléieren awer dat Ganzt Jupyter Labo a plazéiert et an engem Container sou datt Drëtt-Partei-Extensiounen déi NodeJS erfuerderen a benotzen, kënnen net op d'mannst Daten op der Disk klauen wéi déi, déi mir am Container opmaachen. Gitt op Är privat Dokumenter um Host an /home Prozesser aus dem Container sinn onwahrscheinlech erfollegräich, a wa se et maachen, da musst Dir Privilegien op Dateien am Hostsystem hunn, well mir de Container lafen onprivilegiéierten Modus. Baséierend op dës Informatioun, kënnt Dir de Risiko bewäerten fir Extensiounen anzebezéien Jupyter Labo.

Erstellt IPython Notizbicher (Säiten an Jupyter Labo) gëtt elo am Heemverzeechnes vum Benotzer erstallt - /home/jupyter, awer eis Pläng sinn d'Donnéeën (deelen) tëscht dem Host an dem Container opzedeelen, also zréck an d'Konsole a stoppen Jupyter Labo andeems Dir Hotkey ausféiert - CTRL+C an Äntwert y op Ufro. Dann ofschléissen d'Interaktiv Sessioun vum Benotzer jupyter eng Hotkey ausfëllen CTRL+D.

Deelen Daten mam Host ^

Fir Daten mat dem Host ze deelen, musst Dir en Apparat am Container erstellen deen Iech erlaabt dëst ze maachen an dëst ze maachen, fuert de folgende Kommando, wou mir déi folgend Schlësselen spezifizéieren:

  • lxc config device add - De Kommando füügt d'Apparatkonfiguratioun un
  • jupyter - ID vum Container an deem d'Konfiguratioun bäigefüügt gëtt
  • hostfs - Apparat ID. Dir kënnt all Numm setzen.
  • disk - D'Zort vum Apparat gëtt uginn
  • path - Spezifizéiert de Wee am Container op deen LXD dësen Apparat montéiert
  • source - Gitt d'Quell un, de Wee zum Verzeechnes um Host deen Dir mam Container deele wëllt. Spezifizéiert de Wee no Äre Virléiften
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Fir de Katalog /home/dv/projects/ipython-notebooks Erlaabnis muss op de Container Benotzer gesat ginn, deen am Moment eng UID gläich ass SubUID + UID, kuckt Kapitel Sécherheet. Container Privilegien an Artikel Basis Features vun LXD - Linux Container Systemer.

Setzt d'Erlaabnis op den Host, wou de Besëtzer de Container Benotzer ass jupyter, an d'Variabel $USER wäert Äre Host Benotzer als Grupp uginn:

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

Moien Welt! ^

Wann Dir nach eng Konsol Sessioun oppen am Container mat Jupyter Labo, da restart et mat engem neie Schlëssel --notebook-dir andeems Dir de Wäert setzt /mnt/hostfs wéi de Wee op d'Wurzel vun de Laptops am Container fir den Apparat deen mir am virege Schrëtt erstallt hunn:

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

Da gitt op d'Säit http://10.0.5.5:8888 a erstellt Ären éischte Laptop andeems Dir op de Knäppchen op der Säit klickt wéi op der Foto hei ënnendrënner:

Lancéiere Jupyter an LXD Ëmlafbunn

Dann, am Feld op der Säit, gitt de Python Code deen de Klassiker weist Hello World!. Wann Dir fäerdeg sidd aginn, dréckt CTRL+ENTER oder de "Spill" Knäppchen op der Toolbar uewen fir JupyterLab dëst ze maachen:

Lancéiere Jupyter an LXD Ëmlafbunn

Zu dësem Zäitpunkt ass bal alles prett fir ze benotzen, awer et wäert oninteressant sinn wa mir keng zousätzlech Python Moduler installéieren (vollwäerteg Uwendungen) déi d'Standardfäegkeete vum Python wesentlech ausbaue kënnen Jupyter Laboalso loosst eis weidergoen :)

PS Déi interessant Saach ass, datt déi al Ëmsetzung jupyter ënner Code Numm Jupyter Notizbuch ass net fortgaang an et existéiert parallel mat Jupyter Labo. Fir op déi al Versioun ze wiesselen, befollegt de Link deen de Suffix an der Adress bäidréit/tree, an den Iwwergank op déi nei Versioun gëtt mam Suffix duerchgefouert /lab, awer et muss net spezifizéiert ginn:

Erweidert d'Fäegkeete vum Python ^

An dëser Rubrik wäerte mir sou mächteg Python Sproochmoduler installéieren wéi NummPy, Pandas, matplotlib, IPyWidgets d'Resultater vun deenen an Laptops integréiert sinn Jupyter Labo.

Ier Dir déi opgelëscht Python Moduler duerch de Package Manager installéiert pip mir mussen éischt System Ofhängegkeeten am Alpine Linux léisen:

  • g++ - Noutwendeg fir Moduler ze kompiléieren, well e puer vun hinnen an der Sprooch implementéiert sinn C ++ a verbënnt mam Python beim Runtime als binäre Moduler
  • freetype-dev - Ofhängegkeet fir Python Modul matplotlib

Ofhängegkeeten installéieren:

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

Et gëtt e Problem: am aktuellen Zoustand vun der Alpine Linux Verdeelung ass et net méiglech déi nei Versioun vum NumPy ze kompiléieren; e Kompiléierungsfehler erschéngt deen ech net konnt léisen:

Feeler: Konnt net bauen Rieder fir numpy déi PEP benotzen 517 a kann net direkt installéiert ginn

Dofir wäerte mir dëse Modul als System Package installéieren, deen eng scho kompiléiert Versioun verdeelt, awer e bësse méi al wéi dat wat de Moment um Site verfügbar ass:

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

Als nächst installéiert Python Moduler duerch de Package Manager pip. Gitt w.e.g. Gedold well e puer Moduler kompiléieren a kënnen e puer Minutten daueren. Op menger Maschinn huet d'Kompilatioun ~15 Minutten gedauert:

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

Installatioun Cache läschen:

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

Testen Moduler am JupyterLab ^

Wann Dir lafen Jupyter Labo, Restart et sou datt déi nei installéiert Moduler aktivéiert ginn. Fir dëst ze maachen, klickt an enger Konsolsessioun CTRL+C wou Dir hutt et Lafen an gitt y Ufro ze stoppen an dann erëm ufänken Jupyter Labo нажав стрелочку на клавиатуре «вверх», чтобы не вводить команду заново и потом Enter fir et unzefänken:

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

Gitt op d'Säit http://10.0.5.5:8888/lab oder erfrëscht d'Säit an Ärem Browser, a gitt dann de folgende Code an enger neier Notizbuchzelle:

%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

Dir sollt e Resultat kréien wéi am Bild hei drënner, wou IPyWidgets generéiert en UI Element op der Säit déi interaktiv mam Quellcode interagéiert, an och matplotlib weist d'Resultat vum Code a Form vun engem Bild als Funktiounsgraf:

Lancéiere Jupyter an LXD Ëmlafbunn

Vill Beispiller IPyWidgets Dir kënnt et an Tutorials fannen hei

Wat soss? ^

Gutt geschafft wann Dir bliwwen sidd an um Enn vum Artikel erreecht hutt. Ech hunn bewosst kee fäerdege Skript um Enn vum Artikel gepost deen installéiere géif Jupyter Labo an "eem Klick" fir d'Aarbechter ze encouragéieren :) Awer Dir kënnt et selwer maachen, well Dir scho wësst wéi, wann Dir d'Kommandoen an engem eenzege Bash Skript gesammelt hutt :)

Dir kënnt och:

  • Setzt en Netznumm fir de Container anstatt eng IP Adress andeems Dir et einfach schreift /etc/hosts a gitt d'Adress am Browser http://jupyter.local:8888
  • Spillt ronderëm mat der Ressourcelimit fir de Container, fir dëst liest d'Kapitel an Basis LXD Fäegkeeten oder kritt méi Informatiounen op der LXD Entwéckler Site.
  • Ännert d'Thema:

Lancéiere Jupyter an LXD Ëmlafbunn

A vill méi kënnt Dir maachen! Dat ass alles. Ech wënschen Iech Erfolleg!

UPDATE: 15.04.2020/18/30 XNUMX:XNUMX - Korrigéiert Feeler am Kapitel "Hallo, Welt!"
UPDATE: 16.04.2020/10/00 XNUMX:XNUMX - Korrigéiert a bäigefüügt Text an der Beschreiwung vun der Extensioun Manager Aktivatioun Jupyter Labo
UPDATE: 16.04.2020/10/40 XNUMX:XNUMX - Korrigéiert Feeler am Text fonnt a liicht geännert fir d'Besserung d'Kapitel "Basis Software installéieren an de System opzestellen"

Source: will.com

Setzt e Commentaire