ProHoster > Blog > Bestjoer > Jupyter lansearje yn LXD-baan

Jupyter lansearje yn LXD-baan

Hawwe jo oait moatten eksperimintearje mei koade as systeemhulpprogramma's yn Linux om jo gjin soargen te meitsjen oer it basissysteem en net alles te brekken yn gefal fan in flater yn 'e koade dy't mei root-privileezjes moat rinne?

Mar hoe sit it mei it feit dat litte wy sizze dat jo in heule kluster fan ferskate mikrotsjinsten op ien masine moatte testen of útfiere? Hûndert of sels tûzen?

Mei firtuele masines dy't beheard wurde troch in hypervisor, kinne en wurde sokke problemen oplost, mar tsjin hokker kosten? Bygelyks, in kontener yn LXD basearre op de Alpine Linux-distribúsje verbruikt allinich 7.60MB RAM, en wêr't de root-partysje beslacht nei it opstarten 9.5MB! Hoe fynsto dat, Elon Musk? Ik advisearje in check out basismooglikheden fan LXD - in kontenersysteem yn Linux

Nei't it yn 't algemien dúdlik waard wat LXD-konteners binne, litte wy fierder gean en tinke, wat as d'r sa'n harvesterplatfoarm wie wêr't jo feilich koade foar de host kinne útfiere, grafiken generearje, UI-widgets dynamysk (ynteraktyf) keppelje mei jo koade, oanfolje de koade mei tekst mei blackjack ... opmaak? In soarte fan ynteraktyf blog? Wow... ik wol it! Wolle! 🙂

Sjoch ûnder de kat wêr't wy sille lansearje yn in kontener jupyter lab - de folgjende generaasje brûkersynterface ynstee fan it ferâldere Jupyter Notebook, en wy sille ek Python-modules ynstallearje lykas numpy, pandas, matplotlib, IPyWidgets wêrtroch jo alles hjirboppe kinne dwaan en alles opslaan yn in spesjaal bestân - in IPython-laptop.

Jupyter lansearje yn LXD-baan

Orbital startplan ^

Jupyter lansearje yn LXD-baan

Litte wy in koart aksjeplan sketse om it foar ús makliker te meitsjen om it boppesteande skema út te fieren:

  • Litte wy in kontener ynstallearje en lansearje basearre op de distribúsjekit Alpine Linux. Wy sille dizze ferdieling brûke, om't it rjochte is op minimalisme en sil allinich de meast nedige software yn ynstallearje, neat oerstallich.
  • Litte wy in ekstra firtuele skiif tafoegje yn 'e kontener en jou it in namme - hostfs en montearje it op it rootbestânsysteem. Dizze skiif sil it mooglik meitsje om bestannen op 'e host te brûken fan in opjûne map yn' e kontener. Sa sille ús gegevens ûnôfhinklik wêze fan 'e kontener. As de kontener wiske is, sille de gegevens op 'e host bliuwe. Ek is dit skema nuttich foar it dielen fan deselde gegevens tusken in protte konteners sûnder de standert netwurkmeganismen fan 'e kontenerferdieling te brûken.
  • Litte wy Bash, sudo, de nedige biblioteken ynstallearje, in systeembrûker tafoegje en konfigurearje
  • Litte wy Python, modules ynstallearje en binêre ôfhinklikens foar har kompilearje
  • Litte wy ynstallearje en starte jupyter lab, oanpasse it uterlik, ynstallearje útwreidingen foar it.

Yn dit artikel sille wy begjinne mei it lansearjen fan de kontener, wy sille net beskôgje it ynstallearjen en konfigurearjen fan LXD, jo kinne dit alles fine yn in oar artikel - Basisfunksjes fan LXD - Linux-containersystemen.

Ynstallaasje en konfiguraasje fan it basissysteem ^

Wy meitsje in kontener mei it kommando wêryn wy de ôfbylding spesifisearje - alpine3, identifier foar de kontener - jupyterlab en, as nedich, konfiguraasjeprofilen:

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

Hjir brûk ik in konfiguraasjeprofyl hddroot dy't spesifisearret om in kontener te meitsjen mei in root-partysje yn opslach pool leit op in fysike HDD skiif:

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

Dit jout my de kâns om te eksperimintearjen mei konteners op 'e HDD-skiif, en bewarje de boarnen fan' e SSD-skiif, dy't ek beskikber is yn myn systeem 🙂 wêrfoar ik in apart konfiguraasjeprofyl makke haw ssdroot.

