ProHoster > blog > administratie > Lancering van Jupyter in een LXD-baan

Lancering van Jupyter in een LXD-baan

Heb je ooit moeten experimenteren met code of systeemhulpprogramma's in Linux om je geen zorgen te hoeven maken over het basissysteem en niet alles af te breken in het geval van een fout in de code die met rootrechten zou moeten worden uitgevoerd?

Maar hoe zit het met het feit dat u, laten we zeggen, een heel cluster van verschillende microservices op één machine moet testen of uitvoeren? Honderd of zelfs duizend?

Met virtuele machines die worden beheerd door een hypervisor kunnen en zullen dergelijke problemen worden opgelost, maar tegen welke prijs? Een container in LXD gebaseerd op de Alpine Linux-distributie verbruikt bijvoorbeeld alleen 7.60MB RAM, en waar de rootpartitie zich bevindt na het opstarten 9.5MB! Wat vind jij ervan, Elon Musk? Ik raad aan om uit te checken basismogelijkheden van LXD - een containersysteem in Linux

Nadat in het algemeen duidelijk werd wat LXD-containers zijn, laten we verder gaan en nadenken, wat als er zo'n harvesterplatform zou zijn waar je veilig code voor de host kunt uitvoeren, grafieken kunt genereren, UI-widgets dynamisch (interactief) kunt koppelen aan je code, vul de code aan met tekst met blackjack... opmaak? Een soort interactieve blog? Wauw... ik wil het! Wil! 🙂

Kijk onder de kat waar we in een container lanceren jupyter lab - de volgende generatie gebruikersinterface in plaats van de verouderde Jupyter Notebook, en we zullen ook Python-modules installeren zoals NumPy, Pandas, matplotlib, IPyWidgets waarmee je alles hierboven kunt doen en alles kunt opslaan in een speciaal bestand: een IPython-laptop.

Lancering van Jupyter in een LXD-baan

Orbitaal startplan ^

Lancering van Jupyter in een LXD-baan

Laten we een kort actieplan schetsen om het voor ons gemakkelijker te maken het bovenstaande schema te implementeren:

  • Laten we een container installeren en starten op basis van de distributiekit Alpine Linux. We zullen deze distributie gebruiken omdat deze gericht is op minimalisme en er alleen de meest noodzakelijke software in zullen installeren, niets overbodigs.
  • Laten we een extra virtuele schijf aan de container toevoegen en deze een naam geven - hostfs en koppel het aan het rootbestandssysteem. Deze schijf maakt het mogelijk om bestanden op de host te gebruiken vanuit een bepaalde map in de container. Onze gegevens zijn dus onafhankelijk van de container. Als de container wordt verwijderd, blijven de gegevens op de host staan. Dit schema is ook handig voor het delen van dezelfde gegevens tussen veel containers zonder gebruik te maken van de standaard netwerkmechanismen van de containerdistributie.
  • Laten we Bash, sudo en de benodigde bibliotheken installeren, een systeemgebruiker toevoegen en configureren
  • Laten we Python en modules installeren en binaire afhankelijkheden ervoor compileren
  • Laten we installeren en starten jupyter lab, pas het uiterlijk aan, installeer er extensies voor.

In dit artikel beginnen we met het lanceren van de container, we zullen niet overwegen om LXD te installeren en configureren, dit alles vind je in een ander artikel - Basisfuncties van LXD - Linux containersystemen.

Installatie en configuratie van het basissysteem ^

We maken een container met de opdracht waarin we de afbeelding specificeren - alpine3, identificatie voor de container - jupyterlab en, indien nodig, configuratieprofielen:

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

Hier gebruik ik een configuratieprofiel hddroot die specificeert dat er een container moet worden gemaakt met een rootpartitie erin Opslagpool op een fysieke HDD-schijf:

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 geeft mij de mogelijkheid om te experimenteren met containers op de HDD-schijf, waardoor de bronnen van de SSD-schijf worden bespaard, die ook beschikbaar is in mijn systeem 🙂 waarvoor ik een apart configuratieprofiel heb gemaakt ssdroot.

