🥇 Lanĉu Jupyter en LXD-orbiton

Ĉu vi iam devis eksperimenti kun kodo aŭ sistemaj utilecoj en Linukso sen zorgi pri la suba sistemo kaj malkonstrui ĉion en kazo de eraro en la kodo, kiu laŭsupoze ruliĝas kun radikaj privilegioj?

Sed kio pri la fakto, ke ni diru, ke vi devas testi aŭ ruli tutan areton da diversaj mikroservoj sur unu maŝino? Cent aŭ eĉ mil?

Kun virtualaj maŝinoj administritaj de hiperviziero, tiaj problemoj povas kaj estos solvitaj, sed je kia kosto? Ekzemple, ujo en LXD bazita sur la distribuo de Alpa Linukso konsumas nur 7.60MB RAM, kaj kie la radika subdisko okupas post ekfunkciigo 9.5MB! Kiel vi ŝatas ĉi tion, Elon Musk? Mi rekomendas kontroli bazaj kapabloj de LXD - kontenera sistemo en Linukso

Post kiam evidentiĝis ĝenerale, kio estas LXD-ujoj, ni iru plu kaj pensu, kio se ekzistus tia rikoltila platformo, kie vi povus sekure ruli kodon por la gastiganto, generi grafikaĵojn, dinamike (interage) ligi UI-fenestaĵojn kun via kodo, kompletigi la kodon per teksto per blackjack... formatado? Ia interaga blogo? Ve... mi volas ĝin! Volas! 🙂

Rigardu sub la kato, kie ni lanĉos en ujo jupyter-laboratorio - la sekva generacio de uzantinterfaco anstataŭ la malmoderna Jupyter Notebook, kaj ni ankaŭ instalos Python-modulojn kiel ekzemple numpy, Pandoj, matplotlib, IPyWidgets kiu permesos al vi fari ĉion supre listigitan kaj konservi ĉion en speciala dosiero - IPython-tekkomputilo.

Plano de ekflugo orbitala ^

Ni skizu mallongan agadplanon por faciligi al ni efektivigi la skemon supre:

Ni instalu kaj lanĉu ujon bazitan sur la distribua kompleto Linukso Alpa. Ni uzos ĉi tiun distribuon ĉar ĝi celas minimumismon kaj instalos en ĝi nur la plej necesan programaron, nenio superflua.
Ni aldonu plian virtualan diskon en la ujo kaj donu al ĝi nomon - hostfs kaj muntu ĝin al la radika dosiersistemo. Ĉi tiu disko ebligos uzi dosierojn sur la gastiganto de donita dosierujo ene de la ujo. Tiel, niaj datumoj estos sendependaj de la ujo. Se la ujo estas forigita, la datumoj restos sur la gastiganto. Ankaŭ, ĉi tiu skemo estas utila por kunhavigi la samajn datumojn inter multaj ujoj sen uzi la normajn retajn mekanismojn de la ujdistribuo.
Ni instalu Bash, sudo, la necesajn bibliotekojn, aldonu kaj agordu sisteman uzanton
Ni instalu Python, modulojn kaj kompilu binarajn dependecojn por ili
Ni instalu kaj lanĉu jupyter-laboratorio, agordu la aspekton, instalu etendaĵojn por ĝi.

En ĉi tiu artikolo, ni komencos lanĉi la ujon, ni ne konsideros instali kaj agordi LXD, vi povas trovi ĉion ĉi en alia artikolo - Bazaj trajtoj de LXD - Linuksaj ujsistemoj.

Instalado kaj agordo de la baza sistemo ^

Ni kreas ujon kun la komando, en kiu ni specifas la bildon - alpine3, identigilo por la ujo - jupyterlab kaj, se necese, agordaj profiloj:

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

Ĉi tie mi uzas agordan profilon hddroot kiu specifas krei ujon kun radikdisko en Stokado Naĝejo situas sur fizika HDD-disko:

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

Ĉi tio donas al mi la ŝancon eksperimenti kun ujoj sur la HDD-disko, ŝparante la rimedojn de la SSD-disko, kiu ankaŭ estas disponebla en mia sistemo 🙂 por kiu mi kreis apartan agordan profilon. ssdroot.

Post kiam la ujo estas kreita, ĝi estas en la ŝtato STOPPED, do ni devas komenci ĝin rulante la init-sistemon en ĝi:

