ProHoster > Blog > administrasie > Begin Jupyter in LXD Orbit

Begin Jupyter in LXD Orbit

Het jy al ooit met kode of stelselhulpmiddels op Linux geëksperimenteer op 'n manier wat nie die basisstelsel skud en dit alles uitmekaar skeur wanneer 'n kodefout voorkom wat met wortelvoorregte behoort te loop nie?

Maar wat van die feit dat jy byvoorbeeld 'n hele groep van verskeie mikrodienste op een masjien moet toets of laat loop? Honderd of selfs duisend?

Met virtuele masjiene wat deur 'n hiperviseerder bestuur word, kan en sal sulke take opgelos word, maar teen watter koste? Byvoorbeeld, 'n houer in LXD gebaseer op die Alpine Linux-verspreiding verbruik slegs minimaal 7.60MB RAM, en waar die wortelpartisie na opstart beset 9.5MB! Wat dink jy, Elon Musk? Ek beveel aan dat jy gaan kyk basiese kenmerke van LXD - houerstelsels in Linux

Nadat dit algemeen duidelik geword het wat LXD-houers is, kom ons gaan verder en dink oor wat as daar so 'n kombinasieplatform was waar 'n mens veilig kode vir die gasheer kan laat loop, grafieke kan genereer, UI-widgets dinamies (interaktief) met jou kode kan koppel, voltooi die kode met blackjack teks ... formatering? Een of ander interaktiewe blog? Sjoe... ek wil dit hê! Verlang! 🙂

Kyk onder die kat waar ons in 'n houer sal lanseer jupyter laboratorium - die volgende generasie van die gebruikerskoppelvlak in plaas van die verouderde Jupyter Notebook, en installeer ook Python-modules soos Numpy, pandas, matplotlib, IPyWidgets wat jou sal toelaat om al die bogenoemde te doen en dit alles in 'n spesiale lêer te stoor - 'n IPython-skootrekenaar.

Begin Jupyter in LXD Orbit

Opstygplan ^

Begin Jupyter in LXD Orbit

Ons gooi 'n kort aksieplan in om dit vir ons makliker te maak om die skema hierbo te implementeer:

  • Installeer en laat loop die houer gebaseer op die verspreiding Alpine Linux. Ons sal hierdie verspreidingskit gebruik aangesien dit op minimalisme gemik is en ons sal slegs die nodigste sagteware daarin installeer, niks meer nie.
  • Kom ons voeg 'n bykomende virtuele skyf by in die houer waaraan ons 'n naam sal gee - hostfs en monteer na die wortel FS. Hierdie skyf sal dit moontlik maak om lêers op die gasheer te gebruik vanaf 'n gegewe gids binne die houer. Die data sal dus onafhanklik van die houer wees. As die houer uitgevee word, sal die data op die gasheer bly. Hierdie skema is ook nuttig om dieselfde data tussen baie houers te deel sonder om die gereelde netwerkmeganismes van die houerverspreiding te gebruik.
  • Installeer Bash, sudo, nodige biblioteke, voeg 'n stelselgebruiker by en konfigureer dit
  • Installeer Python, modules en stel binêre afhanklikhede daarvoor saam
  • Installeer en hardloop jupyter laboratorium, pas die voorkoms aan, installeer uitbreidings daarvoor.

In hierdie artikel sal ons begin deur die houer te begin, ons sal nie oorweeg om LXD te installeer en op te stel nie, u kan dit alles in 'n ander artikel vind - Kernkenmerke van LXD - Linux Container Systems.

Installeer en konfigureer die basisstelsel ^

Ons skep 'n houer met 'n opdrag waarin ons die beeld spesifiseer - alpine3, identifiseerder vir die houer - jupyterlab en opsioneel konfigurasieprofiele:

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

Hier gebruik ek 'n konfigurasieprofiel hddroot wat vertel om 'n houer te skep met 'n wortelpartisie in Stoor swembad geleë op die fisiese HDD:

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 gee my die geleentheid om te eksperimenteer met houers op die HDD, en spaar die hulpbronne van die SSD-skyf wat ek ook in my stelsel het 🙂 waarvoor ek 'n aparte konfigurasieprofiel geskep het ssdroot.

Nadat die houer geskep is, is dit in die toestand STOPPED, so ons moet dit begin deur die init-stelsel daarin uit te voer:

