ProHoster > Blog > Beheer > We starten Jupyter op LXD.

We starten Jupyter op LXD.

Heb je ooit geƫxperimenteerd met code of systeemtools in Linux zonder je zorgen te maken over het beschadigen van het basissysteem en zonder alles te verwoesten bij een fout in de code die met root-rechten moet worden uitgevoerd?

Wat als je bijvoorbeeld een hele cluster van verschillende microservices op Ć©Ć©n machine moet testen of uitvoeren? Honderd of zelfs duizend?

Met virtuele machines kan een hypervisor dergelijke taken oplossen, maar tegen welke prijs? Bijvoorbeeld, een container in LXD op basis van het Alpine Linux-distributie verbruikt minimaal slechts 7.60MB RAM, en waar de rootpartitie na het opstarten slechts 9.5MB! Wat vind je daarvan, Elon Musk? Ik raad aan om je te verdiepen in de basisfunctionaliteiten van LXD ā€” een containersysteem in Linux.

Nadat we in het algemeen hebben begrepen wat LXD-containers zijn, laten we verder gaan en nadenken over wat als er een soort kombijnplatform zou zijn waar je veilig code voor de host zou kunnen uitvoeren, grafieken genereren, dynamisch (interactief) de UI-widgets met jouw code verbinden, de code aanvullen met tekst met de nodige opmaak? Iets als een interactieve blog? Wauwā€¦ Ik wil het hebben! šŸ™‚

Bekijk het resultaat hieronder waar we JupyterLab in een container gaan draaien. JupyterLab ā€” de volgende generatie gebruikersinterface in plaats van de verouderde Jupyter Notebook, en we installeren ook modules zoals NumPy, Pandas, Matplotlib, IPyWidgets die ons in staat stellen om alles hierboven beschreven te realiseren en dit op te slaan in een speciaal bestand ā€” een IPython-notebook.

We starten Jupyter op LXD.

Lancering op orbitale hoogte ^

We starten Jupyter op LXD.

Laten we een kort actieplan opstellen, zodat het makkelijker is om het bovenstaande schema te realiseren:

  • We installeren en draaien een container op basis van het distributief. Alpine LinuxWe gebruiken deze distributie omdat deze gericht is op minimalisme, en we installeren alleen de meest noodzakelijke software, niets overbodigs.
  • We voegen een extra virtuele schijf toe aan de container, die we een naam geven ā€” hostfs en we monteren het aan het rootbestandssysteem. Deze schijf maakt het mogelijk om bestanden op de host te gebruiken vanuit een opgegeven map binnen de container. Hierdoor blijven de gegevens onafhankelijk van de container. In het geval van verwijdering van de container blijven de gegevens op de host staan. Dit schema is ook nuttig voor het delen van gegevens tussen meerdere containers zonder de standaard netwerkmiddelen van de containerdistributie te gebruiken.
  • We installeren Bash, sudo, de benodigde bibliotheken, voegen een systeemgebruiker toe en configureren deze.
  • We installeren Python, modules en compileren de binaire afhankelijkheden daarvoor.
  • We installeren en starten JupyterLab, configureren het uiterlijk en installeren extensies voor het.

In dit artikel gaan we samen beginnen met het starten van de container, we zullen de installatie en configuratie van LXD niet behandelen, alles hierover kun je in een ander artikel vinden ā€” Basisfunctionaliteiten van LXD - container systemen in Linux.

Installatie en configuratie van het basissysteem ^

We creĆ«ren de container met het commando waarin we het image opgeven ā€” alpine3, de identificatie voor de container ā€” jupyterlab en indien nodig configuratieprofielen:

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

Hier gebruik ik het configuratieprofiel hddroot dat aangeeft dat de container met de root-partitie moet worden gemaakt in Storage Pool gelegen op de fysieke HDD-schijf:

lxc profile show hddroot

config: {}
beschrijving: ""
devices:
  root:
    pad: \/
    pool: hddpool
    type: disk
naam: hddroot
gebruikt door: []
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 geeft me de mogelijkheid om met containers op de HDD-schijf te experimenteren en zo de bronnen van de SSD-schijf, die ook in mijn systeem is, te besparen šŸ™‚ waarvoor ik een apart configuratieprofiel heb aangemaakt. ssdroot.

Na het creƫren van de container bevindt deze zich in de staat STOPPED, dus we moeten deze starten door de init-systeem in te schakelen:

