Käivitame Jupyter LXD-sse

Kas oled kunagi pidanud katsetama koodi või süsteemiteenuseid Linuxis nii, et ei peaks muretsema base süsteemi pärast ja ei hävita kõike, kui kood, mis vajab root-privileege, ebaõnnestub?

Ent kuidas oleks näiteks testida või käivitada terve klaster erinevaid mikroteenuseid ühel masinal? Saja või isegi tuhande?

Virtuaalmasinate puhul, mida haldab hüperviisor, on selliseid ülesandeid küll võimalik lahendada, kuid kui suure hinnaga? Näiteks Alpine Linuxi põhine LXD konteiner tarbib minimaalselt ainult 7.60MB RAM-i, ja kusjuures juurduse jagu pärast käivitamist võtab 9.5MB! Kuidas sulle selline lähtepunkt sobib, Elon Musk? Soovitan tutvuda LXD põhifunktsioonidega — konteinerisüsteem Linuxis

Peale seda, kui saime üldiselt aru, mis on LXD konteinerid, edasi liikudes mõtleme, mis oleks, kui oleks olemas selline platvorm-kombain, kus saaks turvaliselt käivitada hosti koodi, genereerida graafikuid, dünaamiliselt (interaktiivselt) siduda UI vidinaid oma koodiga, täiendada koodi tekstiga mustade kaartidega... vormindamine? Midagi nagu interaktiivne blogi? Vau… Tahan! Tahan! 🙂

Vaata allapoole, kus käivitame konteineris JupyterLab — järgmise põlvkonna kasutajaliides, mis asendab vananenud Jupyter Notebook'i, ning installime sellised Python'i moodulid nagu NumPy, Pandas, Matplotlib, IPyWidgets mis võimaldavad teha kõik eelnevalt loetletud ja salvestada see kõik spetsiaalsesse faili — IPython'i märkmikusse.

Navigeerimine

• Orbitaalne tõusupäev
• Põhisüsteemi installimine ja seadistamine
• Põhiprogrammi installimine ja süsteemi seadistamine
• JupyterLab'i installimine ja seadistamine
• Jagame andmeid hostiga
• Tere, maailm!
• Kohandame Python'i võimalusi
• Testime mooduleid JupyterLab'is
• Mis veel?

Orbitaalne tõusupäev ^

Koostame lühikese tegevuskava, et oleks lihtsam ellu viia ülaltoodud skeem:

• Installime ja käivitame konteineri jaotuse põhjal Alpine Linux. Me kasutame seda distributsiooni, kuna see on suunatud minimaalismile ja installime sinna vaid kõige vajalikuma tarkvara, mitte midagi üleliigset.
• Lisame konteinerisse täiendava virtuaalse ketta, millele anname nime — hostfs ja mountime selle juurfailisüsteemi. See ketas võimaldab kasutada hostis olevaid faile määratud kataloogist konteineris. Sellisel viisil jäävad andmed meie jaoks konteinerist sõltumatuks. Kui konteiner kustutatakse, jäävad andmed hostisse. Samuti on see skeem kasulik, et jagada andmeid mitme konteineri vahel, ilma et kasutada konteineri distributsiooni sisemisi võrgu mehhanisme.
• Installime Bash'i, sudo, vajalikud raamatukogud, lisame ja seadistame süsteemi kasutajat
• Installime Python'i, moodulid ja kompileerime nende jaoks binaarsed sõltuvused.
• Installime ja käivitusime JupyterLab, seadistame välimuse, installime laiendused.

Selles artiklis alustame konteineri käivitamisest, me ei käsitle LXD installimist ja seadistamist, kogu selle teavet leiate teisest artiklist — Alusvõimekus LXD — konteinerite süsteem Linuxis..

Põhisüsteemi installimine ja seadistamine ^

Loome konteineri käsu abil, kus määrame pildi — alpine3, konteineri identifikaator — jupyterlab ja vajadusel konfigureerimisprofiilid:

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

Siin kasutan ma konfigureerimisprofiili hddroot mille eesmärk on luua konteiner root-partitsiooniga Storage Pool mis asub füüsilisel HDD-diskil:

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

