ProHoster > Dienoraštis > Administravimas > Jupyter paleidimas į LXD orbitą

Jupyter paleidimas į LXD orbitą

Ar kada nors teko eksperimentuoti su kodu ar sistemos programomis Linux sistemoje, kad nesijaudintumėte dėl bazinės sistemos ir nesugriūtumėte visko, jei kode, kuris turėtų veikti su root teisėmis, būtų klaida?

Bet ką daryti su tuo, kad, tarkime, jums reikia išbandyti arba paleisti visą klasterį įvairių mikropaslaugų viename kompiuteryje? Šimtas ar net tūkstantis?

Naudojant virtualias mašinas, kurias valdo hipervizorius, tokios problemos gali ir bus išspręstos, bet kokia kaina? Pavyzdžiui, LXD konteineris, pagrįstas „Alpine Linux“ paskirstymu, sunaudoja tik 7.60MB RAM ir kur šakninis skaidinys užima po paleidimo 9.5MB! Kaip tau tai patinka, Elon Musk? Rekomenduoju pasitikrinti pagrindinės LXD – konteinerių sistemos Linux sistemoje – galimybės

Po to, kai apskritai paaiškėjo, kas yra LXD konteineriai, eikime toliau ir pagalvokime, kas būtų, jei būtų tokia kombainų platforma, kurioje būtų galima saugiai paleisti pagrindinio kompiuterio kodą, generuoti grafikus, dinamiškai (interaktyviai) susieti vartotojo sąsajos valdiklius su savo kodu, papildyti kodą tekstu su blackjack... formatavimu? Kažkoks interaktyvus dienoraštis? Oho... noriu! Nori! 🙂

Pažiūrėkite po kate, kur mes paleisime konteinerį „JupyterLab“ - naujos kartos vartotojo sąsaja vietoj pasenusio Jupyter Notebook, taip pat įdiegsime Python modulius, tokius kaip „NumPy“, Pandas, matplotlib, IPyWidgets kuri leis atlikti viską, kas išvardinta aukščiau, ir visa tai išsaugoti specialiame faile – IPython nešiojamame kompiuteryje.

Jupyter paleidimas į LXD orbitą

Orbitinio kilimo planas ^

Jupyter paleidimas į LXD orbitą

Pateikiame trumpą veiksmų planą, kad būtų lengviau įgyvendinti aukščiau pateiktą schemą:

  • Įdiegkime ir paleiskime konteinerį pagal paskirstymo rinkinį Alpių Linux. Naudosime šį platinimą, nes jis orientuotas į minimalizmą ir į jį įdiegs tik būtiniausią programinę įrangą, nieko nereikalingo.
  • Pridėkite papildomą virtualų diską į konteinerį ir suteikime jam pavadinimą - hostfs ir prijunkite prie šakninės failų sistemos. Šis diskas leis naudoti pagrindiniame kompiuteryje esančius failus iš nurodyto konteinerio katalogo. Taigi mūsų duomenys bus nepriklausomi nuo konteinerio. Jei konteineris ištrintas, duomenys liks pagrindiniame kompiuteryje. Be to, ši schema naudinga dalintis tais pačiais duomenimis tarp daugelio konteinerių, nenaudojant standartinių konteinerio paskirstymo tinklo mechanizmų.
  • Įdiegkime Bash, sudo, reikalingas bibliotekas, pridėkime ir sukonfigūruosime sistemos vartotoją
  • Įdiegkime Python, modulius ir sukompiliuokime jiems dvejetaines priklausomybes
  • Įdiegkime ir paleisime „JupyterLab“, tinkinkite išvaizdą, įdiekite jos plėtinius.

Šiame straipsnyje mes pradėsime nuo konteinerio paleidimo, mes nesvarstysime apie LXD diegimą ir konfigūravimą, visa tai galite rasti kitame straipsnyje - Pagrindinės LXD – Linux konteinerių sistemų savybės.

Pagrindinės sistemos montavimas ir konfigūravimas ^

Sukuriame konteinerį su komanda, kurioje nurodome vaizdą - alpine3, konteinerio identifikatorius - jupyterlab ir, jei reikia, konfigūracijos profiliai:

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

Čia aš naudoju konfigūracijos profilį hddroot kuri nurodo sukurti konteinerį su šakniniu skaidiniu Sandėliavimo baseinas esantis fiziniame HDD diske:

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

Tai suteikia man galimybę eksperimentuoti su konteineriais HDD diske, taupant SSD disko resursus, kurie yra ir mano sistemoje 🙂 kuriam sukūriau atskirą konfigūracijos profilį ssdroot.