lxc start jupyterlab

Laten we de lijst van containers in LXD weergeven met de sleutel -c die aangeeft welke ckolommen op het scherm moeten worden weergegeven:

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

Bij het creƫren van de container werd het IP-adres willekeurig gekozen, omdat we gebruikmaakten van het configuratieprofiel default dat eerder was geconfigureerd in het artikel Basisfunctionaliteiten van LXD - container systemen in Linux.

We zullen dit IP-adres wijzigen naar een gemakkelijker te onthouden adres door een netwerkinterface op container-niveau te creƫren, en niet op profiel-configuratieniveau zoals het momenteel in de huidige configuratie is. Dit is niet noodzakelijk, je kunt dit overslaan.

Netwerkinterface aanmaken eth0 waarmee we verbinding maken met de switch (netwerkbrug) lxdbr0 waarbij we NAT inschakelen volgens het vorige artikel en de container nu toegang heeft tot internet, en we de interface een statisch IP-adres toekennen ā€” 10.0.5.5:

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

Na het toevoegen van het apparaat, moet de container opnieuw worden opgestart:

lxc restart jupyterlab

Controleer de status van de container:

lxc list -c ns4b
+------------+---------+------------------+--------------+
|    NAAM    |  STATUS  |       IPV4       | OPSLAGPOOL  |
+------------+---------+------------------+--------------+
| jupyterlab | LOPEND  | 10.0.5.5 (eth0)  | hddpool      |
+------------+---------+------------------+--------------+

Installatie van basissoftware en systeemconfiguratie ^

Voor het beheren van onze container moet de volgende software worden geĆÆnstalleerd:

Package
Beschrijving

bash
De GNU Bourne Again shell

bash-completion
Programmeertaal voor de bash-shell

sudo
Geef bepaalde gebruikers de mogelijkheid om enkele commando's als root uit te voeren

shadow
Hulpmiddelen voor wachtwoord- en accountbeheer met ondersteuning voor schaduwbestanden en PAM

tzdata
Bronnen voor tijdzone- en zomertijdgegevens

Veel mensen hebben hierop gewacht, en veel mensen waren er tegen, maar het is gebeurd: de standaard console teksteditor in Fedora Workstation wordt nano.
Kloon van de Pico-editor met verbeteringen

Daarnaast kunt u systeemondersteuning voor man-pages installeren door de volgende pakketten te installeren ā€” man man-pages mdocml-apropos less

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

Laten we de commando's en opties die we hebben gebruikt, uitleggen:

  • lxc ā€” Roep de LXD-client op
  • exec ā€” Methode van de LXD-client die het commando in de container uitvoert
  • jupyterlab ā€” Identificatienummer van de container
  • -- ā€” Speciaal sleutel die aangeeft dat de volgende opties niet verder als opties moeten worden geĆÆnterpreteerd lxc en de hele resterende regel als is naar de container moet worden doorgestuurd
  • apk ā€” Pakketbeheerder van de Alpine Linux-distributie
  • add ā€” Methode van de pakketbeheerder die de aangegeven pakketten na het commando installeert

Vervolgens stellen we de tijdzone in het systeem in Europe/Moscow:

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

Na het instellen van de tijdzone, is het pakket tzdata in het systeem niet langer nodig, het neemt ruimte in beslag, dus laten we het verwijderen:

lxc exec jupyterlab -- apk del tzdata

Controleer de tijdzone:

lxc exec jupyterlab -- date

Wo Apr 15 10:49:56 MSK 2020

Om geen tijd te verspillen aan het instellen van Bash voor nieuwe gebruikers in de container, zullen we in de volgende stappen de bestaande skel-bestanden van het hostbesturingssysteem naar de container kopiƫren. Dit maakt het mogelijk om Bash in de container in interactivemodus te verfraaien. Mijn hostbesturingssysteem is Manjaro Linux en de gekopieerde bestanden /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors zijn in principe geschikt voor Alpine Linux en veroorzaken geen kritieke problemen, maar u kunt een andere distributie hebben en het kan nodig zijn om zelf de oorzaak van eventuele fouten bij het uitvoeren van Bash in de container te onderzoeken.

Kopieer de skel-bestanden naar de container. Sleutel --create-dirs maakt de benodigde directories aan als deze nog niet bestaan:

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

Voor een al bestaande root-gebruiker kopiƫren we de net gekopieerde skel-bestanden naar de thuismap:

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