lxc start jupyterlab

Ni montru liston de ujoj en LXD uzante la ŝlosilon -c kiu indikas kiun ckolumnoj montriĝas:

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

Kreinte la ujon, la IP-adreso estis elektita hazarde, ĉar ni uzis agordan profilon default kiu estis antaŭe agordita en la artikolo Bazaj trajtoj de LXD - Linuksaj ujsistemoj.

Ni ŝanĝos ĉi tiun IP-adreson al pli memorinda kreante retan interfacon ĉe la ujo-nivelo, kaj ne ĉe la agorda profilnivelo kiel ĝi nun estas en la nuna agordo. Vi ne devas fari ĉi tion, vi povas preterlasi ĝin.

Kreante retan interfacon eth0 kiun ni ligas al la ŝaltilo (retoponto) lxdbr0 en kiu ni ebligis NAT laŭ la antaŭa artikolo kaj la ujo nun havos aliron al Interreto, kaj ni ankaŭ atribuas statikan IP-adreson al la interfaco - 10.0.5.5:

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

Post aldoni aparaton, la ujo devas esti rekomencita:

lxc restart jupyterlab

Kontrolante la staton de la ujo:

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

Instalado de baza programaro kaj agordo de la sistemo ^

Por administri nian ujon, vi devas instali la jenan programaron:

pakaĵo
Priskribo

bash
La ŝelo de GNU Bourne Again

bash-kompletigo
Programebla kompletigo por la bash-ŝelo

sudo
Donu al certaj uzantoj la kapablon ruli kelkajn komandojn kiel radiko

ombro
Pasvorto kaj konta administra ilaro kun subteno por ombraj dosieroj kaj PAM

tzdata
Fontoj por horzono kaj tagtempaj datumoj

nano
Pico-redaktila klono kun plibonigoj

Aldone, vi povas instali subtenon en la sistemaj man-paĝoj instalante la jenajn pakaĵojn − man man-pages mdocml-apropos less

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

Ni rigardu la komandojn kaj klavojn, kiujn ni uzis:

lxc — Voku LXD-klienton
exec - LXD-klienta metodo, kiu rulas komandon en la ujo
jupyterlab — Uja ID
-- - Speciala ŝlosilo, kiu specifas ne interpreti pliajn ŝlosilojn kiel ŝlosilojn por lxc kaj pasigu la reston de la ŝnuro kiel estas al la ujo
apk — Alpine Linux distribua pakaĵmanaĝero
add — Pakaĵmanaĝera metodo, kiu instalas pakaĵojn specifitajn post la komando

Poste, ni agordos horzonon en la sistemo. Europe/Moscow:

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

Post instalo de la horzono, la pako tzdata ne plu bezonas en la sistemo, ĝi okupos spacon, do ni forigu ĝin:

lxc exec jupyterlab -- apk del tzdata

Kontrolante la horzonon:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Por ne pasigi multe da tempo agordante Bash por novaj uzantoj en la ujo, en la sekvaj paŝoj ni kopios pretajn skeldosierojn de la gastiga sistemo al ĝi. Ĉi tio permesos al vi beligi Bash en ujo interage. Mia gastiga sistemo estas Manjaro Linukso kaj la dosieroj estas kopiitaj /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors principe ili taŭgas por Alpine Linukso kaj ne kaŭzas kritikajn problemojn, sed vi eble havas malsaman distribuon kaj vi devas sendepende eltrovi ĉu estas eraro dum rulado de Bash en la ujo.

Kopiu la skel-dosierojn al la ujo. Ŝlosilo --create-dirs kreos la necesajn dosierujojn se ili ne ekzistas:

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

Por jam ekzistanta radika uzanto, kopiu la skel-dosierojn ĵus kopiitajn en la ujon al la hejma dosierujo:

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

Alpa Linukso instalas sisteman ŝelon por uzantoj /bin/sh, ni anstataŭigos ĝin per root uzanto en Bash:

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

ke root la uzanto ne estis senpasvorto, li bezonas agordi pasvorton. La sekva komando generos kaj starigos novan hazardan pasvorton por li, kiun vi vidos sur la konzola ekrano post kiam ĝi estos ekzekutita:

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

Ankaŭ, ni kreu novan sisteman uzanton - jupyter por kiu ni agordos poste jupyter-laboratorio:

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