Nadat de container is gemaakt, heeft deze de status STOPPED, dus we moeten het starten door het init-systeem erin uit te voeren:

lxc start jupyterlab

Laten we een lijst met containers in LXD weergeven met behulp van de sleutel -c wat aangeeft welke ckolommen weergeven:

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

Bij het maken van de container is het IP-adres willekeurig gekozen, omdat we een configuratieprofiel gebruikten default die eerder in het artikel is geconfigureerd Basisfuncties van LXD - Linux containersystemen.

We zullen dit IP-adres veranderen in een beter gedenkwaardig adres door een netwerkinterface op containerniveau te maken, en niet op configuratieprofielniveau zoals nu in de huidige configuratie. Je hoeft dit niet te doen, je kunt het overslaan.

Een netwerkinterface maken eth0 die wij koppelen aan de switch (netwerkbrug) lxdbr0 waarin we NAT hebben ingeschakeld volgens het vorige artikel en de container nu toegang heeft tot internet, en we ook een statisch IP-adres aan de interface toewijzen - 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 een apparaat moet de container opnieuw worden opgestart:

lxc restart jupyterlab

De status van de container controleren:

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

Basissoftware installeren en het systeem instellen ^

Om onze container te beheren, moet u de volgende software installeren:

Pakket
Omschrijving

slaan
De GNU Bourne Again-shell

bash-voltooiing
Programmeerbare voltooiing voor de bash-shell

sudo
Geef bepaalde gebruikers de mogelijkheid om bepaalde opdrachten als root uit te voeren

schaduw
Wachtwoord- en accountbeheertoolsuite met ondersteuning voor schaduwbestanden en PAM

tzdata
Bronnen voor tijdzone- en zomertijdgegevens

nano
Pico-editorkloon met verbeteringen

Bovendien kunt u ondersteuning in de manpagina's van het systeem 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 eens kijken naar de opdrachten en toetsen die we gebruikten:

  • lxc — Bel LXD-client
  • exec - LXD-clientmethode die een opdracht in de container uitvoert
  • jupyterlab — Container-ID
  • -- - Een speciale sleutel die aangeeft dat verdere sleutels niet als sleutels voor mogen worden geïnterpreteerd lxc en geef de rest van het touw zoals het is door aan de container
  • apk - Alpine Linux-distributiepakketbeheerder
  • add — Een pakketbeheerdermethode die pakketten installeert die na de opdracht zijn opgegeven

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

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

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

lxc exec jupyterlab -- apk del tzdata

De tijdzone controleren:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Om niet veel tijd te besteden aan het instellen van Bash voor nieuwe gebruikers in de container, zullen we in de volgende stappen kant-en-klare skel-bestanden van het hostsysteem ernaar kopiëren. Hierdoor kun je Bash interactief in een container verfraaien. Mijn hostsysteem is Manjaro Linux en de bestanden worden gekopieerd /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors in principe zijn ze geschikt voor Alpine Linux en veroorzaken ze geen kritieke problemen, maar het kan zijn dat je een andere distributie hebt en dat je zelf moet uitzoeken of er een fout is opgetreden bij het uitvoeren van Bash in de container.

Kopieer de skel-bestanden naar de container. Sleutel --create-dirs zal de benodigde mappen aanmaken als ze 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 bestaande rootgebruiker kopieert u de skel-bestanden die zojuist naar de container zijn gekopieerd 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

Alpine Linux installeert een systeemshell voor gebruikers /bin/sh, wij zullen het vervangen door root gebruiker in Bash:

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

Dat root de gebruiker was niet zonder wachtwoord, hij moet een wachtwoord instellen. De volgende opdracht genereert en stelt een nieuw willekeurig wachtwoord voor hem in, dat u na uitvoering op het consolescherm zult zien:

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 waarvoor we later zullen configureren jupyter lab:

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

