ProHoster > Блог > Administrācija > Jupyter palaišana LXD orbītā

Jupyter palaišana LXD orbītā

Vai jums kādreiz ir nācies eksperimentēt ar kodu vai sistēmas utilītprogrammām operētājsistēmā Linux, neuztraucoties par pamatā esošo sistēmu un nenojaucot visu, ja rodas kļūda kodā, kuram vajadzētu darboties ar root tiesībām?

Bet kā ir ar to, ka pieņemsim, ka vienā mašīnā ir jāpārbauda vai jāpalaiž vesela dažādu mikropakalpojumu kopa? Simts vai pat tūkstotis?

Ar virtuālajām mašīnām, kuras pārvalda hipervizors, šādas problēmas var un tiks atrisinātas, bet par kādu cenu? Piemēram, konteiners LXD, kura pamatā ir Alpine Linux izplatīšana, patērē tikai 7.60MB RAM un vieta, kur pēc palaišanas atrodas saknes nodalījums 9.5MB! Kā tev tas patīk, Īlons Masks? Iesaku pārbaudīt pamata iespējas LXD - konteineru sistēma Linux

Pēc tam, kad kopumā kļuva skaidrs, kas ir LXD konteineri, dosimies tālāk un padomāsim, kā būtu, ja būtu tāda harvestera platforma, kurā varētu droši palaist resursdatora kodu, ģenerēt grafikus, dinamiski (interaktīvi) saistīt UI logrīkus ar savu kodu, papildināt kodu ar tekstu ar blekdžeku... formatējumu? Kaut kāds interaktīvs emuārs? Oho... es to gribu! Gribi! 🙂

Paskaties zem kaķa, kur mēs palaidīsim konteinerā jupyter laboratorija - nākamās paaudzes lietotāja interfeiss novecojušā Jupyter piezīmjdatora vietā, un mēs arī instalēsim Python moduļus, piemēram, nejutīgs, Pandas, matplotlib, IPyWidgets kas ļaus izdarīt visu iepriekš minēto un to visu saglabāt īpašā failā – IPython klēpjdatorā.

Jupyter palaišana LXD orbītā

Orbitālās pacelšanās plāns ^

Jupyter palaišana LXD orbītā

Ieskicēsim īsu rīcības plānu, lai mums būtu vieglāk īstenot iepriekš minēto shēmu:

  • Instalēsim un palaidīsim konteineru, pamatojoties uz izplatīšanas komplektu Alpine Linux. Mēs izmantosim šo izplatīšanu, jo tas ir vērsts uz minimālismu un tajā instalēs tikai pašu nepieciešamāko programmatūru, nekas nav lieks.
  • Pievienosim konteinerā papildu virtuālo disku un piešķirsim tam nosaukumu - hostfs un pievienojiet to saknes failu sistēmai. Šis disks ļaus izmantot resursdatorā esošos failus no dotā direktorija konteinera iekšpusē. Tādējādi mūsu dati būs neatkarīgi no konteinera. Ja konteiners tiek dzēsts, dati paliks resursdatorā. Šī shēma ir noderīga arī to pašu datu koplietošanai starp daudziem konteineriem, neizmantojot konteineru izplatīšanas standarta tīkla mehānismus.
  • Instalēsim Bash, sudo, nepieciešamās bibliotēkas, pievienosim un konfigurēsim sistēmas lietotāju
  • Instalēsim Python, moduļus un apkoposim tiem binārās atkarības
  • Instalēsim un palaidīsim jupyter laboratorija, pielāgojiet izskatu, instalējiet tam paplašinājumus.

Šajā rakstā mēs sāksim ar konteinera palaišanu, mēs neapsvērsim LXD instalēšanu un konfigurēšanu, to visu varat atrast citā rakstā - LXD - Linux konteineru sistēmu pamatfunkcijas.

Pamatsistēmas uzstādīšana un konfigurēšana ^

Mēs izveidojam konteineru ar komandu, kurā norādām attēlu - alpine3, konteinera identifikators - jupyterlab un, ja nepieciešams, konfigurācijas profili:

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

Šeit es izmantoju konfigurācijas profilu hddroot kas nosaka izveidot konteineru ar saknes nodalījumu Uzglabāšanas baseins atrodas fiziskajā HDD diskā:

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

Tas dod man iespēju eksperimentēt ar konteineriem HDD diskā, ietaupot SSD diska resursus, kas ir pieejams arī manā sistēmā 🙂 kuram esmu izveidojis atsevišķu konfigurācijas profilu ssdroot.