Ni generu kaj agordu pasvorton por ĝi:

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

Poste, ni ekzekutos du komandojn, la unua kreos sisteman grupon sudo, kaj la dua aldonos uzanton al ĝi jupyter:

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

Ni vidu al kiuj grupoj apartenas la uzanto jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Ĉio estas en ordo, ni pluiru.

Permesu ĉiujn uzantojn kiuj estas membroj de la grupo sudo uzu komandon sudo. Por fari tion, rulu la sekvan skripton, kie sed malkomentas la parametran linion en la agorda dosiero /etc/sudoers:

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

Instalado kaj agordo de JupyterLab ^

jupyter-laboratorio estas Python-apliko, do ni unue devas instali ĉi tiun interpretilon. Ankaŭ, jupyter-laboratorio ni instalos uzante la pakaĵadministrilon de Python pip, kaj ne la sistema, ĉar ĝi povas esti malmoderna en la sistemdeponejo kaj tial ni devas mane solvi la dependecojn por ĝi instalante la jenajn pakaĵojn − python3 python3-dev gcc libc-dev zeromq-dev:

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

Ni ĝisdatigu python-modulojn kaj pakaĵadministrilon pip al la nuna versio:

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

Instali jupyter-laboratorio per pakaĵmanaĝero pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Ekde la etendaĵoj en jupyter-laboratorio estas eksperimentaj kaj ne estas oficiale liveritaj kun la pako jupyterlab, do ni devas instali kaj agordi ĝin permane.

Ni instalu NodeJS kaj la pakaĵadministrilon por ĝi - NPM, ekde jupyter-laboratorio uzas ilin por siaj etendaĵoj:

lxc exec jupyterlab -- apk add nodejs npm

Al etendoj por jupyter-laboratorio kiujn ni instalos funkciis, ili devas esti instalitaj en la uzanta dosierujo ĉar la aplikaĵo estos lanĉita de la uzanto jupyter. La problemo estas, ke ne estas parametro en la lanĉa komando kiu povas esti pasita al dosierujo; la aplikaĵo nur akceptas mediovariablon kaj tial ni devas difini ĝin. Por fari tion, ni skribos la variablon eksportan komandon JUPYTERLAB_DIR en la medio de la uzanto jupyter, arkivi .bashrckiu estas efektivigita ĉiufoje kiam la uzanto ensalutas:

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

La sekva komando instalos specialan etendon - etenda administranto en jupyter-laboratorio:

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

Nun ĉio estas preta por la unua lanĉo jupyter-laboratorio, sed ni ankoraŭ povas instali kelkajn utilajn etendaĵojn:

toc — Enhavo, generas liston de rubrikoj en artikolo/kajero
jupyterlab-horizon-theme — UI-temo
jupyterlab_neon_theme — UI-temo
jupyterlab-ubu-theme - Alia temo de la aŭtoro ĉi tiu artikolo :) Sed en ĉi tiu kazo, la instalado de la GitHub-deponejo estos montrita

Do, rulu la sekvajn komandojn sinsekve por instali ĉi tiujn etendaĵojn:

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"

Post instalo de la etendaĵoj, ni devas kompili ilin, ĉar antaŭe, dum instalado, ni specifis la ŝlosilon --no-build por ŝpari tempon. Nun ni signife akcelos kompilante ilin unufoje:

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

Nun rulu la sekvajn du komandojn por ruli ĝin unuafoje jupyter-laboratorio. Eblus lanĉi ĝin per unu komando, sed ĉi-kaze, la lanĉa komando, kiu estas malfacile memorebla en via menso, estos memorita per bash en la ujo, kaj ne sur la gastiganto, kie jam estas sufiĉe da komandoj. registri ilin en la historio :)

Ensalutu al la ujo kiel uzanto jupyter:

lxc exec jupyterlab -- su -l jupyter

Poste, kuru jupyter-laboratorio kun klavoj kaj parametroj kiel indikite:

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

Iru al la adreso en via retumilo http://10.0.5.5:8888 kaj sur la paĝo kiu malfermiĝas eniru token aliro, kiun vi vidos en la konzolo. Kopiu kaj algluu ĝin sur la paĝon, tiam alklaku Ensaluti. Ensalutinte, iru al la menuo de etendoj maldekstre, kiel montrite en la suba figuro, kie oni petos vin, kiam vi aktivigas la administranton de etendoj, preni sekurecajn riskojn instalante etendaĵojn de triaj partioj por kiuj la komando. Evoluo de JupyterLab ne respondecas:

Tamen ni izolas la tuton jupyter-laboratorio kaj metu ĝin en ujo por ke triaj etendaĵoj kiuj postulas kaj uzas NodeJS ne povas almenaŭ ŝteli datumojn sur la disko krom tiuj, kiujn ni malfermas ene de la ujo. Akiru viajn privatajn dokumentojn sur la gastiganto en /home procezoj de la ujo verŝajne ne sukcesos, kaj se jes, tiam vi devas havi privilegiojn pri dosieroj en la gastiga sistemo, ĉar ni rulas la ujon en senprivilegia reĝimo. Surbaze de ĉi tiu informo, vi povas taksi la riskon inkluzivi etendaĵojn en jupyter-laboratorio.

Kreis IPython-kajeroj (paĝoj en jupyter-laboratorio) nun estos kreita en la hejma dosierujo de la uzanto - /home/jupyter, sed niaj planoj estas dividi la datumojn (dividon) inter la gastiganto kaj la ujo, do revenu al la konzolo kaj ĉesu jupyter-laboratorio per ekzekuto de klavoklavo - CTRL+C kaj respondante y laŭ peto. Poste ĉesigu la interagan sesion de la uzanto jupyter kompletigante klavoklavon CTRL+D.

Kunhavigi datumojn kun la gastiganto ^

Por kunhavigi datumojn kun la gastiganto, vi devas krei aparaton en la ujo, kiu ebligas al vi fari tion, kaj por fari tion, rulu la sekvan komandon kie ni specifas la sekvajn ŝlosilojn:

lxc config device add — La komando aldonas la aparatan agordon
jupyter — ID de la ujo al kiu la agordo estas aldonita
hostfs — Aparato ID. Vi povas agordi ajnan nomon.
disk — La tipo de aparato estas indikita
path — Specifas la vojon en la ujo, al kiu LXD montos ĉi tiun aparaton
source — Specifu la fonton, la vojon al la dosierujo sur la gastiganto, kiun vi volas dividi kun la ujo. Indiku la vojon laŭ viaj preferoj

lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Por la katalogo /home/dv/projects/ipython-notebooks permeso devas esti agordita al la uzanto, kiu nuntempe havas UID egalan al SubUID + UID, vidu ĉapitron Sekureco. Privilegioj de ujo en la artikolo Bazaj trajtoj de LXD - Linuksaj ujsistemoj.

Agordu la permeson sur la gastiganto, kie la posedanto estos la uzanto jupyter, kaj la variablo $USER specifos vian gastigantan uzanton kiel grupon:

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

Saluton mondo! ^

Se vi ankoraŭ havas konzolan sesion malfermitan en la ujo kun jupyter-laboratorio, tiam rekomencu ĝin per nova ŝlosilo --notebook-dir fiksante la valoron /mnt/hostfs kiel la vojo al la radiko de la tekkomputiloj en la ujo por la aparato, kiun ni kreis en la antaŭa paŝo:

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

Poste iru al la paĝo http://10.0.5.5:8888 kaj kreu vian unuan tekkomputilon alklakante la butonon sur la paĝo kiel montrite en la suba bildo:

Poste, en la kampo sur la paĝo, enigu la Python-kodon, kiu montros la klasikaĵon Hello World!. Kiam vi finis eniri, premu CTRL+ENTER aŭ la butonon "ludi" sur la ilobreto supre por ke JupyterLab faru ĉi tion:

Je ĉi tiu punkto, preskaŭ ĉio estas preta por uzo, sed estos neinteresa se ni ne instalas pliajn Python-modulojn (plenrajtaj aplikoj), kiuj povas signife vastigi la normajn kapablojn de Python en jupyter-laboratorio, do ni pluiru :)

PS Lin interesa estas ke la malnova efektivigo Jupitero sub kodnomo Kajero Jupyter ne foriris kaj ĝi ekzistas paralele kun jupyter-laboratorio. Por ŝanĝi al la malnova versio, sekvu la ligilon aldonante la sufikson en la adreso/tree, kaj la transiro al la nova versio estas farata per la sufikso /lab, sed ĝi ne devas esti specifita:

Jupyter Kajero - http://10.0.5.5:8888/tree
Jupyter Lab - http://10.0.5.5:8888/lab

Pligrandigante la kapablojn de Python ^

En ĉi tiu sekcio, ni instalos tiajn potencajn Python-lingvajn modulojn kiel numpy, Pandoj, matplotlib, IPyWidgets kies rezultoj estas integritaj en tekkomputiloj jupyter-laboratorio.

Antaŭ ol instali la listigitajn Python-modulojn per la pakaĵa administranto pip ni unue devas solvi sistemajn dependecojn en Alpine Linukso:

g++ — Bezonata por kompili modulojn, ĉar kelkaj el ili estas realigitaj en la lingvo C ++ kaj konekti al Python ĉe rultempo kiel binaraj moduloj
freetype-dev - dependeco por Python-modulo matplotlib

Instalado de dependecoj:

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

Estas unu problemo: en la nuna stato de la distribuo Alpine Linux, ne eblos kompili la novan version de NumPy; aperos kompila eraro, kiun mi ne povis solvi:

ERROR: Ne eblis konstrui radojn por numpy kiuj uzas PEP 517 kaj ne povas esti instalitaj rekte

Sekve, ni instalos ĉi tiun modulon kiel sisteman pakaĵon, kiu distribuas jam kompilitan version, sed iom pli malnovan ol kio estas nuntempe disponebla en la retejo:

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

Poste, instalu Python-modulojn per la pakaĵa administranto pip. Bonvolu pacienci ĉar iuj moduloj kompilos kaj eble daŭros kelkajn minutojn. Sur mia maŝino, kompilo daŭris ~15 minutojn:

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

Forigante instalaĵkaŝmemorojn:

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

Testante modulojn en JupyterLab ^

Se vi kuras jupyter-laboratorio, rekomencu ĝin por ke la nove instalitaj moduloj estu aktivigitaj. Por fari tion, en konzola sesio, klaku CTRL+C kie vi havas ĝin funkcianta kaj eniru y haltigi peton kaj poste komenci denove jupyter-laboratorio premante la supren-sagon sur la klavaro por ne enigi la komandon denove kaj poste Enter por komenci ĝin:

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

Iru al la paĝo http://10.0.5.5:8888/lab aŭ refreŝigu la paĝon en via retumilo, kaj poste enigu la sekvan kodon en nova kajeroĉelo:

%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

Vi devus ricevi rezulton kiel en la suba bildo, kie IPyWidgets generas UI-elementon sur la paĝo, kiu interagas kun la fontkodo, kaj ankaŭ matplotlib montras la rezulton de la kodo en formo de bildo kiel funkciografeo:

Multaj ekzemploj IPyWidgets vi povas trovi ĝin en lerniloj tie

Kio alia? ^

Bone farite se vi restos kaj atingis la finon de la artikolo. Mi intence ne afiŝis pretan skripton ĉe la fino de la artikolo kiu instalus jupyter-laboratorio en "unu klako" por kuraĝigi laboristojn :) Sed vi povas fari ĝin mem, ĉar vi jam scias kiel, kolektinte la komandojn en ununuran Bash-skripton :)

Vi ankaŭ povas:

Agordu retnomon por la ujo anstataŭ IP-adreso skribante ĝin per simpla /etc/hosts kaj tajpu la adreson en la retumilo http://jupyter.local:8888
Ludu kun la limo de rimedoj por la ujo, por tio legu la ĉapitron en bazaj LXD-kapabloj aŭ akiri pliajn informojn en la retejo de la programisto LXD.
Ŝanĝu la temon:

Kaj multe pli vi povas fari! Tio estas ĉio. Mi deziras al vi sukceson!

ĜISDATIGO: 15.04.2020/18/30 XNUMX:XNUMX - Korektitaj eraroj en la ĉapitro "Saluton, Mondo!"
ĜISDATIGO: 16.04.2020/10/00 XNUMX:XNUMX — Korektita kaj aldonita teksto en la priskribo de aktivigo de etenda administranto jupyter-laboratorio
ĜISDATIGO: 16.04.2020/10/40 XNUMX:XNUMX — Korektitaj eraroj trovitaj en la teksto kaj iomete ŝanĝita por pli bone la ĉapitro "Instalado de baza programaro kaj agordo de la sistemo"

fonto: www.habr.com

Lanĉante Jupyter en LXD-orbiton

Навигация