lxc start jupyterlab

Vertoon 'n lys houers in LXD deur die sleutel te gebruik -c wat aandui watter ckolomme om te vertoon:

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

By die skep van die houer is die IP-adres lukraak gekies, aangesien ons 'n konfigurasieprofiel gebruik het default wat voorheen in die artikel opgestel is Kernkenmerke van LXD - Linux Container Systems.

Ons sal hierdie IP-adres na 'n meer onvergeetlike een verander deur 'n netwerkkoppelvlak op die houervlak te skep, en nie op die konfigurasieprofielvlak nie, soos dit nou in die huidige opstelling is. Dit is nie nodig nie, jy kan dit oorslaan.

Die skep van 'n netwerkkoppelvlak eth0 wat ons met die skakelaar (netwerkbrug) koppel lxdbr0 waarin ons NAT geaktiveer het volgens die laaste artikel en die houer sal nou toegang tot die internet hê, en ons ken ook 'n statiese IP-adres aan die koppelvlak toe - 10.0.5.5:

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

Nadat die toestel bygevoeg is, moet die houer herbegin word:

lxc restart jupyterlab

Kontroleer die status van die houer:

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

Basiese sagteware-installasie en stelselopstelling ^

Om ons houer te administreer, moet jy die volgende sagteware installeer:

pakket
Beskrywing

bash
Die GNU Bourne Again-dop

bash-voltooiing
Programmeerbare voltooiing vir die bash-dop

sudo
Gee sekere gebruikers die vermoë om sommige opdragte as root uit te voer

skaduwee
Wagwoord- en rekeningbestuurhulpmiddelpakket met ondersteuning vir skadulêers en PAM

tzdata
Bronne vir tydsone en dagligbesparingstyddata

nano
Pico redakteur kloon met verbeterings

Daarbenewens kan u ondersteuning in die man-bladsye-stelsel installeer deur die volgende pakkette te installeer - man man-pages mdocml-apropos less

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

Kom ons ontleed die opdragte en sleutels wat ons gebruik het:

  • lxc - Bel LXD kliënt
  • exec - LXD-kliëntmetode wat 'n opdrag in 'n houer uitvoer
  • jupyterlab - Houer ID
  • -- — 'n Spesiale sleutel wat spesifiseer om nie verdere sleutels as sleutels vir te interpreteer nie lxc en gee die res van die tou soos dit is na die houer
  • apk - Alpine Linux verspreiding pakket bestuurder
  • add - 'n Pakketbestuurdermetode wat die pakkette installeer wat na die opdrag gespesifiseer is

Stel dan 'n tydsone in die stelsel op Europe/Moscow:

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

Na die opstel van die tydsone, die pakket tzdata nie meer in die stelsel benodig word nie, sal dit spasie opneem, vee dit dus uit:

lxc exec jupyterlab -- apk del tzdata

Kontroleer die tydsone:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Om nie baie tyd te spandeer om Bash vir nuwe gebruikers in die houer op te stel nie, sal die volgende stappe klaargemaakte skel-lêers vanaf die gasheerstelsel daarin kopieer. Dit sal jou toelaat om Bash op 'n interaktiewe manier in 'n houer te versier. My gasheerstelsel is Manjaro Linux en gekopieerde lêers /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors in beginsel is hulle geskik vir Alpine Linux en veroorsaak dit nie kritieke probleme nie, maar jy kan 'n ander verspreiding hê en jy moet dit self uitvind in die geval van 'n fout wat Bash in 'n houer laat loop.

Kopieer die skel-lêers na die houer. Sleutel --create-dirs sal die nodige gidse skep as hulle nie bestaan ​​nie:

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

Vir 'n reeds bestaande wortelgebruiker, kopieer die skel-lêers wat pas in die houer gekopieer is na die tuisgids:

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 installeer 'n stelseldop vir gebruikers /bin/sh, sal ons dit vervang met root gebruiker in Bash:

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

Wat root die gebruiker was nie wagwoordloos nie, hy moet 'n wagwoord stel. Die volgende opdrag sal 'n nuwe ewekansige wagwoord daarvoor genereer en stel, wat u op die konsoleskerm sal sien nadat dit uitgevoer is:

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