Pēc konteinera izveides tas ir stāvoklī STOPPED, tāpēc mums tas jāsāk, palaižot tajā init sistēmu:

lxc start jupyterlab

Parādīsim konteineru sarakstu LXD, izmantojot taustiņu -c kas norāda uz kuru ckolonnu displejs:

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

Veidojot konteineru, IP adrese tika izvēlēta nejauši, jo mēs izmantojām konfigurācijas profilu default kas iepriekš tika konfigurēts rakstā LXD - Linux konteineru sistēmu pamatfunkcijas.

Mēs mainīsim šo IP adresi uz neaizmirstamāku, izveidojot tīkla saskarni konteinera līmenī, nevis konfigurācijas profila līmenī, kā tas tagad ir pašreizējā konfigurācijā. Jums tas nav jādara, varat to izlaist.

Tīkla interfeisa izveide eth0 kuru mēs saistām ar slēdzi (tīkla tilts) lxdbr0 kurā mēs iespējojām NAT saskaņā ar iepriekšējo rakstu, un konteineram tagad būs piekļuve internetam, kā arī interfeisam piešķiram statisku IP adresi - 10.0.5.5:

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

Pēc ierīces pievienošanas konteiners ir jāpārstartē:

lxc restart jupyterlab

Konteinera statusa pārbaude:

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

Pamatprogrammatūras instalēšana un sistēmas iestatīšana ^

Lai administrētu mūsu konteineru, jums jāinstalē šāda programmatūra:

Pakete
Apraksts

stipri iesist
GNU Bourne Again apvalks

bash-pabeigšana
Programmējama bash čaulas pabeigšana

sudo
Dodiet dažiem lietotājiem iespēju palaist dažas komandas kā root

ēna
Paroles un konta pārvaldības rīku komplekts ar atbalstu ēnu failiem un PAM

tzdata
Laika joslas un vasaras laika datu avoti

nano
Pico redaktora klons ar uzlabojumiem

Turklāt jūs varat instalēt atbalstu sistēmas man-lapās, instalējot šādas pakotnes − man man-pages mdocml-apropos less

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

Apskatīsim izmantotās komandas un taustiņus:

  • lxc — Zvaniet LXD klientam
  • exec - LXD klienta metode, kas palaiž komandu konteinerā
  • jupyterlab — Konteinera ID
  • -- - Īpaša atslēga, kas nosaka turpmākās atslēgas neinterpretēt kā atslēgas priekš lxc un nodot pārējo virkni, kā tas ir konteinerā
  • apk — Alpine Linux izplatīšanas pakotņu pārvaldnieks
  • add — pakotņu pārvaldnieka metode, kas instalē pakotnes, kas norādītas pēc komandas

Tālāk mēs sistēmā iestatīsim laika joslu Europe/Moscow:

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

Pēc laika joslas instalēšanas pakotne tzdata sistēmā vairs nav nepieciešams, tas aizņems vietu, tāpēc izdzēsīsim to:

lxc exec jupyterlab -- apk del tzdata

Laika joslas pārbaude:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Lai netērētu daudz laika, iestatot Bash jaunajiem lietotājiem konteinerā, turpmākajās darbībās no resursdatora sistēmas uz to kopēsim gatavus skel failus. Tas ļaus interaktīvi izrotāt Bašu konteinerā. Mana resursdatora sistēma ir Manjaro Linux, un faili tiek kopēti /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors principā tie ir piemēroti Alpine Linux un nerada kritiskas problēmas, taču jums var būt atšķirīgs sadalījums, un jums ir patstāvīgi jānoskaidro, vai, palaižot Bash konteinerā, ir radusies kļūda.

Kopējiet skel failus konteinerā. Atslēga --create-dirs izveidos nepieciešamos direktorijus, ja tie neeksistē:

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

Esošam root lietotājam kopējiet skel failus, kas tikko iekopēti konteinerā, uz mājas direktoriju:

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 instalē lietotājiem sistēmas apvalku /bin/sh, mēs to aizstāsim ar root lietotājs Bash:

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

Ka root lietotājs nebija bezparoles, viņam jāiestata parole. Šī komanda ģenerēs un iestatīs viņam jaunu nejaušu paroli, kuru pēc tās izpildes redzēsit konsoles ekrānā:

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

Tāpat izveidosim jaunu sistēmas lietotāju - jupyter kuru mēs konfigurēsim vēlāk jupyter laboratorija:

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

Izveidosim un iestatīsim tam paroli:

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