Nei't de kontener oanmakke is, is it yn 'e steat STOPPED, dus wy moatte it begjinne troch it init-systeem yn te rinnen:

lxc start jupyterlab

Litte wy in list mei konteners yn LXD werjaan mei de kaai -c dy't oanjout hokker csifers werjaan:

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

By it meitsjen fan de kontener waard it IP-adres willekeurich keazen, om't wy in konfiguraasjeprofyl brûkten default dat wie earder konfigurearre yn it artikel Basisfunksjes fan LXD - Linux-containersystemen.

Wy sille dit IP-adres feroarje nei in mear memorabel troch it meitsjen fan in netwurkynterface op it kontenernivo, en net op it konfiguraasjeprofylnivo sa't it no is yn 'e hjoeddeistige konfiguraasje. Jo hoege dit net te dwaan, jo kinne it oerslaan.

It meitsjen fan in netwurkynterface eth0 dy't wy keppelje oan de switch (netwurkbrêge) lxdbr0 wêryn wy NAT ynskeakele hawwe neffens it foarige artikel en de kontener sil no tagong hawwe ta it ynternet, en wy jouwe ek in statysk IP-adres ta oan 'e ynterface - 10.0.5.5:

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

Nei it tafoegjen fan in apparaat moat de kontener opnij opstarte wurde:

lxc restart jupyterlab

Kontrolearje de status fan 'e kontener:

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

It ynstallearjen fan basissoftware en it ynstellen fan it systeem ^

Om ús kontener te behearjen, moatte jo de folgjende software ynstallearje:

Pakket
Beskriuwing

bash
De GNU Bourne Again shell

bash-foltôging
Programmierbere foltôging foar de bash-shell

sudo
Jou bepaalde brûkers de mooglikheid om guon kommando's as root út te fieren

skaad
Wachtwurd- en akkountbehear-arksuite mei stipe foar skaadbestannen en PAM

tzdata
Boarnen foar gegevens oer tiidsône en simmertiid

Nano
Pico bewurker kloon mei ferbetterings

Derneist kinne jo stipe ynstallearje yn 'e systeemman-pagina's troch de folgjende pakketten te ynstallearjen - man man-pages mdocml-apropos less

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

Litte wy nei de kommando's en toetsen sjen dy't wy brûkten:

  • lxc - Rop LXD-kliïnt
  • exec - LXD client metoade dy't rint in kommando yn 'e kontener
  • jupyterlab - Container ID
  • -- - In spesjale kaai dy't spesifisearret net te ynterpretearje fierdere kaaien as kaaien foar lxc en passe de rest fan 'e snaar sa't it is nei de kontener
  • apk - Alpine Linux distribúsjepakketbehearder
  • add - In metoade foar pakketbehearder dy't pakketten ynstalleart opjûn nei it kommando

Folgjende sille wy in tiidsône yn it systeem ynstelle Europe/Moscow:

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

Nei it ynstallearjen fan de tiidsône, it pakket tzdata is net mear nedich yn it systeem, sil it romte nimme, dus litte wy it wiskje:

lxc exec jupyterlab -- apk del tzdata

Kontrolearje de tiidsône:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Om net in protte tiid te besteegjen oan it ynstellen fan Bash foar nije brûkers yn 'e kontener, sille wy yn' e folgjende stappen klearmakke skel-bestannen kopiearje fan it hostsysteem nei it. Hjirmei kinne jo Bash ynteraktyf yn in kontener prettify. Myn hostsysteem is Manjaro Linux en de bestannen wurde kopiearre /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors yn prinsipe binne se geskikt foar Alpine Linux en feroarsaakje gjin krityske problemen, mar jo kinne in oare ferdieling hawwe en jo moatte selsstannich útfine as d'r in flater is by it útfieren fan Bash yn 'e kontener.

Kopiearje de skel triemmen nei de kontener. Kaai --create-dirs sil de nedige mappen oanmeitsje as se net besteane:

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

Foar in besteande root-brûker kopiearje de skel-bestannen dy't krekt yn 'e kontener kopieare binne nei de thúsmap:

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 ynstalleart in systeemshell foar brûkers /bin/sh, wy sille ferfange it mei root brûker yn Bash:

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

dat root de brûker wie net sûnder wachtwurd, hy moat in wachtwurd ynstelle. It folgjende kommando sil in nij willekeurich wachtwurd foar him generearje en ynstelle, dat jo sille sjen op it konsole-skerm nei it útfieren:

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