Sukūrus konteinerį, jis yra būsenoje STOPPED, todėl turime jį pradėti paleisdami jame init sistemą:

lxc start jupyterlab

Naudodami klavišą parodykime LXD konteinerių sąrašą -c kuri rodo, kuri cstulpelių ekranas:

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

Kuriant konteinerį IP adresas buvo pasirinktas atsitiktinai, nes naudojome konfigūracijos profilį default kuris anksčiau buvo sukonfigūruotas straipsnyje Pagrindinės LXD – Linux konteinerių sistemų savybės.

Šį IP adresą pakeisime į įsimintinesnį, sukurdami tinklo sąsają konteinerio lygiu, o ne konfigūracijos profilio lygiu, kaip dabar yra dabartinėje konfigūracijoje. Jūs neprivalote to daryti, galite tai praleisti.

Tinklo sąsajos kūrimas eth0 kurį susiejame su jungikliu (tinklo tiltu) lxdbr0 kuriame pagal ankstesnį straipsnį įjungėme NAT ir konteineris dabar turės prieigą prie interneto, taip pat sąsajai priskiriame statinį IP adresą - 10.0.5.5:

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

Pridėjus įrenginį, konteineris turi būti paleistas iš naujo:

lxc restart jupyterlab

Konteinerio būsenos tikrinimas:

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

Pagrindinės programinės įrangos įdiegimas ir sistemos nustatymas ^

Norėdami administruoti mūsų konteinerį, turite įdiegti šią programinę įrangą:

Paketas
Aprašymas

bash
GNU Bourne Again apvalkalas

bash-užbaigimas
Programuojamas bash apvalkalo užbaigimas

: sudo
Suteikite tam tikriems vartotojams galimybę paleisti kai kurias komandas kaip root

šešėlis
Slaptažodžių ir paskyros valdymo įrankių rinkinys su šešėlinių failų ir PAM palaikymu

tzdata
Laiko juostos ir vasaros laiko duomenų šaltiniai

nanotechnologijų
Pico redaktoriaus klonas su patobulinimais

Be to, galite įdiegti palaikymą sistemos vadovo puslapiuose, įdiegdami šiuos paketus − man man-pages mdocml-apropos less

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

Pažvelkime į naudojamas komandas ir klavišus:

  • lxc — Skambinti LXD klientui
  • exec - LXD kliento metodas, kuris paleidžia komandą konteineryje
  • jupyterlab – Sudėtinio rodinio ID
  • -- - Specialus raktas, nurodantis, kad kiti klavišai nebūtų interpretuojami kaip raktai lxc ir perkelkite likusią eilutės dalį į konteinerį
  • apk - Alpine Linux platinimo paketų tvarkyklė
  • add – Paketų tvarkyklės metodas, kuris įdiegia po komandos nurodytus paketus

Toliau sistemoje nustatysime laiko juostą Europe/Moscow:

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

Įdiegę laiko juostą, paketą tzdata sistemoje nebereikalingas, jis užims vietos, todėl ištrinkite:

lxc exec jupyterlab -- apk del tzdata

Tikrinama laiko juosta:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Kad nereikėtų praleisti daug laiko nustatant Bash naujiems naudotojams konteineryje, atlikdami šiuos veiksmus mes nukopijuosime paruoštus skel failus iš pagrindinės sistemos į jį. Tai leis interaktyviai pagražinti Bash konteineryje. Mano pagrindinė sistema yra „Manjaro Linux“ ir kopijuojami failai /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors iš esmės jie tinka „Alpine Linux“ ir nesukelia kritinių problemų, tačiau paskirstymas gali būti kitoks ir jums reikia savarankiškai išsiaiškinti, ar paleidžiant „Bash“ konteineryje yra klaida.

Nukopijuokite skelio failus į konteinerį. Raktas --create-dirs sukurs reikiamus katalogus, jei jų nėra:

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

Esamam root naudotojui nukopijuokite skel failus, ką tik nukopijuotus į konteinerį, į pagrindinį katalogą:

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“ vartotojams įdiegia sistemos apvalkalą /bin/sh, mes jį pakeisime root vartotojas Bash:

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

Kad root vartotojas nebuvo be slaptažodžio, jam reikia nustatyti slaptažodį. Ši komanda sugeneruos ir nustatys jam naują atsitiktinį slaptažodį, kurį įvykdę pamatysite konsolės ekrane:

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

Be to, sukurkime naują sistemos vartotoją - jupyter kuriuos sukonfigūruosime vėliau „JupyterLab“:

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