See võimaldab mul eksperimenteerida konteineritega HDD-diskil, säästes SSD-diskilt ressursse, mis samuti minu süsteemis olemas 🙂, millele olen loonud eraldi konfigureerimisprofiili. ssdroot.

Pärast konteineri loomist on see seisundis PEATUD, seega peame selle käivitama, käivitades seal init-süsteemi:

lxc start jupyterlab

Vaatame LXD-s konteinerite loendit, kasutades võtit -c mis näitab, millised cveergudest kuvatakse ekraanil:

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

Konteineri loomisel valiti IP-aadress juhuslikult, kuna kasutasime varem konfigureeritud profiili default mis oli eelnevalt seadistatud artiklis Alusvõimekus LXD — konteinerite süsteem Linuxis..

Muudame selle IP-aadressi meeldejäävamaks, luues võrguhoova konteineri tasemel, mitte konfiguratsiooniprofiili tasemel, nagu see praeguses konfiguratsioonis on. Seda ei ole kohustuslik teha, võite selle vahele jätta.

Loome võrguhoova eth0 mille lingime lülitiga (võrgusillaga) lxdbr0 kus oleme eelmine kord NAT-i sisse lülitanud ja konteineril on nüüd juurdepääs internetile, samuti määrame liidesele staatilise IP-aadressi — 10.0.5.5:

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

Pärast seadme lisamist tuleb konteiner taaskäivitada:

lxc restart jupyterlab

Kontrollime konteineri staatust:

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

Põhiprogrammi installimine ja süsteemi seadistamine ^

Meie konteineri haldamiseks on vajalik paigaldada järgmine tarkvara:

Paketid
Kirjeldus

bash
GNU Bourne Again shell

bash-completion
Programmable completion for the bash shell

sudo
Anna teatavatele kasutajatele võimalus käivitada mõned käsklused administraatori õigustes

shadow
Parooli ja konto haldamise tööriistade komplekt, mis toetab shadow-faile ja PAM-i

tzdata
Ajakohastatud andmed ajavööndite ja suveaja kohta

nano
Pico redaktori kloon, millel on täiendused

Lisaks võite paigaldada man-lehekülgede toe, installides järgmised paketid — man man-pages mdocml-apropos less

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

Analüüsime käsklusi ja lüliteid, mida kasutasime:

• lxc — LXD kliendi kutse
• exec — LXD kliendi meetod, mis käivitab käsu konteineris
• jupyterlab — Konteineri identifikaator
• -- — Eriline lüliti, mis näitab, et edasisi lüliteid ei tohi tõlgendada lxc ja edastada kogu ülejäänud rea sellisena konteinerisse
• apk — Alpine Linuxi jaotise pakihaldur
• add — Pakihalduri meetod, mis installib käsu järel nimetatud paketid

Edasi, seadistame süsteemis ajavööndi Europe/Moscow:

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

Pärast ajavööndi seadistamist on pakett tzdata süsteemis enam vajalik, see võtab ruumi, seega eemaldame selle:

lxc exec jupyterlab -- apk del tzdata

Kontrollime ajavööndi:

lxc exec jupyterlab -- date

Kolmapäev Apr 15 10:49:56 MSK 2020

Ettevaatlikult aega säästmata Bash-i seadistamisel konteineris uutele kasutajatele kopeerime järgmiste toimingutega valmiskujul skel-failid kohalikust süsteemist. See võimaldab Bash-i ilu konteineris interaktiivses režiimis. Minu kohalik süsteem on Manjaro Linux ja kopeeritud failid /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors sobivad põhimõtteliselt ka Alpine Linuxile ning ei tekita kriitilisi probleeme, kuid teil võib olla mõni muu distributsioon ja peate vigade korral ise toime tulema, kui Bash konteineris ei käivitu.

Kopeerime skel-failid konteinerisse. Võti --create-dirs loob vajalikud kataloogid, kui neid ei ole:

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

Olemasolevale root-kasutajale kopeerime kodukatalooge just äsja konteinerisse kopeeritud skel-failid:

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 Linuxis installitakse kasutajatele süsteemi kest, /bin/shme vahetame selle root kasutajal Bash-i vastu:

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