In Alpine Linux wordt de systeemshell voor gebruikers ingesteld /bin/sh, we vervangen deze bij root de gebruiker door Bash:

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

Om root de gebruiker had geen wachtwoord, hij moet een wachtwoord instellen. De volgende opdracht genereert en stelt een nieuw willekeurig wachtwoord in dat u op het console-venster zult zien na uitvoering:

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

Laten we ook een nieuwe systeemgebruiker aanmaken ā€” jupyter voor wie we later zullen configureren JupyterLab:

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

We genereren en stellen zijn wachtwoord in:

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

Daarna voeren we twee commando's uit, de eerste maakt een systeemgroep aan sudo, en de tweede voegt de gebruiker eraan toe jupyter:

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

Laten we bekijken in welke groepen de gebruiker zich bevindt jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Alles is goed, we gaan verder.

We staan alle gebruikers die in de groep zitten sudo toe om het commando sudote gebruiken. Voer hiervoor het volgende script uit, dat sed de regelparameter in het configuratiebestand uitcommentarieert /etc/sudoers:

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

Installatie en configuratie van JupyterLab ^

JupyterLab ā€” dit is een Python-applicatie, dus we moeten eerst deze interpreter installeren. Ook JupyterLab gaan we installeren met behulp van de Python package manager pip, en niet met het systeem, omdat deze in de systeemrepository verouderd kan zijn, en daarom moeten we handmatig de afhankelijkheden voor hem oplossen door de volgende pakketten te installeren ā€” python3 python3-dev gcc libc-dev zeromq-dev:

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

We updaten de python-modules en de package manager pip naar de laatste versie:

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

Instellen JupyterLab via de package manager pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Aangezien de extensies in JupyterLab zijn experimenteel en worden officieel niet geleverd met het jupyterlab-pakket, daarom moeten we dit handmatig installeren en configureren.

Laten we NodeJS en de pakketbeheerder daarvoor ā€” NPM ā€” installeren, aangezien JupyterLab ze worden gebruikt voor zijn uitbreidingen:

lxc exec jupyterlab -- apk add nodejs npm

Om de uitbreidingen voor JupyterLab die we installeren te laten werken, moeten ze in de gebruikersdirectory worden geĆÆnstalleerd, aangezien de applicatie als gebruiker zal worden uitgevoerd. jupyterHet probleem is dat er geen parameter is in het opstartcommando waar we de map aan kunnen doorgeven; de applicatie accepteert alleen de omgevingsvariabele en daarom moeten we deze definiĆ«ren. Hiervoor zullen we de exportopdracht voor de variabele opstellen: JUPYTERLAB_DIR in de gebruikersomgeving jupyter, in het bestand .bashrc, dat elke keer wordt uitgevoerd wanneer de gebruiker inlogt:

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

Met de volgende opdracht installeren we een speciale uitbreiding ā€” de extensiebeheerder in 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"

Nu is alles klaar voor de eerste uitvoering JupyterLab, maar we kunnen nog een paar nuttige uitbreidingen installeren:

  • toc ā€” Inhoudsopgave, genereert een lijst van koppen in het artikel/notebook
  • jupyterlab-horizon-theme ā€” UI-thema
  • jupyterlab_neon_theme ā€” UI-thema
  • jupyterlab-ubu-theme ā€” Nog een thema van de auteur van dit artikel šŸ™‚ Maar in dit geval wordt de installatie vanuit de GitHub-repository weergegeven.

Dus voer de volgende opdrachten achtereenvolgens uit om deze uitbreidingen te installeren:

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"

Na de installatie van de uitbreidingen moeten we deze compileren, aangezien we eerder tijdens de installatie de sleutel --no-build hebben opgegeven om tijd te besparen. Nu versnellen we aanzienlijk door ze allemaal tegelijk te compileren:

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

Voer nu de volgende twee opdrachten uit voor de eerste uitvoering. JupyterLabJe zou het met Ć©Ć©n commando kunnen starten, maar in dat geval zal het startcommando, dat je in gedachten houdt, door bash in de container worden opgeslagen en niet op de host, waar al genoeg commando's zijn om in de geschiedenis te worden vastgelegd šŸ™‚

Log in op de container als gebruiker jupyter:

lxc exec jupyterlab -- su -l jupyter

Vervolgens start u JupyterLab met de sleutels en parameters zoals aangegeven:

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