Tālāk mēs izpildīsim divas komandas, no kurām pirmā izveidos sistēmas grupu sudo, un otrais tam pievienos lietotāju jupyter:

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

Apskatīsim, kurām grupām lietotājs pieder jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Viss kārtībā, ejam tālāk.

Atļaut visiem lietotājiem, kas ir grupas dalībnieki sudo izmantot komandu sudo. Lai to izdarītu, palaidiet šādu skriptu, kur sed atceļ parametru rindiņas komentārus konfigurācijas failā /etc/sudoers:

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

JupyterLab instalēšana un konfigurēšana ^

jupyter laboratorija ir Python lietojumprogramma, tāpēc mums vispirms ir jāinstalē šis tulks. Tāpat jupyter laboratorija mēs instalēsim, izmantojot Python pakotņu pārvaldnieku pip, nevis sistēmas, jo tas var būt novecojis sistēmas repozitorijā, un tāpēc mums ir manuāli jāatrisina tās atkarības, instalējot šādas pakotnes - python3 python3-dev gcc libc-dev zeromq-dev:

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

Atjaunināsim python moduļus un pakotņu pārvaldnieku pip uz pašreizējo versiju:

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

Komplekts jupyter laboratorija caur pakotņu pārvaldnieku pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Kopš paplašinājumiem jupyter laboratorija ir eksperimentāli un netiek oficiāli piegādāti kopā ar jupyterlab pakotni, tāpēc mums tā ir jāinstalē un jākonfigurē manuāli.

Instalēsim NodeJS un tam paredzēto pakotņu pārvaldnieku - NPM, kopš jupyter laboratorija izmanto tos saviem paplašinājumiem:

lxc exec jupyterlab -- apk add nodejs npm

Uz paplašinājumiem for jupyter laboratorija kurus mēs instalēsim, tie ir jāinstalē lietotāja direktorijā, jo lietojumprogramma tiks palaista no lietotāja jupyter. Problēma ir tāda, ka palaišanas komandā nav parametru, ko varētu nodot direktorijai; lietojumprogramma pieņem tikai vides mainīgo, un tāpēc mums tas ir jādefinē. Lai to izdarītu, mēs uzrakstīsim mainīgā eksporta komandu JUPYTERLAB_DIR lietotāja vidē jupyter, uz failu .bashrckas tiek izpildīts katru reizi, kad lietotājs piesakās:

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

Nākamā komanda instalēs īpašu paplašinājumu - paplašinājumu pārvaldnieku jupyter laboratorija:

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

Tagad viss ir gatavs pirmajai palaišanai jupyter laboratorija, taču mēs joprojām varam instalēt dažus noderīgus paplašinājumus:

  • toc — Satura rādītājs, ģenerē raksta/piezīmju grāmatiņas virsrakstu sarakstu
  • jupyterlab-horizon-theme — UI tēma
  • jupyterlab_neon_theme — UI tēma
  • jupyterlab-ubu-theme - Vēl viens tēma no autora šo rakstu :) Bet šajā gadījumā tiks rādīta instalācija no GitHub repozitorija

Tātad, lai instalētu šos paplašinājumus, secīgi palaidiet šādas komandas:

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"

Pēc paplašinājumu instalēšanas mums tie ir jāapkopo, jo iepriekš instalēšanas laikā mēs norādījām atslēgu --no-build lai ietaupītu laiku. Tagad mēs ievērojami paātrināsim, apkopojot tos kopā vienā piegājienā:

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

Tagad palaidiet šīs divas komandas, lai to palaistu pirmo reizi jupyter laboratorija. To varētu palaist ar vienu komandu, taču šajā gadījumā palaišanas komandu, kuru prātā grūti atcerēties, atcerēsies bash konteinerā, nevis resursdatorā, kur komandu jau ir pietiekami daudz. ierakstīt tos vēsturē :)

Piesakieties konteinerā kā lietotājs jupyter:

lxc exec jupyterlab -- su -l jupyter

Tālāk, skrien jupyter laboratorija ar taustiņiem un parametriem, kā norādīts:

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

Pārejiet uz adresi savā tīmekļa pārlūkprogrammā http://10.0.5.5:8888 un atvērtajā lapā ievadiet žetons piekļuvi, ko redzēsit konsolē. Kopējiet un ielīmējiet to lapā, pēc tam noklikšķiniet uz Ieiet. Pēc pieteikšanās dodieties uz paplašinājumu izvēlni kreisajā pusē, kā parādīts attēlā zemāk, kur, aktivizējot paplašinājumu pārvaldnieku, jums tiks piedāvāts uzņemties drošības risku, instalējot trešo pušu paplašinājumus, kuriem tiek veikta komanda JupyterLab izstrāde nav atbildīgs:

Jupyter palaišana LXD orbītā

Tomēr mēs izolējam visu jupyter laboratorija un ievietojiet to konteinerā, lai trešo pušu paplašinājumi, kuriem nepieciešams un izmanto NodeJS, nevarētu vismaz nozagt datus diskā, izņemot tos, kurus mēs atveram konteinerā. Piekļūstiet saviem privātajiem dokumentiem resursdatorā /home procesi no konteinera, visticamāk, neizdosies, un, ja tā izdodas, jums ir jābūt privilēģijām uz failiem resursdatora sistēmā, jo mēs palaižam konteineru nepievilcīgs režīms. Pamatojoties uz šo informāciju, varat novērtēt paplašinājumu iekļaušanas risku jupyter laboratorija.

Izveidotas IPython piezīmju grāmatiņas (lapas iekšā jupyter laboratorija) tagad tiks izveidots lietotāja mājas direktorijā - /home/jupyter, taču mūsu plāni ir sadalīt datus (koplietot) starp resursdatoru un konteineru, tāpēc atgriezieties konsolē un pārtraucam jupyter laboratorija izpildot karsto taustiņu - CTRL+C un atbildot y pēc pieprasījuma. Pēc tam pārtrauciet lietotāja interaktīvo sesiju jupyter aizpildot karsto taustiņu CTRL+D.

Datu koplietošana ar saimniekdatoru ^

Lai koplietotu datus ar resursdatoru, konteinerā ir jāizveido ierīce, kas ļauj to izdarīt, un, lai to izdarītu, palaidiet šādu komandu, kurā norādām šādas atslēgas:

  • lxc config device add — komanda pievieno ierīces konfigurāciju
  • jupyter — konteinera ID, kuram pievienota konfigurācija
  • hostfs — Ierīces ID. Varat iestatīt jebkuru nosaukumu.
  • disk — Ir norādīts ierīces veids
  • path — norāda ceļu konteinerā, kuram LXD pievienos šo ierīci
  • source — Norādiet avotu, ceļu uz resursdatora direktoriju, kuru vēlaties koplietot ar konteineru. Norādiet ceļu atbilstoši savām vēlmēm
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Par katalogu /home/dv/projects/ipython-notebooks atļauja ir jāiestata konteinera lietotājam, kuram pašlaik ir vienāds ar UID SubUID + UID, skatiet nodaļu Drošība. Konteinera privilēģijas rakstā LXD - Linux konteineru sistēmu pamatfunkcijas.

Iestatiet resursdatora atļauju, kur īpašnieks būs konteinera lietotājs jupyter, un mainīgais $USER norādīs jūsu resursdatora lietotāju kā grupu:

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

Sveika pasaule! ^

Ja jums joprojām ir atvērta konsoles sesija konteinerā ar jupyter laboratorija, pēc tam restartējiet to ar jaunu atslēgu --notebook-dir iestatot vērtību /mnt/hostfs kā ceļš uz klēpjdatoru sakni ierīces konteinerā, kuru izveidojām iepriekšējā darbībā:

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

Pēc tam dodieties uz lapu http://10.0.5.5:8888 un izveidojiet savu pirmo klēpjdatoru, noklikšķinot uz pogas lapā, kā parādīts attēlā zemāk:

Jupyter palaišana LXD orbītā

Pēc tam lapas laukā ievadiet Python kodu, kas parādīs klasisko Hello World!. Kad esat pabeidzis ievadīšanu, nospiediet CTRL+ENTER vai pogu "Atskaņot" rīkjoslā augšpusē, lai JupyterLab veiktu šādas darbības:

Jupyter palaišana LXD orbītā

Šobrīd gandrīz viss ir gatavs lietošanai, taču būs neinteresanti, ja mēs neinstalēsim papildu Python moduļus (pilnvērtīgas lietojumprogrammas), kas var ievērojami paplašināt Python standarta iespējas jupyter laboratorija, tāpēc ejam tālāk :)

P.S. Interesanti ir tas, ka vecā ieviešana Jupters zem koda nosaukuma Jupyter piezīmju grāmatiņa nav pazudis un pastāv paralēli jupyter laboratorija. Lai pārslēgtos uz veco versiju, sekojiet saitei, pievienojot adresē sufiksu/tree, un pāreja uz jauno versiju tiek veikta ar sufiksu /lab, bet tas nav jānorāda:

Python iespēju paplašināšana ^

Šajā sadaļā mēs instalēsim tādus jaudīgus Python valodas moduļus kā nejutīgs, Pandas, matplotlib, IPyWidgets kuru rezultāti tiek integrēti klēpjdatoros jupyter laboratorija.

Pirms uzskaitīto Python moduļu instalēšanas, izmantojot pakotņu pārvaldnieku pip vispirms mums ir jāatrisina sistēmas atkarības Alpine Linux:

  • g++ — Nepieciešams moduļu kompilēšanai, jo daži no tiem ir ieviesti valodā C + + un izveidojiet savienojumu ar Python izpildlaikā kā bināri moduļi
  • freetype-dev - atkarība no Python moduļa matplotlib

Atkarību instalēšana:

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

Ir viena problēma: pašreizējā Alpine Linux izplatīšanas stāvoklī nebūs iespējams apkopot jauno NumPy versiju; parādīsies kompilācijas kļūda, kuru nevarēju novērst:

KĻŪDA: Nevar izveidot riteņus, kas izmanto PEP 517 un kurus nevar uzstādīt tieši

Tāpēc mēs instalēsim šo moduli kā sistēmas pakotni, kas izplata jau kompilētu versiju, bet nedaudz vecāku par to, kas pašlaik ir pieejama vietnē:

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

Pēc tam instalējiet Python moduļus, izmantojot pakotņu pārvaldnieku pip. Lūdzu, esiet pacietīgs, jo daži moduļi tiks apkopoti un var aizņemt dažas minūtes. Manā mašīnā kompilācija aizņēma ~15 minūtes:

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

Instalācijas kešatmiņas notīrīšana:

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

Moduļu testēšana programmā JupyterLab ^

Ja jūs skrienat jupyter laboratorija, restartējiet to, lai tiktu aktivizēti tikko instalētie moduļi. Lai to izdarītu, konsoles sesijā noklikšķiniet uz CTRL+C kur tas darbojas, un ievadiet y lai apturētu pieprasījumu un pēc tam sāktu no jauna jupyter laboratorija nospiežot tastatūras augšupvērsto bultiņu, lai neievadītu komandu vēlreiz un pēc tam Enter lai to sāktu:

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

Dodieties uz lapu http://10.0.5.5:8888/lab vai atsvaidziniet lapu savā pārlūkprogrammā un pēc tam ievadiet šādu kodu jaunā piezīmju grāmatiņas šūnā:

%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

Jums vajadzētu iegūt rezultātu, piemēram, attēlā zemāk, kur IPyWidgets ģenerē UI elementu lapā, kas interaktīvi mijiedarbojas ar avota kodu, kā arī matplotlib parāda koda rezultātu attēla veidā kā funkciju grafiku:

Jupyter palaišana LXD orbītā

Daudz piemēru IPyWidgets to var atrast pamācībās šeit

Kas vēl? ^

Labi darīts, ja palikāt un sasniedzāt pašas raksta beigas. Es apzināti neievietoju raksta beigās gatavu skriptu, kas instalētu jupyter laboratorija ar “vienu klikšķi”, lai iedrošinātu strādniekus :) Bet jūs to varat izdarīt pats, jo jūs jau zināt, kā, apkopojot komandas vienā Bash skriptā :)

Jūs varat arī:

  • Iestatiet konteineram tīkla nosaukumu, nevis IP adresi, ierakstot to vienkāršā veidā /etc/hosts un pārlūkprogrammā ierakstiet adresi http://jupyter.local:8888
  • Apskatiet konteinera resursu ierobežojumu, lai to uzzinātu, izlasiet nodaļu pamata LXD iespējas vai iegūstiet vairāk informācijas LXD izstrādātāju vietnē.
  • Mainiet tēmu:

Jupyter palaišana LXD orbītā

Un vēl daudz vairāk jūs varat darīt! Tas ir viss. Es novēlu jums panākumus!

ATJAUNINĀJUMS: 15.04.2020 18:30 - Izlabotas kļūdas sadaļā “Sveika, pasaule!”
ATJAUNINĀJUMS: 16.04.2020 10:00 — Izlabots un pievienots teksts paplašinājumu pārvaldnieka aktivizācijas aprakstā jupyter laboratorija
ATJAUNINĀJUMS: 16.04.2020 10:40 — Tekstā atrastas izlabotas kļūdas un nedaudz izmainītas uz labo pusi nodaļā “Pamata programmatūras instalēšana un sistēmas iestatīšana”

Avots: www.habr.com