Et root kasutaja ei olnud paroolita, tal tuleb seada parool. Järgmine käsk genereerib ja seadistab talle uue juhusliku parooli, mille näete pärast selle täitmist konsooliekraanil:

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

Loome ka uue süsteemse kasutaja — jupyter kellele seadistame hiljem JupyterLab:

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

Genereerime ja seadistame talle parooli:

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

Edasi täidame kaks käsku, esimene loob süsteemi grupi sudo, teine aga lisab sellesse kasutaja jupyter:

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

Vaata, millistesse gruppidesse kasutaja kuulub jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Kõik – selge, liigume edasi.

Lubame kõigil kasutajatel, kes kuuluvad gruppi sudo kasutada käsku sudo. Selleks täitke järgmine skript, kus sed kommenteerib konfigureerimisfaili parameetri rea välja /etc/sudoers:

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

JupyterLab'i installimine ja seadistamine ^

JupyterLab — see on Python rakendus, seega peame esmalt selle tõlgendi installima. Samuti, JupyterLab me installime pythoniga seotud paketihalduri abil, pip, mitte süsteemihalduri kaudu, kuna süsteemide registris võib see olla aegunud, ja seetõttu peame käsitsi sõltuvused lahendama, installides järgmised paketid — python3 python3-dev gcc libc-dev zeromq-dev:

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

Uuendame pythonimoodulid ja paketihalduri pip aktuaalsele versioonile:

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

Paigaldame JupyterLab paketihalduri kaudu pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Kuna laiendused JupyterLab on eksperimentaalsed ja ametlikult ei tule need koos jupyterlabi paketiga, seega peame selle installima ja seadistama käsitsi.

Installime NodeJS ja selle paketihalduri — NPM, kuna JupyterLab kasutab neid oma laiendustes:

lxc exec jupyterlab -- apk add nodejs npm

Kuna laiendused, mille me installime, peavad töötama, tuleb need installida kasutajakausta, kuna rakendus käivitatakse kasutaja alt. JupyterLab mida me installime, tuleb paigaldada kasutaja katalooge, kuna rakendus käivitub kasutaja alt jupyter. Probleem on see, et käivituskäsk ei sisalda parameetrit katalooge edastamiseks, rakendus tunnustab ainult keskkonnamuutujat, seega peame selle määratlema. Selleks kirjutame muutujate eksportimise käsu. JUPYTERLAB_DIR kasutaja keskkonnas jupyter, faili .bashrc, mida täidetakse iga kord, kui kasutaja süsteemi siseneb:

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

Järgmiseks käskime paigaldada spetsiaalse laienduse — laienduste halduri 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"

Nüüd on kõik valmis esimese käivituse jaoks JupyterLab, kuid me saame paigaldada veel mõned kasulikud laiendused:

• toc — Sisukord, genereerib nimekirja pealkirjadest artiklis/notebookis
• jupyterlab-horizon-theme — UI kujundusteema
• jupyterlab_neon_theme — UI kujundusteema
• jupyterlab-ubu-theme — Veel üks kujundusteema autori selle artikli 🙂 Kuid sel juhul kuvatakse paigaldus GitHubi repost.

Seega käivitage järjestikku järgmised käsud, et need laiendused paigaldada:

lxc exec jupyterlab -- su -l jupyter -c "export JUPYTERLAB_DIR=$HOME/.local/share/jupyter/lab; jupyter labextension install --no-build @jupyterlab/toc @mohirio/jupyterlab-horizon-theme @yeebc/jupyterlab_neon_theme"

lxc exec jupyterlab -- su -l jupyter -c "wget -c https://github.com/microcoder/jupyterlab-ubu-theme/archive/master.zip"

lxc exec jupyterlab -- su -l jupyter -c "unzip -q master.zip && rm master.zip"

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

lxc exec jupyterlab -- su -l jupyter -c "rm -r jupyterlab-ubu-theme-master"

Pärast laiendite installimist peame need kompileerima, nagu enne, installimise käigus kasutasime võtme --no-build aja säästmiseks. Nüüd kiirendame oluliselt, kompileerides need koos ühe korraga:

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