Laten we er een wachtwoord voor genereren en instellen:

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

Vervolgens zullen we twee opdrachten uitvoeren, de eerste zal een systeemgroep maken sudo, en de tweede zal er een gebruiker aan toevoegen jupyter:

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

Laten we eens kijken tot welke groepen de gebruiker behoort jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Alles is oké, laten we verder gaan.

Sta alle gebruikers toe die lid zijn van de groep sudo gebruik commando sudo. Om dit te doen, voert u het volgende script uit, waar sed verwijdert commentaar op de parameterregel in het configuratiebestand /etc/sudoers:

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

JupyterLab installeren en configureren ^

jupyter lab is een Python-applicatie, dus we moeten deze tolk eerst installeren. Ook, jupyter lab we zullen installeren met behulp van de Python-pakketbeheerder pip, en niet die van het systeem, omdat deze mogelijk verouderd is in de systeemrepository en daarom moeten we de afhankelijkheden ervan handmatig 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

Laten we Python-modules en pakketbeheer bijwerken pip naar de huidige versie:

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

Ingesteld jupyter lab via pakketbeheerder pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Sinds de uitbreidingen in jupyter lab zijn experimenteel en worden niet officieel meegeleverd met het jupyterlab-pakket, dus we moeten het handmatig installeren en configureren.

Laten we NodeJS en de pakketbeheerder ervoor installeren - NPM, sindsdien jupyter lab gebruikt ze voor zijn extensies:

lxc exec jupyterlab -- apk add nodejs npm

Naar extensies voor jupyter lab die we zullen installeren werkte, ze moeten in de gebruikersmap worden geïnstalleerd, omdat de applicatie vanuit de gebruiker wordt gestart jupyter. Het probleem is dat er geen parameter in het startcommando zit die aan een directory kan worden doorgegeven; de applicatie accepteert alleen een omgevingsvariabele en daarom moeten we deze definiëren. Om dit te doen, zullen we de variabele exportopdracht schrijven JUPYTERLAB_DIR in de gebruikersomgeving jupyter, om te archiveren .bashrcdie 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"

De volgende opdracht installeert een speciale extensie - extensiebeheer in jupyter lab:

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 lancering jupyter lab, maar we kunnen nog steeds een paar nuttige extensies installeren:

  • toc — Inhoudsopgave, genereert een lijst met koppen in een artikel/notitieblok
  • jupyterlab-horizon-theme — UI-thema
  • jupyterlab_neon_theme — UI-thema
  • jupyterlab-ubu-theme - Nog een thema van de auteur dit artikel :) Maar in dit geval wordt de installatie uit de GitHub-repository getoond

Voer dus de volgende opdrachten achtereenvolgens uit om deze extensies 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"

Nadat we de extensies hebben geïnstalleerd, moeten we ze compileren, omdat we eerder tijdens de installatie de sleutel hebben opgegeven --no-build tijd besparen. Nu gaan we het aanzienlijk versnellen door ze in één keer samen te stellen:

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 om het voor de eerste keer uit te voeren jupyter lab. Het zou mogelijk zijn om het met één commando te starten, maar in dit geval wordt het startcommando, dat moeilijk te onthouden is in je hoofd, onthouden door bash in de container, en niet op de host, waar er al voldoende commando's zijn om ze vast te leggen in de geschiedenis :)

Log als gebruiker in op de container jupyter:

lxc exec jupyterlab -- su -l jupyter

Ren vervolgens jupyter lab met sleutels en parameters zoals aangegeven:

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

Ga naar het adres in uw webbrowser http://10.0.5.5:8888 en op de pagina die wordt geopend, typt u teken toegang die u in de console ziet. Kopieer en plak het op de pagina en klik vervolgens Inloggen. Ga na het inloggen naar het extensiesmenu aan de linkerkant, zoals weergegeven in onderstaande figuur, waar u bij het activeren van de extensiemanager wordt gevraagd veiligheidsrisico's te nemen door extensies te installeren van derden waarvoor het commando JupyterLab-ontwikkeling is niet verantwoordelijk:

Lancering van Jupyter in een LXD-baan

We isoleren echter het geheel jupyter lab en plaats het in een container zodat extensies van derden die NodeJS nodig hebben en gebruiken op zijn minst geen andere gegevens op de schijf kunnen stelen dan de gegevens die we in de container openen. Ga naar uw privédocumenten op de host /home Het is onwaarschijnlijk dat processen uit de container zullen slagen, en als dat wel het geval is, moet u rechten hebben op bestanden op het hostsysteem, aangezien we de container draaien in onbevoegde modus. Op basis van deze informatie kunt u het risico van het opnemen van extensies inschatten jupyter lab.

IPython-notebooks gemaakt (pagina's in jupyter lab) wordt nu aangemaakt in de homedirectory van de gebruiker - /home/jupyter, maar onze plannen zijn om de gegevens (delen) te splitsen tussen de host en de container, dus keer terug naar de console en stop jupyter lab door een sneltoets uit te voeren - CTRL+C en beantwoorden y op verzoek. Beëindig vervolgens de interactieve sessie van de gebruiker jupyter het invullen van een sneltoets CTRL+D.

Gegevens delen met de host ^

Om gegevens met de host te delen, moet u een apparaat in de container maken waarmee u dit kunt doen. Voer hiervoor de volgende opdracht uit, waarbij we de volgende sleutels opgeven:

  • lxc config device add — De opdracht voegt de apparaatconfiguratie toe
  • jupyter — ID van de container waaraan de configuratie is toegevoegd
  • hostfs - Apparaat ID. U kunt elke naam instellen.
  • disk — Het type apparaat wordt aangegeven
  • path — Specificeert het pad in de container waarop LXD dit apparaat zal koppelen
  • source — Geef de bron op, het pad naar de map op de host die u met de container wilt delen. 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 catalogus /home/dv/projects/ipython-notebooks toestemming moet worden ingesteld op de containergebruiker die momenteel een UID heeft die gelijk is aan SubUID + UID, zie hoofdstuk Veiligheid. Containerrechten in artikel Basisfuncties van LXD - Linux containersystemen.

Stel de machtiging in op de host, waarbij de eigenaar de containergebruiker zal zijn jupyteren de variabele $USER specificeert uw hostgebruiker als een groep:

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

Hallo Wereld! ^

Als u nog steeds een consolesessie geopend heeft in de container met jupyter laben start het vervolgens opnieuw op met een nieuwe sleutel --notebook-dir door de waarde in te stellen /mnt/hostfs als het pad naar de root van de laptops 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 dan naar de pagina http://10.0.5.5:8888 en maak uw eerste laptop door op de knop op de pagina te klikken, zoals weergegeven in de onderstaande afbeelding:

Lancering van Jupyter in een LXD-baan

Voer vervolgens in het veld op de pagina de Python-code in waarmee de klassieker wordt weergegeven Hello World!. Als u klaar bent met invoeren, drukt u op CTRL+ENTER of de knop "afspelen" op de werkbalk bovenaan om JupyterLab dit te laten doen:

Lancering van Jupyter in een LXD-baan

Op dit punt is bijna alles klaar voor gebruik, maar het zal oninteressant zijn als we geen extra Python-modules (volwaardige applicaties) installeren die de standaardmogelijkheden van Python aanzienlijk kunnen uitbreiden jupyter labdus laten we verder gaan :)

PS Het interessante is dat de oude implementatie Jupiterpy onder codenaam Jupyter Notebook is niet verdwenen en bestaat parallel met jupyter lab. Om naar de oude versie over te schakelen, volgt u de link waarbij u het achtervoegsel aan het adres toevoegt/tree, en de overgang naar de nieuwe versie wordt uitgevoerd met het achtervoegsel /lab, maar het hoeft niet te worden gespecificeerd:

De mogelijkheden van Python uitbreiden ^

In deze sectie zullen we krachtige Python-taalmodules installeren als NumPy, Pandas, matplotlib, IPyWidgets waarvan de resultaten in laptops worden geïntegreerd jupyter lab.

Voordat u de vermelde Python-modules installeert via pakketbeheer pip we moeten eerst de systeemafhankelijkheden in Alpine Linux oplossen:

  • g++ — Nodig voor het compileren van modules, omdat sommige ervan in de taal zijn geïmplementeerd C + + en maak tijdens runtime verbinding met Python als binaire modules
  • freetype-dev - afhankelijkheid voor 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 zal het niet mogelijk zijn om de nieuwe versie van NumPy te compileren; er zal een compilatiefout verschijnen die ik niet kon oplossen:

FOUT: Kan geen wielen bouwen voor numpy die PEP 517 gebruiken en kunnen niet rechtstreeks worden geïnstalleerd

Daarom zullen we deze module installeren als een systeempakket dat een reeds gecompileerde versie distribueert, maar iets ouder dan wat momenteel beschikbaar is op de site:

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

Installeer vervolgens Python-modules via pakketbeheer pip. Even geduld, want sommige modules worden gecompileerd en dit kan een paar minuten duren. Op mijn computer duurde de compilatie ongeveer 15 minuten:

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

Installatiecaches wissen:

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

Modules testen in JupyterLab ^

Als je aan het rennen bent jupyter lab, start het opnieuw op zodat de nieuw geïnstalleerde modules worden geactiveerd. Om dit te doen, klikt u in een consolesessie op CTRL+C waar je het laat draaien en ga naar binnen y om het verzoek te stoppen en vervolgens opnieuw te beginnen jupyter lab door op de pijl-omhoog op het toetsenbord te drukken, zodat u de opdracht niet steeds opnieuw hoeft in te voeren Enter om het 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 uw browser en voer vervolgens de volgende code in een nieuwe notebookcel 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

U zou een resultaat moeten krijgen zoals in de onderstaande afbeelding, waar IPyWidgets genereert een UI-element op de pagina dat interactief samenwerkt met de broncode, en ook matplotlib geeft het resultaat van de code weer in de vorm van een afbeelding als functiegrafiek:

Lancering van Jupyter in een LXD-baan

Veel voorbeelden IPyWidgets je kunt het vinden in tutorials hier

Wat nog meer? ^

Goed gedaan als je bent gebleven en het einde van het artikel hebt bereikt. Ik heb bewust geen kant-en-klaar script aan het einde van het artikel geplaatst dat zou installeren jupyter lab in "één klik" om werknemers aan te moedigen :) Maar je kunt het zelf doen, omdat je al weet hoe, nadat je de commando's in één enkel Bash-script hebt verzameld :)

Je kan ook:

  • Stel een netwerknaam voor de container in in plaats van een IP-adres door deze in een eenvoudig bestand te schrijven /etc/hosts en typ het adres in de browser http://jupyter.local:8888
  • Speel met de resourcelimiet voor de container, lees hiervoor het hoofdstuk in basis LXD-mogelijkheden of krijg meer informatie op de LXD-ontwikkelaarssite.
  • Verander het thema:

Lancering van Jupyter in een LXD-baan

En je kunt nog veel meer doen! Dat is alles. Ik wens je succes!

UPDATE: 15.04.2020-18-30 XNUMX:XNUMX - Fouten gecorrigeerd in het hoofdstuk “Hallo wereld!”
UPDATE: 16.04.2020-10-00 XNUMX:XNUMX uur — Tekst gecorrigeerd en toegevoegd in de beschrijving van activering van extensiebeheer jupyter lab
UPDATE: 16.04.2020-10-40 XNUMX:XNUMX uur — Fouten in de tekst gecorrigeerd en het hoofdstuk “Basissoftware installeren en het systeem instellen” enigszins ten goede gewijzigd

Bron: www.habr.com

Voeg een reactie