Ga in uw webbrowser naar http://10.0.5.5:8888 en voer op de geopende pagina in token de toegangscode die u in de console ziet. Kopieer deze en plak deze op de pagina, klik vervolgens op Inloggen. Na inloggen gaat u links naar het menu extensies, zoals hieronder afgebeeld, waar u bij het activeren van de extensiebeheerder gevraagd wordt de veiligheidsrisico's te aanvaarden bij het installeren van extensies van derden waarvoor het team JupyterLab ontwikkeling geen verantwoordelijkheid voor draagt:

We starten Jupyter op LXD.

Echter, we isoleren het volledig voor dit doel JupyterLab en plaatsen het in een container, zodat externe extensies die NodeJS vereisen en gebruiken, in ieder geval geen gegevens op de schijf kunnen stelen, behalve diegene die we binnen de container openen. Er zal waarschijnlijk geen toegang zijn tot uw persoonlijke documenten op de host vanuit /home processen in de container, en als het mogelijk is, heeft u daarvoor privileges op bestanden in het hostsysteem nodig, omdat we de container draaien in niet-privilege modus. Op basis van deze informatie kunt u het risico van het inschakelen van extensies in JupyterLab.

Gemaakte IPython-notebooks (pagina's in JupyterLab) worden nu aangemaakt in de thuisdirectory van de gebruiker ā€” /home/jupyter, maar we zijn van plan om data (te delen) tussen de host en de container, dus ga terug naar de console en stop JupyterLab door de sneltoets uit te voeren ā€” CTRL+C en te antwoorden y op de vraag. Breek vervolgens de interactieve gebruikerssessie af jupyter door de sneltoets uit te voeren CTRL+D.

Gegevens delen met de host ^

Om gegevens met de host te delen, moet u een apparaat in de container creƫren dat dit mogelijk maakt en gebruik hiervoor het volgende commando waarbij we de volgende opties opgeven:

  • lxc config device add ā€” Het commando voegt de apparaatsconfiguratie toe
  • jupyter ā€” De identificatie van de container waaraan de configuratie wordt toegevoegd
  • hostfs ā€” De identificatie van het apparaat. U kunt elke naam opgeven.
  • disk ā€” Het type apparaat wordt aangegeven
  • path ā€” Het pad in de container waar LXD dit apparaat zal koppelen
  • source ā€” Geef de bron op, het pad naar de map op de host die u wilt delen met de container. Geef het pad op volgens uw voorkeuren.
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Voor de map /home/dv/projects/ipython-notebooks moet de rechten voor de containergebruiker worden ingesteld, die momenteel een UID heeft gelijk aan SubUID + UID, zie hoofdstuk Beveiliging. Containerprivileges in het artikel Basisfunctionaliteiten van LXD - container systemen in Linux.

Stel de rechten in op de host, waar de eigenaar de containergebruiker zal zijn jupyter, en de variabele $USER zal uw hostgebruiker als groep aanvullen:

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

Hello, World! ^

Als u nog een console-sessie in de container heeft met JupyterLab, herstart deze dan met de nieuwe sleutel --notebook-dir door de waarde op te geven /mnt/hostfs als het pad naar de root van de notebooks in de container voor het apparaat dat we in de vorige stap hebben gemaakt:

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

Ga vervolgens naar de pagina http://10.0.5.5:8888 en maak uw eerste notebook door op de knop op de pagina te klikken zoals aangegeven in de afbeelding hieronder:

We starten Jupyter op LXD.

Voer dan in het veld op de pagina code in de programmeertaal Python in, die de klassieke 4) Ga vanuit de map waar je de voorbeeldcode hebt gedownload naar de map die bevat. Na het invoeren drukt u op CTRL+ENTER of op de knop 'play' op de werkbalk bovenaan zodat JupyterLab dit uitvoert:

We starten Jupyter op LXD.

Bijna alles is nu klaar voor gebruik, maar het zal niet interessant zijn als we geen extra Python-modules (volwaardige applicaties) installeren die de standaardmogelijkheden van Python in JupyterLab, dus laten we verder gaan šŸ™‚

P.S. Het interessante is dat de oude implementatie Jupyter onder de codenaam Jupyter Notebook niks is verdwenen; het bestaat parallel met JupyterLab. Om naar de oude versie te gaan, gaat u naar de link door de suffix/treetoe te voegen, en het overstappen naar de nieuwe versie gebeurt met de suffix /lab, maar het is niet nodig om dit op te geven:

Python-functionaliteit uitbreiden ^

In dit gedeelte installeren we krachtige modules van de programmeertaal Python zoals NumPy, Pandas, Matplotlib, IPyWidgets wiens resultaten worden geĆÆntegreerd in de notebooks. JupyterLab.

Voordat we de genoemde Python-modules via de package manager installeren, pip moeten we eerst de systeemafhankelijkheden in Alpine Linux toestaan:

  • g++ ā€” Nodig voor het compileren van modules, omdat sommige van hen zijn geĆÆmplementeerd in de taal C++ en op runtime aan Python worden gekoppeld als binaire modules.
  • freetype-dev ā€” afhankelijkheid voor de Python-module Matplotlib

Afhankelijkheden installeren:

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

Er is Ć©Ć©n probleem, in de huidige staat van de Alpine Linux-distributie kan een nieuwe versie van NumPy niet worden gecompileerd. Er zal een compilatiefout optreden die ik niet kon oplossen:

FOUT: Kon geen wielen bouwen voor numpy die PEP 517 gebruiken en kunnen niet direct worden geĆÆnstalleerd.

Daarom zullen we deze module installeren als een systeempakket dat al een gecompileerde versie verspreidt, maar iets ouder is dan die op de website beschikbaar is:

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

Vervolgens installeren we de Python-modules via de pakketbeheerder. pipHeb geduld, want sommige modules moeten worden gecompileerd en dit kan een paar minuten duren. Op mijn machine duurde de compilatie ongeveer 15 minuten:

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

We wissen de installatiecache:

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

Modules testen in JupyterLab ^

Als je actief bent JupyterLab, herstart het om de nieuw geĆÆnstalleerde modules te activeren. Druk hiervoor in de console-sessie op CTRL+C waar hij actief is en voer in y op de stop aanvraag, en start dan opnieuw JupyterLab door op de pijl omhoog op het toetsenbord te drukken, zodat je de opdracht niet opnieuw hoeft in te voeren en daarna Enter om te starten:

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

Ga naar de pagina http://10.0.5.5:8888/lab of vernieuw de pagina in de browser, voer daarna de volgende code in een nieuwe cel van de notebook:

%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

Je moet een resultaat krijgen zoals op de onderstaande afbeelding, waar IPyWidgets een UI-element op de pagina genereert dat interactief communiceert met de broncode, en ook Matplotlib de output van de code in de vorm van een afbeelding als functiecurve weergegeven:

We starten Jupyter op LXD.

Veel voorbeelden IPyWidgets kun je vinden in de tutorials. hier

Wat nog meer? ^

Goed gedaan als je bent gebleven en het einde van het artikel hebt bereikt. Ik heb expres geen kant-en-klaar script aan het eind van het artikel geplaatst dat zou installeren JupyterLab in 'Ć©Ć©n klik', om de hardwerkenden te belonen šŸ™‚ Maar je kunt dat zelf doen, omdat je al weet hoe, door de commando's in Ć©Ć©n Bash-script te verzamelen šŸ™‚

Bovendien kun je:

  • Geef een netwerknaam voor de container op in plaats van het IP-adres door het in te voeren in een eenvoudige /etc/hosts en voer in de browser het adres in http://jupyter.local:8888
  • Speel met het beperken van middelen voor de container, lees hiervoor het hoofdstuk in basisfunctionaliteiten van LXD. of krijg meer informatie op de website van de ontwikkelaar van LXD.
  • Verander het thema:

We starten Jupyter op LXD.

En er is nog veel meer dat u kunt! Dat is alles. Ik wens u veel succes!

UPDATE: 15.04.2020 18:30 ā€” Fouten in het hoofdstuk 'Hallo, Wereld!' gecorrigeerd
UPDATE: 16.04.2020 10:00 ā€” Tekst in de beschrijving van het activatiebeheer voor extensies gecorrigeerd en toegevoegd JupyterLab
UPDATE: 16.04.2020 10:40 ā€” Gekende fouten in de tekst gecorrigeerd en het hoofdstuk 'Installatie van basissoftware en systeemconfiguratie' iets verbeterd

Bron: habr.com

Koop betrouwbare webhosting met bescherming tegen DDoS, VPS VDS servers šŸ”„ Koop betrouwbare webhosting met bescherming tegen DDoS, VPS VDS servers | ProHoster