Sugeneruokime ir nustatykime jam slaptažodį:

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

Toliau vykdysime dvi komandas, pirmoji sukurs sistemos grupę sudo, o antrasis prie jo pridės vartotoją jupyter:

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

Pažiūrėkime, kurioms grupėms priklauso vartotojas jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Viskas gerai, judam toliau.

Leisti visiems naudotojams, kurie yra grupės nariai sudo naudoti komandą sudo. Norėdami tai padaryti, paleiskite šį scenarijų, kur sed atšaukia parametrų eilutės komentarus konfigūracijos faile /etc/sudoers:

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

„JupyterLab“ diegimas ir konfigūravimas ^

„JupyterLab“ yra Python programa, todėl pirmiausia turime įdiegti šį interpretatorių. Taip pat „JupyterLab“ įdiegsime naudodami Python paketų tvarkyklę pip, o ne sisteminė, nes ji gali būti pasenusi sistemos saugykloje, todėl turime rankiniu būdu pašalinti jos priklausomybes, įdiegdami šiuos paketus - python3 python3-dev gcc libc-dev zeromq-dev:

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

Atnaujinkime python modulius ir paketų tvarkyklę pip į dabartinę versiją:

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

Nustatyti „JupyterLab“ per paketų tvarkyklę pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Kadangi pratęsimai į „JupyterLab“ yra eksperimentiniai ir nėra oficialiai pristatomi kartu su „jupyterlab“ paketu, todėl turime jį įdiegti ir konfigūruoti rankiniu būdu.

Įdiegkime NodeJS ir jam skirtą paketų tvarkyklę – NPM, nuo „JupyterLab“ naudoja juos savo plėtiniams:

lxc exec jupyterlab -- apk add nodejs npm

Norėdami plėtinius „JupyterLab“ kuriuos įdiegsime, jie veikė, juos reikia įdiegti vartotojo kataloge, nes programa bus paleista iš vartotojo jupyter. Problema ta, kad paleidimo komandoje nėra parametro, kurį būtų galima perduoti į katalogą; programa priima tik aplinkos kintamąjį, todėl turime jį apibrėžti. Norėdami tai padaryti, parašysime kintamojo eksporto komandą JUPYTERLAB_DIR vartotojo aplinkoje jupyter, į failą .bashrckuris vykdomas kiekvieną kartą vartotojui prisijungus:

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

Kita komanda įdiegs specialų plėtinį - plėtinių tvarkyklę „JupyterLab“:

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

Dabar viskas paruošta pirmajam paleidimui „JupyterLab“, bet vis tiek galime įdiegti keletą naudingų plėtinių:

  • toc — Turinys, sugeneruoja straipsnio / užrašų knygelės antraščių sąrašą
  • jupyterlab-horizon-theme - UI tema
  • jupyterlab_neon_theme - UI tema
  • jupyterlab-ubu-theme - Kitas tema iš autoriaus šis straipsnis :) Bet tokiu atveju bus rodomas diegimas iš GitHub saugyklos

Taigi, nuosekliai vykdykite šias komandas, kad įdiegtumėte šiuos plėtinius:

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"

Įdiegę plėtinius turime juos sukompiliuoti, nes anksčiau diegimo metu nurodėme raktą --no-build taupyti laiką. Dabar mes žymiai paspartinsime juos sudarydami kartu vienu ypu:

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

Dabar paleiskite šias dvi komandas, kad paleistumėte pirmą kartą „JupyterLab“. Galima būtų paleisti ir viena komanda, bet tokiu atveju paleidimo komandą, kurią mintyse sunku prisiminti, įsimins bash konteineryje, o ne pagrindiniame kompiuteryje, kur komandų jau yra pakankamai įrašyti juos į istoriją :)

Prisijunkite prie konteinerio kaip vartotojas jupyter:

lxc exec jupyterlab -- su -l jupyter

Toliau bėkite „JupyterLab“ su klavišais ir parametrais, kaip nurodyta:

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

Eikite į adresą savo žiniatinklio naršyklėje http://10.0.5.5:8888 ir atsidariusiame puslapyje įveskite žetonas prieiga, kurią matysite konsolėje. Nukopijuokite ir įklijuokite jį puslapyje, tada spustelėkite Prisijungti. Prisijungę eikite į kairėje pusėje esantį plėtinių meniu, kaip parodyta paveikslėlyje žemiau, kur būsite paraginti, aktyvindami plėtinių tvarkyklę, rizikuoti saugumu, diegdami plėtinius iš trečiųjų šalių, kuriems skirta komanda JupyterLab kūrimas neatsako:

Jupyter paleidimas į LXD orbitą

Tačiau mes izoliuojame visą „JupyterLab“ ir įdėkite jį į konteinerį, kad trečiųjų šalių plėtiniai, kuriems reikalingas ir naudojamas NodeJS, bent jau negalėtų pavogti duomenų diske, išskyrus tuos, kuriuos atidarome konteineryje. Pasiekite savo privačius dokumentus pagrindiniame kompiuteryje /home vargu ar pavyks atlikti procesus iš sudėtinio rodinio, o jei pavyks, tuomet turite turėti privilegijas prieglobos sistemos failams, nes konteinerį paleidžiame neprivilegijuotas režimas. Remdamiesi šia informacija galite įvertinti plėtinių įtraukimo riziką „JupyterLab“.

Sukūrė IPython užrašų knygeles (puslapiai į „JupyterLab“) dabar bus sukurtas vartotojo namų kataloge - /home/jupyter, bet mūsų planai yra padalinti duomenis (bendrinti) tarp pagrindinio kompiuterio ir sudėtinio rodinio, todėl grįžkite į konsolę ir sustabdykite „JupyterLab“ paleidus spartųjį klavišą - CTRL+C ir atsakydamas y pagal užklausą. Tada nutraukite interaktyvią vartotojo seansą jupyter užbaigiant greitąjį klavišą CTRL+D.

Dalijimasis duomenimis su šeimininku ^

Norėdami bendrinti duomenis su pagrindiniu kompiuteriu, konteineryje turite sukurti įrenginį, kuris leidžia tai padaryti, ir paleiskite šią komandą, kurioje nurodome šiuos raktus:

  • lxc config device add — Komanda prideda įrenginio konfigūraciją
  • jupyter — konteinerio, prie kurio pridedama konfigūracija, ID
  • hostfs — Įrenginio ID. Galite nustatyti bet kokį pavadinimą.
  • disk — Nurodomas įrenginio tipas
  • path — Nurodomas kelias konteineryje, prie kurio LXD prijungs šį įrenginį
  • source — Nurodykite šaltinį, kelią į pagrindinio kompiuterio katalogą, kurį norite bendrinti su konteineriu. Nurodykite kelią pagal savo pageidavimus
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Dėl katalogo /home/dv/projects/ipython-notebooks leidimas turi būti nustatytas sudėtinio rodinio naudotojui, kurio UID šiuo metu yra lygus SubUID + UID, žr. skyrių Saugumas. Sudėtinio rodinio privilegijos straipsnyje Pagrindinės LXD – Linux konteinerių sistemų savybės.

Nustatykite pagrindinio kompiuterio leidimą, kurio savininkas bus sudėtinio rodinio naudotojas jupyter, ir kintamasis $USER nurodys jūsų pagrindinio kompiuterio vartotoją kaip grupę:

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

Labas pasauli! ^

Jei vis dar atidaryta konsolės sesija konteineryje su „JupyterLab“, tada paleiskite jį iš naujo naudodami naują raktą --notebook-dir nustatydami vertę /mnt/hostfs kaip kelias į nešiojamųjų kompiuterių šaknį įrenginio konteineryje, kurį sukūrėme ankstesniame veiksme:

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

Tada eikite į puslapį http://10.0.5.5:8888 ir sukurkite savo pirmąjį nešiojamąjį kompiuterį spustelėdami mygtuką puslapyje, kaip parodyta paveikslėlyje žemiau:

Jupyter paleidimas į LXD orbitą

Tada puslapio lauke įveskite Python kodą, kuriame bus rodomas klasikinis Hello World!. Baigę įvesti, paspauskite CTRL+ENTER arba mygtuką „Play“ įrankių juostoje viršuje, kad „JupyterLab“ atliktų tai:

Jupyter paleidimas į LXD orbitą

Šiuo metu beveik viskas yra paruošta naudoti, tačiau bus neįdomu, jei neįdiegsime papildomų Python modulių (visaverčių programų), galinčių žymiai išplėsti standartines Python galimybes. „JupyterLab“Taigi, eikime toliau :)

PS Įdomu tai, kad senas įgyvendinimas Jupyteris pagal kodinį pavadinimą „Jupyter“ užrašų knygelė neišnyko ir egzistuoja lygiagrečiai su „JupyterLab“. Norėdami pereiti prie senosios versijos, spustelėkite nuorodą ir pridėkite priedą adresu/tree, o perėjimas prie naujos versijos atliekamas su priesaga /lab, bet nebūtina nurodyti:

Python galimybių išplėtimas ^