Kom ons skep ook 'n nuwe stelselgebruiker - jupyter waarvoor ons later sal konfigureer jupyter laboratorium:

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

Genereer en stel 'n wagwoord daarvoor:

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

Voer dan twee opdragte uit, die eerste sal 'n stelselgroep skep sudo, en die tweede een sal die gebruiker daarby voeg jupyter:

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

Kyk aan watter groepe die gebruiker behoort jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Goed, kom ons gaan aan.

Laat alle gebruikers toe wat lede van die groep is sudo gebruik opdrag sudo. Om dit te doen, voer die volgende skrip uit, waar sed verwyder die parameterlyn in die konfigurasielêer /etc/sudoers:

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

Installeer en konfigureer JupyterLab ^

jupyter laboratorium is 'n Python-toepassing, so ons moet eers hierdie tolk installeer. Ook, jupyter laboratorium ons sal installeer met behulp van python-pakketbestuurder pip, en nie die stelsel een nie, want in die stelselbewaarplek kan dit verouderd wees, en daarom moet ons die afhanklikhede daarvoor handmatig oplos deur die volgende pakkette te installeer - python3 python3-dev gcc libc-dev zeromq-dev:

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

Dateer python-modules en pakketbestuurder op pip na die huidige weergawe:

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

Stel jupyter laboratorium via pakketbestuurder pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Sedert die uitbreidings in jupyter laboratorium is eksperimenteel en word nie amptelik saam met die jupyterlab-pakket gestuur nie, so ons moet dit met die hand installeer en konfigureer.

Installeer NodeJS en die pakketbestuurder daarvoor - NPM, sedert jupyter laboratorium gebruik dit vir sy uitbreidings:

lxc exec jupyterlab -- apk add nodejs npm

Om uitbreidings vir jupyter laboratorium wat ons sal installeer het gewerk, hulle moet in die gebruikersgids geïnstalleer word, aangesien die toepassing vanaf die gebruiker geloods sal word jupyter. Die probleem is dat daar geen parameter in die beginopdrag is wat 'n gids deurgegee kan word nie, die toepassing aanvaar slegs 'n omgewingsveranderlike en daarom moet ons dit definieer. Om dit te doen, sal ons 'n veranderlike uitvoeropdrag skryf JUPYTERLAB_DIR in die gebruiker se omgewing jupyter, om te liasseer .bashrc, wat uitgevoer word elke keer as die gebruiker aanmeld:

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

Die volgende opdrag sal 'n spesiale uitbreiding installeer - die uitbreidingsbestuurder in jupyter laboratorium:

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

Nou is alles gereed vir die eerste bekendstelling jupyter laboratorium, maar ons kan steeds 'n paar nuttige uitbreidings installeer:

  • toc - Inhoudsopgawe, genereer 'n lys van opskrifte in 'n artikel/notaboek
  • jupyterlab-horizon-theme - UI-tema
  • jupyterlab_neon_theme - UI-tema
  • jupyterlab-ubu-theme - Nog een tema van die skrywer van hierdie artikel 🙂 Maar in hierdie geval sal die installasie vanaf die GitHub-bewaarplek gewys word

Voer dus die volgende opdragte in volgorde uit om hierdie uitbreidings te installeer:

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"

Nadat ons die uitbreidings geïnstalleer het, moet ons dit saamstel, aangesien ons vroeër tydens die installasie die sleutel gespesifiseer het --no-build tyd te bespaar. Nou kan ons baie bespoedig deur hulle in een slag saam te stel:

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

Voer nou die volgende twee opdragte uit vir die eerste lopie jupyter laboratorium. Dit sou moontlik wees om dit met een opdrag te begin, maar in hierdie geval sal die beginopdrag, wat moeilik is om in gedagte te hou, onthou word deur bash in die houer, en nie op die gasheer nie, waar daar reeds genoeg opdragte is om skryf hulle in die geskiedenis 🙂

Meld aan by die houer as 'n gebruiker jupyter:

lxc exec jupyterlab -- su -l jupyter

Volgende lopie jupyter laboratorium met sleutels en parameters soos gegee:

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