Nüüd käivitage järgmised kaks käsku esmakordseks käivitamiseks JupyterLab. Ühe käsuga oleks võimalik see käivitada, kuid sel juhul jääb käivituskäsk, mida vaimus hoida, bash’i konteinerisse talletuma, mitte hostisse, kus on juba piisavalt käske ajaloosse kirjutamiseks 🙂

Logige konteineris sisse kasutajana jupyter:

lxc exec jupyterlab -- su -l jupyter

Seejärel käivitage JupyterLab võtmete ja parameetritega nagu näidatud:

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

Avage veebibrauseris aadressil http://10.0.5.5:8888 ja ja avatud lehe, sisestage token juurdepääs, mille näete konsoolis. Kopeerige see ja kleepige lehele, seejärel vajutage Logi sisse. Pärast sisselogimist minge vasakul laiendite menüüsse, nagu on näidatud alloleval pildil, kus teile pakutakse laiendihalduri aktiveerimisel võtta endale turvariskid, installides kolmandate osade laiendeid, mille eest meeskond JupyterLabi arendus ei vastuta:

Kuid me isoleerime selle täielikult JupyterLab ja paneme selle konteinerisse, et kolmandad osalised laiendused, mis nõuavad ja kasutavad NodeJS-d, ei saaks vähemalt andmeid kettale varastada, välja arvatud need, mida avame konteineris. Ligipääs teie privaatsetele dokumentidele hostis /home konteineri protsessidest ei õnnestu tõenäoliselt, ja kui ka õnnestub, siis selleks on vaja failides privileege hostisüsteemis, kuna käitame konteinerit ilma privileegideta. Selle teabe põhjal saate hinnata riskide taset laiendite lubamisel JupyterLab.

Loodud IPythoni märkmikud (lehed JupyterLab) luuakse nüüd kasutaja kodukaustas — /home/jupyter, kuid meie plaanid on jagada andmeid (jagada) hosti ja konteineri vahel, seega minge tagasi konsooli ja peatage JupyterLab kasutades hotkey-d — CTRL+C ja vastake y päringule. Seejärel katkestage kasutaja interaktiivne seanss jupyter kasutades hotkey-d CTRL+D.

Jagame andmeid hostiga ^

Et jagada andmeid hostiga, tuleb konteineris luua seade, mis seda võimaldab, ja selleks käivitage järgmine käsk, kus näitame järgmisi võtmeid:

• lxc config device add — Käsk lisab seadme konfiguratsiooni
• jupyter — Konteineri identifikaator, kuhu konfiguratsioon lisatakse
• hostfs — Seadmestiku identifikaator. Saate määrata ükskõik millise nime.
• disk — Näitab seadme tüüpi
• failitee — Näitab teed konteineris, kuhu LXD selle seadme mountib
• source — Näitab allikat, teed katalooge hostis, mida soovite konteineriga jagada. Määrake tee vastavalt oma eelistustele

lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Katalooge /home/dv/projects/ipython-notebooks peab olema määratud konteineri kasutajale, kellel on praegu UID, mis on võrdne SubUID + UID, vaadake peatükki Turvalisus. Konteinerite õigused artiklis Alusvõimekus LXD — konteinerite süsteem Linuxis..

Seame kohalike õigusi hostis, kus konteineri kasutaja on omanik jupyter, ja muutuja $USER määrab teie hosti kasutaja grupina:

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

Tere, maailm! ^

Kui teil on konteineris juba avatud konsoolisessioon JupyterLab, siis taaskäivitage see uue võtmega --notebook-dir andmisega /mnt/hostfs kui teed, mis viitab konteineris loodud seadme juurikale:

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

Seejärel minge lehele http://10.0.5.5:8888 ja looge oma esimene sülearvuti, klõpsates alloleval pildil näidatud nuppu:

Seejärel sisestage lehe väljal Pythonis kood, mis väljendab klassikalist Hello World!. Sisestamise lõpus vajutage CTRL+ENTER või nuppu «play» ülemise tööriistariba peal, et JupyterLab seda käivitaks:

Sellega on peaaegu kõik kasutamiseks valmis, kuid see ei oleks huvitav, kui me ei installi täiendavaid Python-mooduleid (täisrakendusi), mis võimaldavad oluliselt laiendada Python'i standardvõimeid JupyterLab, seega liikume edasi 🙂