Šiame skyriuje įdiegsime tokius galingus Python kalbos modulius kaip „NumPy“, Pandas, matplotlib, IPyWidgets kurių rezultatai integruojami į nešiojamus kompiuterius „JupyterLab“.

Prieš įdiegdami išvardytus Python modulius per paketų tvarkyklę pip pirmiausia turime išspręsti sistemos priklausomybes Alpine Linux:

  • g++ — Reikalingas moduliams kompiliuoti, nes kai kurie iš jų yra realizuoti kalba C + + ir prisijunkite prie Python vykdymo metu kaip dvejetainiai moduliai
  • freetype-dev - priklausomybė nuo Python modulio matplotlib

Priklausomybių diegimas:

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

Yra viena problema: dabartinėje „Alpine Linux“ platinimo būsenoje nebus įmanoma sudaryti naujos „NumPy“ versijos; pasirodys kompiliavimo klaida, kurios negalėjau išspręsti:

KLAIDA: Neįmanoma sukurti ratų, skirtų numpytams, kurie naudoja PEP 517 ir negali būti montuojami tiesiogiai

Todėl mes įdiegsime šį modulį kaip sistemos paketą, kuris platina jau sukompiliuotą versiją, bet šiek tiek senesnę nei šiuo metu yra svetainėje:

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

Tada įdiekite Python modulius per paketų tvarkyklę pip. Būkite kantrūs, nes kai kurie moduliai bus sukompiliuoti ir gali užtrukti kelias minutes. Mano kompiuteryje kompiliavimas užtruko ~15 minučių:

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

Diegimo talpyklos išvalymas:

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

Modulių testavimas JupyterLab ^

Jei bėgate „JupyterLab“, paleiskite jį iš naujo, kad būtų suaktyvinti naujai įdiegti moduliai. Norėdami tai padaryti, konsolės seanso metu spustelėkite CTRL+C kur jis veikia, ir įeikite y sustabdyti užklausą ir pradėti iš naujo „JupyterLab“ paspausdami klaviatūros rodyklę aukštyn, kad daugiau neįvestumėte komandos ir tada Enter pradėti:

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

Eikite į puslapį http://10.0.5.5:8888/lab arba atnaujinkite puslapį naršyklėje, tada įveskite šį kodą naujame bloknoto langelyje:

%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

Turėtumėte gauti tokį rezultatą kaip žemiau esančiame paveikslėlyje, kur IPyWidgets puslapyje sugeneruoja vartotojo sąsajos elementą, kuris interaktyviai sąveikauja su šaltinio kodu, taip pat matplotlib rodo kodo rezultatą paveikslėlio pavidalu kaip funkcijų diagramą:

Jupyter paleidimas į LXD orbitą

Daug pavyzdžių IPyWidgets galite rasti vadovėliuose čia

Kas dar? ^

Puiku, jei pasilikote ir pasiekėte pačią straipsnio pabaigą. Straipsnio pabaigoje sąmoningai nepaskelbiau paruošto scenarijaus, kuris būtų įdiegtas „JupyterLab“ „vienu paspaudimu“, kad paskatintumėte darbuotojus :) Bet jūs galite tai padaryti patys, nes jau žinote kaip, surinkę komandas į vieną Bash scenarijų :)

Tu taip pat gali:

  • Vietoj IP adreso nustatykite konteinerio tinklo pavadinimą, parašydami jį paprastu /etc/hosts ir naršyklėje įveskite adresą http://jupyter.local:8888
  • Apsvarstykite sudėtinio rodinio išteklių apribojimą. Norėdami tai padaryti, skaitykite skyrių pagrindinės LXD galimybės arba gauti daugiau informacijos LXD kūrėjų svetainėje.
  • Pakeiskite temą:

Jupyter paleidimas į LXD orbitą

Ir dar daug ką galite padaryti! Tai viskas. Linkiu sėkmės!

ATNAUJINIMAS: 15.04.2020-18-30 XNUMX:XNUMX - Ištaisytos klaidos skyriuje "Sveikas, pasauli!"
ATNAUJINIMAS: 16.04.2020-10-00 XNUMX:XNUMX — Ištaisytas ir papildytas tekstas plėtinių tvarkyklės aktyvinimo aprašyme „JupyterLab“
ATNAUJINIMAS: 16.04.2020-10-40 XNUMX:XNUMX — Ištaisytos klaidos tekste ir šiek tiek pakeistos į gerąją pusę skyriuje „Pagrindinės programinės įrangos diegimas ir sistemos nustatymas“

Šaltinis: www.habr.com

Добавить комментарий