Litte wy ek in nije systeembrûker oanmeitsje - jupyter wêrfoar wy sille konfigurearje letter jupyter lab:

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

Litte wy in wachtwurd foar generearje en ynstelle:

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

Folgjende sille wy twa kommando's útfiere, de earste sil in systeemgroep meitsje sudo, en de twadde sil in brûker taheakje jupyter:

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

Litte wy sjen by hokker groepen de brûker heart jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Alles is goed, litte wy fierder.

Tastean alle brûkers dy't lid binne fan de groep sudo gebrûk kommando sudo. Om dit te dwaan, rinne it folgjende skript, wêr sed uncomments de parameter line yn de konfiguraasje triem /etc/sudoers:

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

Ynstallearje en konfigurearje JupyterLab ^

jupyter lab is in Python-applikaasje, dus moatte wy dizze tolk earst ynstallearje. Ek, jupyter lab wy sille ynstallearje mei de Python-pakketbehearder pip, en net it systeem ien, om't it miskien ferâldere is yn it systeemrepository en dêrom moatte wy de ôfhinklikens foar it manuell oplosse troch de folgjende pakketten te ynstallearjen - python3 python3-dev gcc libc-dev zeromq-dev:

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

Litte wy python-modules en pakketbehearder bywurkje pip nei de aktuele ferzje:

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

Ynstallearje jupyter lab fia pakketbehearder pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Sûnt de útwreidingen yn jupyter lab binne eksperiminteel en wurde net offisjeel ferstjoerd mei it jupyterlab-pakket, dus wy moatte it manuell ynstallearje en konfigurearje.

Litte wy NodeJS en de pakketbehearder foar it ynstallearje - NPM, sûnt jupyter lab brûkt se foar har tafoegings:

lxc exec jupyterlab -- apk add nodejs npm

Om útwreidings foar jupyter lab dy't wy sille ynstallearje wurke, se moatte wurde ynstallearre yn de brûkersmap sûnt de applikaasje sil wurde lansearre fan de brûker jupyter. It probleem is dat d'r gjin parameter is yn it startkommando dat kin wurde trochjûn oan in map; de applikaasje aksepteart allinich in omjouwingsfariabele en dêrom moatte wy it definiearje. Om dit te dwaan, sille wy de fariabele eksportearje skriuwe JUPYTERLAB_DIR yn de brûker syn omjouwing jupyter, opslaan .bashrcdat wurdt útfierd elke kear as de brûker ynloggt:

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

It folgjende kommando sil in spesjale útwreiding ynstallearje - extension manager yn jupyter lab:

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

No is alles klear foar de earste lansearring jupyter lab, mar wy kinne noch in pear nuttige tafoegings ynstallearje:

  • toc - Ynhâldsopjefte, genereart in list mei kopteksten yn in artikel / notebook
  • jupyterlab-horizon-theme - UI-tema
  • jupyterlab_neon_theme - UI-tema
  • jupyterlab-ubu-theme - Noch ien tema fan de skriuwer dit artikel :) Mar yn dit gefal sil de ynstallaasje fan it GitHub-repository werjûn wurde

Dus, útfiere de folgjende kommando's sequentieel om dizze tafoegings te ynstallearjen:

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"

Nei it ynstallearjen fan de tafoegings moatte wy se kompilearje, om't wy earder, tidens de ynstallaasje, de kaai spesifisearje --no-build om tiid te besparjen. No sille wy signifikant fersnelle troch se yn ien kear tegearre te kompilearjen:

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

Fier no de folgjende twa kommando's út om it foar it earst út te fieren jupyter lab. It soe mooglik wêze om it mei ien kommando te starten, mar yn dit gefal sil it startkommando, dat yn jo gedachten lestich is te ûnthâlden, wurde ûnthâlden troch bash yn 'e kontener, en net op' e host, wêr't al genôch kommando's binne om se yn 'e skiednis op te nimmen :)

Oanmelde by de kontener as brûker jupyter:

lxc exec jupyterlab -- su -l jupyter

Folgjende, rinne jupyter lab mei toetsen en parameters lykas oanjûn:

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

Gean nei it adres yn jo webblêder http://10.0.5.5:8888 en op 'e side dy't iepenet enter token tagong dy't jo sille sjen yn 'e konsole. Kopiearje en plakke it op 'e side, klik dan login. Gean nei it oanmelden nei it tafoegingsmenu oan 'e lofterkant, lykas werjûn yn' e ôfbylding hjirûnder, wêr't jo by it aktivearjen fan de tafoegingbehearder frege wurde om feiligensrisiko's te nimmen troch tafoegings fan tredden te ynstallearjen wêrfoar it kommando JupyterLab ûntwikkeling is net ferantwurdlik:

Jupyter lansearje yn LXD-baan

Wy isolearje lykwols it gehiel jupyter lab en pleats it yn in kontener sadat tafoegings fan tredden dy't NodeJS fereaskje en brûke kinne net op syn minst gegevens op 'e skiif stelle, oars as dejingen dy't wy yn 'e kontener iepenje. Gean nei jo privee dokuminten op de host yn /home prosessen fan 'e kontener binne net wierskynlik te slagjen, en as se dogge, dan moatte jo privileezjes hawwe op bestannen op it hostsysteem, om't wy de kontener yn rinne unprivileged modus. Op grûn fan dizze ynformaasje kinne jo it risiko beoardielje om útwreidingen yn te nimmen jupyter lab.

Oanmakke IPython-notebooks (siden yn jupyter lab) sil no oanmakke wurde yn de thúsmap fan de brûker - /home/jupyter, mar ús plannen binne om de gegevens (diel) te dielen tusken de host en de kontener, dus werom nei de konsole en stopje jupyter lab troch it útfieren fan fluchtoets - CTRL+C en antwurdzje y op oanfraach. Beëinigje dan de ynteraktive sesje fan de brûker jupyter it ynfoljen fan in fluchtoets CTRL+D.

Diele gegevens mei de host ^

Om gegevens te dielen mei de host, moatte jo in apparaat yn 'e kontener meitsje wêrmei jo dit kinne dwaan en om dit te dwaan, fier it folgjende kommando út wêr't wy de folgjende kaaien oantsjutte:

  • lxc config device add - It kommando foeget de apparaatkonfiguraasje ta
  • jupyter - ID fan de kontener dêr't de konfiguraasje wurdt tafoege
  • hostfs - Apparaat ID. Jo kinne elke namme ynstelle.
  • disk - It type apparaat wurdt oanjûn
  • path - Spesifiseart it paad yn 'e kontener wêrop LXD dit apparaat sil mount
  • source - Spesifisearje de boarne, it paad nei de map op 'e host dy't jo wolle diele mei de kontener. Spesifisearje it paad neffens jo foarkar
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Foar de katalogus /home/dv/projects/ipython-notebooks tastimming moat ynsteld wurde foar de kontenerbrûker dy't op it stuit in UID hat gelyk oan SubUID + UID, sjoch haadstik Feilichheid. Container Privileges yn it artikel Basisfunksjes fan LXD - Linux-containersystemen.

Stel de tastimming yn op 'e host, wêr't de eigner de kontenerbrûker sil wêze jupyter, en de fariabele $USER sil jo hostbrûker as groep spesifisearje:

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

Hallo wrâld! ^

As jo ​​noch hawwe in konsole sesje iepen yn de kontener mei jupyter lab, start it dan op 'e nij mei in nije kaai --notebook-dir troch it ynstellen fan de wearde /mnt/hostfs as it paad nei de root fan 'e laptops yn' e kontener foar it apparaat dat wy makke hawwe yn 'e foarige stap:

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

Gean dan nei de side http://10.0.5.5:8888 en meitsje jo earste laptop troch te klikken op de knop op 'e side lykas werjûn yn' e ôfbylding hjirûnder:

Jupyter lansearje yn LXD-baan

Fier dan yn it fjild op 'e side de Python-koade yn dy't de klassiker werjaan sil Hello World!. As jo ​​klear binne mei it ynfieren, druk op CTRL+ENTER of de knop "spielje" op 'e arkbalke boppe om JupyterLab dit te dwaan:

Jupyter lansearje yn LXD-baan

Op dit punt is hast alles klear foar gebrûk, mar it sil net ynteressant wêze as wy gjin ekstra Python-modules (folsleine applikaasjes) ynstallearje dy't de standertmooglikheden fan Python signifikant kinne útwreidzje yn jupyter labdus litte wy fierder :)

PS It nijsgjirrige is dat de âlde ymplemintaasje jupyter ûnder koade namme Jupyter Notebook is net fuortgien en it bestiet parallel mei jupyter lab. Om oer te skeakeljen nei de âlde ferzje, folgje de keppeling mei it tafoegjen fan it efterheaksel yn it adres/tree, en de oergong nei de nije ferzje wurdt útfierd mei it efterheaksel /lab, mar it hoecht net oantsjutte te wurden:

It útwreidzjen fan de mooglikheden fan Python ^

Yn dizze seksje sille wy sokke krêftige Python-taalmodules ynstallearje as numpy, pandas, matplotlib, IPyWidgets wêrfan de resultaten binne yntegreare yn laptops jupyter lab.

Foardat jo de neamde Python-modules ynstallearje fia de pakketbehearder pip wy moatte earst systeemôfhinklikens oplosse yn Alpine Linux:

  • g++ - Need foar it kompilearjen fan modules, om't guon fan harren yn 'e taal binne ymplementearre C ++ en ferbine mei Python by runtime as binêre modules
  • freetype-dev - ôfhinklikens foar Python module matplotlib

Ofhinklikens ynstallearje:

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

D'r is ien probleem: yn 'e hjoeddeistige steat fan' e Alpine Linux-distribúsje sil it net mooglik wêze om de nije ferzje fan NumPy te kompilearjen; in kompilaasjeflater sil ferskine dy't ik net koe oplosse:

FERSIN: Koe net bouwe tsjillen foar numpy dy't brûke PEP 517 en kin net ynstallearre wurde direkt

Dêrom sille wy dizze module ynstallearje as in systeempakket dat in al kompilearre ferzje distribearret, mar in bytsje âlder dan wat op it stuit beskikber is op 'e side:

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

Ynstallearje dan Python-modules fia de pakketbehearder pip. Wês asjebleaft geduld, om't guon modules sille kompilearje en in pear minuten duorje kinne. Op myn masine naam kompilaasje ~15 minuten:

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

Ynstallaasjecaches wiskje:

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

Testen fan modules yn JupyterLab ^

As jo ​​rinne jupyter lab, start it op 'e nij sadat de nij ynstallearre modules binne aktivearre. Om dit te dwaan, klikje yn in konsole-sesje CTRL+C wêr't jo it rinnen hawwe en ynfiere y om fersyk te stopjen en dan opnij te begjinnen jupyter lab troch op de pylk omheech te drukken op it toetseboerd om it kommando net wer en dan yn te fieren Enter om it te begjinnen:

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

Gean nei de side http://10.0.5.5:8888/lab of ferfarskje de side yn jo browser, en fier dan de folgjende koade yn yn in nije notebooksel:

%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

Jo moatte krije in resultaat lykas yn de foto hjirûnder, wêr IPyWidgets genereart in UI-elemint op 'e side dy't ynteraktyf ynteraktyf is mei de boarnekoade, en ek matplotlib toant it resultaat fan 'e koade yn' e foarm fan in ôfbylding as in funksjegrafyk:

Jupyter lansearje yn LXD-baan

In protte foarbylden IPyWidgets jo kinne it fine yn tutorials hjir

Wat oars? ^

Goed dien as jo bleaunen en it heule ein fan it artikel berikke. Ik haw mei opsetsin gjin klearmakke skript pleatst oan 'e ein fan it artikel dat soe ynstallearje jupyter lab yn "ien klik" om arbeiders oan te moedigjen :) Mar jo kinne it sels dwaan, om't jo al witte hoe, nei't jo de kommando's sammele hawwe yn ien Bash-skript :)

Do kinst ek:

  • Stel in netwurknamme foar de kontener yn ynstee fan in IP-adres troch it yn in ienfâldige te skriuwen /etc/hosts en typ it adres yn 'e browser http://jupyter.local:8888
  • Boartsje mei de boarne limyt foar de kontener, hjirfoar lês it haadstik yn basis LXD mooglikheden of krije mear ynformaasje op de LXD-ûntwikkeldersside.
  • Feroarje it tema:

Jupyter lansearje yn LXD-baan

En folle mear kinne jo dwaan! Da's alles. Ik winskje dy sukses!

UPDATE: 15.04.2020/18/30 XNUMX:XNUMX - Korrizjearre flaters yn it haadstik "Hallo, wrâld!"
UPDATE: 16.04.2020/10/00 XNUMX:XNUMX - Korrigearre en tafoege tekst yn 'e beskriuwing fan aktivearring fan útwreidingsbehearder jupyter lab
UPDATE: 16.04.2020/10/40 XNUMX:XNUMX - Korrizjearre flaters fûn yn 'e tekst en wat feroare foar it better it haadstik "Basissoftware ynstallearje en it systeem ynstelle"

Boarne: www.habr.com

Add a comment