Navigeer in 'n webblaaier na http://10.0.5.5:8888 en voer op die oop bladsy in teken toegang wat jy in die konsole sal sien. Kopieer dit en plak dit op die bladsy, en klik dan Teken aan. Nadat u aangemeld het, gaan na die uitbreidingskieslys aan die linkerkant, soos in die figuur hieronder getoon, waar u, wanneer u die uitbreidingsbestuurder aktiveer, gevra sal word om sekuriteitsrisiko's te aanvaar deur uitbreidings van derde partye te installeer waarvoor die opdrag JupyterLab ontwikkeling is nie verantwoordelik vir:

Begin Jupyter in LXD Orbit

Ons sal egter die geheel isoleer jupyter laboratorium en sit dit in 'n houer sodat derdeparty-uitbreidings wat NodeJS benodig en gebruik, nie ten minste data op skyf kan steel anders as wat ons binne die houer oopmaak nie. Gaan na jou private dokumente op die gasheer in /home prosesse vanaf die houer sal waarskynlik nie slaag nie, en as hulle dit doen, moet u lêerregte op die gasheerstelsel hê, aangesien ons die houer in nie-bevoorregte modus. Op grond van hierdie inligting kan u die risiko evalueer om uitbreidings in te sluit jupyter laboratorium.

Het IPython-notaboeke geskep (bladsye in jupyter laboratorium) sal nou in die gebruiker se tuisgids geskep word - /home/jupyter, maar in ons planne om data (deel) tussen die gasheer en die houer te deel, keer dus terug na die konsole en stop jupyter laboratorium deur sneltoets uit te voer - CTRL+C en antwoord y op versoek. Beëindig dan die gebruiker se interaktiewe sessie jupyter deur 'n sneltoets uit te voer CTRL+D.

Deel data met die gasheer ^

Om data met die gasheer te deel, moet jy 'n toestel in die houer skep wat jou toelaat om dit te doen, en hiervoor die volgende opdrag uitvoer waar ons die volgende sleutels spesifiseer:

  • lxc config device add - Command voeg toestelkonfigurasie by
  • jupyter — Identifiseerder van die houer waarby die konfigurasie gevoeg is
  • hostfs — Toestel-ID. Jy kan enige naam stel.
  • disk - Toesteltipe word aangedui
  • path - Spesifiseer die pad in die houer waarop LXD hierdie toestel sal monteer
  • source - Die bron is gespesifiseer, die pad na die gids op die gasheer wat jy met die houer wil deel. Spesifiseer die pad volgens jou voorkeur
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Vir katalogus /home/dv/projects/ipython-notebooks die toestemming moet gestel word aan die houergebruiker wat tans 'n UID het gelykstaande aan SubUID + UID, sien hoofstuk Veiligheid. Houer Voorregte in artikel Kernkenmerke van LXD - Linux Container Systems.

Stel die toestemming op die gasheer waar die houergebruiker die eienaar sal wees jupyter, en die veranderlike $USER sal jou gasheergebruiker as 'n groep lys:

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

Hello Wêreld! ^

As jy nog 'n konsolesessie oop het in die houer met jupyter laboratoriumherbegin dit dan met 'n nuwe sleutel --notebook-dir deur die waarde in te stel /mnt/hostfs as die pad na die wortel van die notaboeke in die houer vir die toestel wat ons in die vorige stap geskep het:

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

Gaan dan na die bladsy http://10.0.5.5:8888 en skep jou eerste skootrekenaar deur op die knoppie op die bladsy te klik soos in die prentjie hieronder getoon:

Begin Jupyter in LXD Orbit

Voer dan die Python-kode in wat die klassieke sal uitvoer in die veld op die bladsy Hello World!. Wanneer jy klaar ingevoer het, druk CTRL+ENTER of die "speel"-knoppie op die boonste nutsbalk om JupyterLab dit te laat doen:

Begin Jupyter in LXD Orbit

Dit is amper alles gereed om te gebruik, maar dit sal nie interessant wees as ons nie addisionele Python-modules (volwaardige toepassings) installeer wat ons in staat stel om die standaardkenmerke van Python aansienlik uit te brei in jupyter laboratoriumso kom ons gaan aan 🙂

NS Die interessante ding is dat die ou implementering jupyter onder die kodenaam Jupyter Notaboek het nie weggegaan nie en dit bestaan ​​parallel met jupyter laboratorium. Om na die ou weergawe oor te skakel, volg die skakel deur 'n agtervoegsel by die adres te voeg/tree, en die oorgang na die nuwe weergawe word uitgevoer met die agtervoegsel /lab, maar dit hoef nie gespesifiseer te word nie:

Uitbreiding van Python ^

In hierdie afdeling sal ons sulke kragtige Python-taalmodules installeer soos Numpy, pandas, matplotlib, IPyWidgets waarvan die resultate in skootrekenaars geïntegreer is jupyter laboratorium.

Voordat u die genoemde Python-modules installeer deur die pakketbestuurder pip ons moet eers stelselafhanklikhede in Alpine Linux oplos:

  • g++ - Benodig om modules saam te stel, aangesien sommige van hulle in die taal geïmplementeer is C + + en is tydens looptyd aan Python gekoppel as binêre modules
  • freetype-dev - afhanklikheid vir Python-module matplotlib

Installeer afhanklikhede:

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

Daar is een probleem, in die huidige toestand van die Alpine Linux-verspreiding sal dit nie werk om 'n nuwe weergawe van NumPy saam te stel nie, 'n samestellingsfout sal uitvlieg wat ek nie kon oplos nie:

FOUT: Kon nie wiele bou vir numpy wat PEP 517 gebruik en nie direk geïnstalleer kan word nie

Daarom sal ons hierdie module installeer as 'n stelselpakket wat 'n reeds saamgestelde weergawe versprei, maar 'n bietjie ouer as wat tans op die webwerf beskikbaar is:

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

Installeer dan Python-modules deur die pakketbestuurder pip. Wees geduldig aangesien sommige modules sal saamstel en 'n paar minute neem. Samestelling het ~15 minute op my masjien geneem:

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

Vee installasiegeheue uit:

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

Toets modules in JupyterLab ^

As jy hardloop jupyter laboratorium, herbegin dit sodat die nuut geïnstalleerde modules geaktiveer word. Om dit te doen, druk in die konsolesessie CTRL+C waar jy dit aan die gang het en ingaan y om versoek te stop en dan weer te begin jupyter laboratorium deur die pyltjie op die sleutelbord "op" te druk om nie die opdrag weer en dan in te voer nie Enter om dit te begin:

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

Gaan na die bladsy http://10.0.5.5:8888/lab of verfris die bladsy in die blaaier, en voer dan die volgende kode in 'n nuwe notaboeksel in:

%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

Jy behoort 'n resultaat te kry soos in die prentjie hieronder, waar IPyWidgets genereer 'n UI-element op die bladsy wat interaktief met die bronkode in wisselwerking tree, en matplotlib vertoon die resultaat van die kode as 'n prentjie as 'n grafiek van die funksie:

Begin Jupyter in LXD Orbit

Baie voorbeelde IPyWidgets jy kan vind in tutoriale hier

Wat nog? ^

Jy is wonderlik as jy gebly het en die heel einde van die artikel bereik het. Ek het doelbewus nie die voltooide skrif aan die einde van die artikel geplaas wat sou installeer nie jupyter laboratorium in "een klik" om die harde werkers te beloon 🙂 Maar jy kan dit self doen, want jy weet reeds hoe, deur opdragte in 'n enkele Bash-skrif te versamel 🙂

Jy kan ook:

  • Stel 'n netwerknaam vir die houer in plaas van 'n IP-adres deur dit eenvoudig te skryf /etc/hosts en tik die adres in die blaaier in http://jupyter.local:8888
  • Speel rond met die hulpbronlimiet vir die houer, lees hiervoor die hoofstuk in basiese LXD-vermoëns of kry meer inligting op die LXD-ontwikkelaarwebwerf.
  • Verander tema:

Begin Jupyter in LXD Orbit

En nog baie meer wat jy kan doen! Dis al. Ek wens jou sukses toe!

UPDATE: 15.04.2020/18/30 XNUMX:XNUMX - Vaste foute in die "Hallo, Wêreld!"
UPDATE: 16.04.2020/10/00 XNUMX:XNUMX vm. - Reggestelde en bygevoegde teks in die uitbreidingbestuurder-aktiveringbeskrywing jupyter laboratorium
UPDATE: 16.04.2020/10/40 XNUMX:XNUMX vm - Foute wat gevind is in die teks reggestel en die hoofstuk "Installering van basiese sagteware en stelselkonfigurasie" effens verbeter

Bron: will.com

Voeg 'n opmerking