P.S. Huvi pakub, et vana teostus Jupyter koodinimega Jupyter Notebook ei ole kuhugi kadunud ja see eksisteerib paralleelselt JupyterLab. Vana versiooni minemiseks minge lingile, lisades aadressile suffiksi/tree, uus versioon on saadaval suffiksiga /lab, kuid seda pole tingimata vaja märkida:

• Jupyter Notebook — http://10.0.5.5:8888/tree
• Jupyter Lab — http://10.0.5.5:8888/lab

Kohandame Python'i võimalusi ^

Selles osas installime võimsad Python'i moodulid nagu NumPy, Pandas, Matplotlib, IPyWidgets mille töö tulemused integreeritakse raamatutesse JupyterLab.

Enne kui installime loetletud Python'i moodulid paketihalduri kaudu pip peame esmalt lahendama süsteemi sõltuvused Alpine Linuxis:

• g++ — Vajalik moodulite kompileerimiseks, kuna mõned neist on kirjutatud keeles C++ ja liidetakse Python'iga tööajal kui binaarsed moodulid
• freetype-dev — sõltuvus Python'i moodulile Matplotlib

Installeerime sõltuvused:

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

On üks probleem, praeguses Alpine Linuxi jaotuses ei õnnestu meil kompileerida uut versiooni NumPy'st, kompileerimise viga, mille lahendamine mul ei õnnestunud:

ERROR: Could not build wheels for numpy which use PEP 517 and cannot be installed directly

Seega installime selle mooduli kui süsteemipaketi, mis jagab juba kompileeritud versiooni, kuid see on veidi vanem kui praegu veebisaidil saadaval:

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

Seejärel installime Pythoni moodulid paketihalduri kaudu pip. Olge kannatlik, kuna mõned moodulid kompileeritakse ja see võtab paar minutit. Minu masinas kestis kompileerimine umbes 15 minutit:

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

Kustutame installatsiooni vahemälud:

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

Testime mooduleid JupyterLab'is ^

Kui see on käivitatud JupyterLab, taaskäivitage see, et uued installitud moodulid aktiveeruksid. Selleks vajutage konsoolis CTRL+C seal, kus see on käivitatud, ja sisestage y peatumise korral. JupyterLab Seejärel käivitage uuesti, vajutades klaviatuuril noole üles, et command't uuesti sisestada, ja seejärel Enter käivitamiseks:

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

Minge lehele http://10.0.5.5:8888/lab või värskendage brauseris lehte ning seejärel sisestage järgmine kood uude notebuki rakkusse:

%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

Te peate saama tulemuse nagu alloleval pildil, kus IPyWidgets genereerib lehelt UI-elementi, mis suhtleb interaktiivselt lähtekoodiga, samuti Matplotlib kuvab koodi tulemuse pildi kujul nagu funktsiooni graafik:

Paljusid näiteid IPyWidgets võite leida õpetustes siit

Mis veel? ^

Te olete tublid, kui jõudsite artikli lõpuni. Ma ei soovinud artikli lõpus valmis skripti jagada, mis installiks JupyterLab "ühe klikiga", et julgustada töötajaid 🙂 Kuid te saate seda teha ise, kuna te juba teate, kuidas, kogudes käsud ühte Bash skripti 🙂

Samuti võite:

• Seada konteineri võrgunime IP-aadressi asemel, kirjutades selle lihtsasse /etc/hosts ja brauseris aadressi tippida http://jupyter.local:8888
• Mängida konteineri ressursside piirangutega, selleks lugege peatükki LXD põhivõimalustest või hankige täiendavat teavet LXD arendaja veebisaidilt.
• Vahetada teema:

Ja veel palju muud saate teha! Sellega on kõik. Soovin teile edu!

UUENDUS: 15.04.2020 18:30 — Parandasin vead peatükis "Tere, maailm!"
UUENDUS: 16.04.2020 10:00 — Kohandasin ja lisasin teksti laiendite halduri aktiveerimise kirjelduse JupyterLab
UUENDUS: 16.04.2020 10:40 — Parandasin tekstis leitud vigu ja muutsin pisut paremaks peatüki "Põhirtarkvara installimine ja süsteemi seadistamine".

Allikas: habr.com