Käivitame Jupyter LXD orbiidil

Kas oled katsetanud koodi või süsteemi utiliite Linuxis viisil, et mitte karta põhiosade purunemist ja mitte hävitada kõike, kui kood, mis peaks käivituma, on root-privileegidega?

Ent kuidas on selle kahtluse korral, et näiteks on vaja testida või käivitada terve klaster erinevaid mikroteenuseid ühel masinal? Sadakond või isegi tuhat?

Hüperviisori haldustel on virtuaalmasinate kaudu selliseid ülesandeid võimalik täita, kuid mis hinnaga? Näiteks LXD konteiner Alpine Linux’i jaotuses tarbib minimaalselt vaid 7.60MB RAM-i, ja kusjuures juurepartitsioon pärast käivitamist hõivab 9.5MB! Kuidas sulle selline idee meeldib, Elon Musk? Soovitan tutvuda LXD põhivõimalustega — konteinerite süsteem Linuxis.

Kui üldiselt on selge, mis on LXD konteinerid, liigume edasi ja mõtleme, mis siis, kui oleks olemas selline platvorm-kombain, kus saaks ohutult käivitada hosti jaoks koodi, genereerida graafikuid, dünaamiliselt (interaktiivselt) siduda UI-vidinaid oma koodiga, täiendada koodi tekstiga mustade kasino… vormindamisega? Midagi nagu interaktiivne blogi? Vau… Tahaks! Tahaks! 🙂

Vaata allpool, kus me käivitame konteineris JupyterLab — järgmise põlvkonna kasutajaliidese, mis asendab vananenud Jupyter Notebook'i, ning paigaldame ka sellised Python'i moodulid nagu NumPy, Pandas, Matplotlib, IPyWidgets mis võimaldavad teha kõike ülaltoodut ja salvestada selle kõik spetsiaalsesse faili — IPython'i märkmikus.

Navigeerimine

• Orbitaalne tõusuplaan
• Algsüsteemi paigaldamine ja seadistamine
• Baassofti paigaldamine ja seadistamine
• JupyterLab'i paigaldamine ja seadistamine
• Andmete jagamine hostiga
• Tere, maailm!
• Python'i võimaluste laiendamine
• Moodulite testimine JupyterLab'is
• Mis veel?

Orbitaalne tõusuplaan ^

Koostame lühikese tegevusplaani, et meil oleks lihtsam ülaltoodud skeemi teostada:

• Paigaldame ja käivitame konteineri Alpine Linux'i jaotusel Alpine Linux. Kasutame seda jaotust, kuna see on suunatud minimalismile ja paigaldame sinna ainult kõige vajalikuma tarkvara, mitte midagi üleliigset.
• Lisame konteiners ühe täiendava virtuaalse kõvaketta, millele anname nime — hostfs ja paigaldame selle juurdete väitäle. See ketas annab võimaluse kasutada faile hostis antud kataloogist konteineris. Sellega on meie andmed konteinerist sõltumatud. Kui konteiner eemaldatakse, jäävad andmed hostisse. Samuti on see skeem kasulik, et jagada andmeid mitme konteineri vahel, kasutamata konteineri väljastpoolne võrgu mehhanisme.
• Paigaldame Bash'i, sudo, vajalikke teeke, lisame ja seadistame süsteemikasutaja.
• Paigaldame Python'i, moodulid ja kompileerime nende jaoks binaarset sõltuvust.
• Paigaldame ja käivitame. JupyterLab, seadistame välimust, paigaldame laiendusi selle jaoks.

Selles artiklis alustame konteineri käivitamisest, me ei käsitle LXD seadistamist ja paigaldamist, seda võite leida teises artiklis - LXD põhifunktsioonid — konteinerisüsteem Linuxis.

Algsüsteemi paigaldamine ja seadistamine ^

Loome konteineri käsuga, kus määrame pildi - alpine3, konteineri ID - jupyterlab ja vajadusel konfiguratsiooniprofiilid:

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

Siin kasutan konfiguratsiooniprofiili hddroot mis näitab, et konteiner luuakse root-partitsiooniga Säilitustorn mis asub füüsilisel HDD kettal:

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 annab mulle võimaluse katsetada konteineri HDD kettal, säästes SSD ketta ressursse, mis samuti minu süsteemis on 🙂, mille jaoks mul on loodud eraldi konfiguratsiooniprofiil. ssdroot.

Pärast konteineri loomist on see seisundis STOPPIND, seega peame selle käivitama, kolmendades initsüsteemi:

lxc start jupyterlab

Kuvame LXD konteinerite nimekirja, kasutades võtme -c mis määrab, millised cveergud kuvada ekraanile:

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 konfiguratsiooniprofiili Seejärel käivitame exec käsu ja ootame 5000 sekundit, et jätkata jälgimist: mis oli eelnevalt seadistatud artiklis LXD põhifunktsioonid — konteinerisüsteem Linuxis.

Muudame selle IP aadressi kergemini meeldejäävaks, luues võrgu liidese konteineri tasemel, mitte konfiguratsiooniprofiili tasemel nagu see praeguses konfiguratsioonis on. See ei ole tingimata vajalik, saate selle vahele jätta.

Loome võrgu liidese eth0 mille ühendame lülitiga (võrgusilla) lxdbr0 kus me lubasime NAT eelnevas artiklis 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      |
+------------+---------+------------------+--------------+

Baassofti paigaldamine ja seadistamine ^

Konteineri haldamiseks tuleb installida järgmised tarkvarad:

Package
Kirjeldus

bash
GNU Bourne Again shell

bash-completion
Programmable completion for the bash shell

sudo
Anna teatud kasutajatele võimalus käitada mõned käsud rootina

shadow
Parooli- ja konto haldustööriistade komplekt, mis toetab shadow-failide ja PAM-i kasutamist

tzdata
Allikad ajavööndi ja suveaja andmete jaoks

nano
Pico redaktori kloon täiendustega

Lisaks võite süsteemis man-pages toe installimiseks paigaldada järgmised paketid — man man-pages mdocml-apropos less

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

Vaatame käske ja võtmeid, mida kasutasime:

• lxc — LXD kliendi kutse
• exec — LXD kliendi meetod, mis käivitab käsu konteineris
• jupyterlab — Konteineri identifikaator
• -- — Erakordne võti, mis näitab, et võtmeid ei tõlgendata enam võtmetena lxc ja edastab kogu ülejäänud reas, nagu see on, konteinerile
• apk — Alpine Linuxi jaotise paketihaldur
• add — Paketihalduri meetod, mis installib käsu järel näidatud paketid

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

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

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

lxc exec jupyterlab -- apk del tzdata

Kontrollime ajavööndit:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Et mitte raisata palju aega Bash'i seadistamisele uutele kasutajatele konteineris, järgnevate toimingutega kopeerime sinna host-süsteemist juba valmis skel-failid. See võimaldab muuta Bash'i konteineris interaktiivses režiimis. Minu host-süsteem on Manjaro Linux ja kopeeritavad failid /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors sobivad põhimõtteliselt ka Alpine Linuxile ja ei tekita kriitilisi probleeme, kuid teil võib olla erinev jaotamine ja peate ise tegelema probleemiga, kui käivitatav Bash konteineris ei tööta.

Kopeerime skel-failid konteinerisse. Võti --create-dirs loob vajalikud kaustad, kui need ei eksisteeri:

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

Kuna root-kasutaja eksisteerib, kopeerime just konteinerisse kopeeritud skel-failid tema kodu kausta:

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 on kasutajatele installitud süsteemi shell /bin/sh, me vahetame selle root kasutaja jaoks Bash-iga:

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

Et root kui kasutaja ei olnud paroolita, peab ta parooli seadma. Järgmine käsk genereerib ja seadistab talle uue juhusliku parooli, mille näete konsooli ekraanil pärast selle täitmist:

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

Samuti loome uue süsteemi 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

Seejärel täidame kaks käsku, esimene loob süsteemi rühma sudo, ja teine lisab kasutaja sellesse jupyter:

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

Kontrollime, millistesse rühmadesse kasutaja kuulub jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Kõik on korras, liigume edasi.

Lubame kõigil kasutajatel, kes kuuluvad rühma sudo kasutada käsku sudo. Selleks täitke järgmine skript, mis sed kommenteerib konfiguratsioonifaili parameetrit: /etc/sudoers:

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

JupyterLab'i paigaldamine ja seadistamine ^

JupyterLab — see on Pythoni rakendus, seega peame esmalt installima selle tõlgendi. Samuti, JupyterLab me kavatseme installida Pythonipakettide halduri kaudu pip, mitte süsteemi kaudu, kuna süsteemide registris võib see olla aegunud, ja seetõttu peame käsitsi lubama selle sõltuvused, 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 pakettide halduri pip ajaloolise versioonini:

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

Paigaldame JupyterLab pakettide halduri kaudu pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Kuna laiendused on JupyterLab on eksperimentaalsed ega tule neid ametlikult jupyterlab paketiga, seega peame nad käsitsi installima ja seadistama.

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

lxc exec jupyterlab -- apk add nodejs npm

Kuna laiendused, JupyterLab mida me installime, peavad töötama, tuleb need installida kasutajadiriktiivi, kuna rakendus käivitatakse kasutaja alt. jupyterProbleem on selles, et käivituskomandis pole parameetrit, mille kaudu saaks kausta edastada; rakendus tunnustab ainult keskkonnamuutujat ja seetõttu peame selle määrama. Selleks kirjutame keskkonnamuutujate ekspordi käsu. JUPYTERLAB_DIR kasutaja keskkonnas jupyter, faili .bashrc, mis 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ärgmisel käsul installime 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 esimeseks käivitamiseks, JupyterLabaga saame installida veel mõned kasulikud laiendused:

• toc — Sisukord, genereerib artiklis/notebookis pealkirjade loendi
• jupyterlab-horizon-theme — UI kujundus
• jupyterlab_neon_theme — UI kujundus
• jupyterlab-ubu-theme — Veel üks kujundus autori poolt selle artikli 🙂 Kuid selles juhtumis näidatakse, et installimine toimub GitHubi kaudu.

Seega täitke järjestikku järgmised käsud, et installida need laiendused:

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 laienduste installimist peame need kompileerima, kuna varem, installimisel, määrasime võtme --no-build aega säästa. Nüüd kiirendame oluliselt nende koos kompileerimist.

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

Nüüd täitke järgmised kaks käsku esmakordseks käivitamiseks. JupyterLabSeda oleks võimalik käivitada ühe käsuga, kuid sel juhul jääb käivitamise käsk, mida me mõttes hoiame, bash'i konteinerisse, mitte hostisse, kus käske on juba piisavalt, et neid ajaloos salvestada 🙂

Logime end konteinerisse sisse kui kasutaja jupyter:

lxc exec jupyterlab -- su -l jupyter

Jätkake koos JupyterLab võtmete ja parameetritega nagu on näidatud:

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

Avage veebibrauseris aadress http://10.0.5.5:8888 ja avanenud lehele sisestage token juurdepääsu, mida näete konsoolis. Kopeerige see ja kleepige lehele, seejärel klõpsake Logi sisse. Pärast sisse logimist minge vasakpoolse menüü laienditesse, nagu on näidatud alloleval pildil, kus teile pakutakse laiendihalduri aktiveerimisel võtta enda kanda turvariskid, installides kolmandate osapoolte laiendeid, mille eest JupyterLabi arendus ei vastuta:

Kuid me isolatsioonime täielikult JupyterLab ja paigutame selle konteinerisse, nii et kolmandad osapooled, kes vajavad ja kasutavad NodeJS-i, ei saaks vähemalt andmeid kettalt varastada, välja arvatud need, mille me avame konteineri sees. Teie privaatsetele dokumentidele hostis /home konteinerist protsessidele ligipääs tõenäoliselt ei õnnestu, ja kui see juhtub, siis peavad selleks olema failide privileegid hostsüsteemis, kuna me käivitame konteineri privileegideta režiimis. Selle teabe põhjal võite hinnata laiendite lubamise riski JupyterLab.

Loodud IPython-i notebukid (lehed JupyterLab) luuakse nüüd kasutaja kodu direktorisse — /home/jupyter, kuid meie plaanides on andmete jagamine (jagamine) hosti ja konteineri vahel, seega minge tagasi konsooli ja peatage JupyterLab kasutades kuumklahvi — CTRL+C ja vastates y päringule. Seejärel katkestage kasutaja interaktiivne sessioon jupyter tehes kuumklahvi CTRL+D.

Andmete jagamine hostiga ^

Hostiga andmete jagamiseks tuleb konteinerisse luua seade, mis seda võimaldab ja selleks täitke järgmine käsk, kus me määrame järgmised võtmed:

• lxc config device add — Käsk lisab seadme konfiguratsiooni
• jupyter — Konteinerite identifikaator, kuhu seadme konfiguratsioon lisatakse
• hostfs — Seadmestiku identifikaator. Võite määrata mistahes nime.
• disk — Määratakse seadme tüüp
• path — Määratakse tee konteineris, kuhu LXD selle seadme monteerib
• source — Määrake allikas, tee 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

Kataloogile /home/dv/projects/ipython-notebooks peab olema seatud konteineri kasutaja õigused, kellel on praegu UID, mis on võrdne SubUID + UID, vaadake peatükki Turvalisus. Konteinerite õigused artiklis LXD põhifunktsioonid — konteinerisüsteem Linuxis.

Sätet õiguste hostis, kus konteineri kasutaja on omanik. jupyter, ja muutuja $USER määrab teie hosti kasutaja rühmaks:

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

Tere, maailm! ^

Kui teil on veel avatud konsooli sessioon konteineris koos JupyterLab, käivitage see uuesti uue võtmega --notebook-dir määrates väärtuse /mnt/hostfs konteineri sügisel, mille me lõikes varem lõime:

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älja Python koodi, mis väljastab klassikalise Tere maailm!. Sisestamise lõpetamisel vajutage CTRL+ENTER või nuppu „play” ülemise tööriistariba peal, et JupyterLab seda teeks:

Peaaegu kõik on nüüd kasutamiseks valmis, kuid ei oleks huvitav, kui me ei installiks täiendavaid Python-mooduleid (täisrakendusi), mis oluliselt laiendavad Python'i standardseid võimalusi JupyterLab, seega liigume edasi 🙂

P.S. Huvi pärast, vana versioon Jupyter koodinimega Jupyter Notebook ei ole kuskile kadunud ja see eksisteerib paralleelselt JupyterLab. Vanale versioonile üleminekuks minge lingile, lisades aadressile sufiksi/tree, ja uuele versioonile üleminek toimub sufiksiga /lab, kuid seda ei pea tingimata määrama:

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

Python'i võimaluste laiendamine ^

Selles jaotises installime võimsad Python'i moodulid, mille tulemused integreeritakse sülearvutitesse NumPy, Pandas, Matplotlib, IPyWidgets Enne kui installime ülaltoodud Python'i moodulid paketihalduri kaudu JupyterLab.

peame esmalt lubama süsteemi sõltuvused Alpine Linuxis: pip — Vajalik moodulite kompileerimiseks, kuna mõned neist on rakendatud keeles

• g++ ja need ühendatakse Python'iga käitamisel kui binaarsed moodulid C++ freetype-dev
• — sõltuvus Python mooduli jaoks lxc exec jupyterlab -- apk add g++ freetype-dev Matplotlib

Paigaldame sõltuvused:

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

Alpine Linux'i praeguses versioonis on üks probleem, et uut NumPy versiooni ei õnnestu kompileerida, ilmneb kompileerimisviga, mida mul ei õnnestunud lahendada:

VIGA: Ei õnnestunud luua wheel'e numpy jaoks, mis kasutavad PEP 517 ja mida ei saa otse installida

Seetõttu installime selle mooduli kui süsteemipaketi, mis sisaldab juba kompileeritud versiooni, kuid see on veidi vanem kui see, mis on praegu veebilehel saadaval:

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

Seejärel installime Python moodulid pakihalduri kaudu pip. Ole kannatlik, kuna mõned moodulid kompileeritakse ja see võtab mitu minutit. Minu masinas võttis kompileerimine umbes 15 minutit:

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

Kustutame installatsioonide vahemäed:

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

Moodulite testimine JupyterLab'is ^

Kui sul on käivitamine JupyterLab, taaskäivita see, et uued installitud moodulid aktiveeruksid. Selle jaoks vajutage CTRL+C seal, kus see on käivitatud ja sisestage y peatamise päringule, ja siis käivita uuesti JupyterLab vajutades klaviatuuril 'üles' noolt, et mitte käsku uuesti sisestada ja seejärel Enter et käivitada:

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

Mine lehele http://10.0.5.5:8888/lab või värskenda brauseris lehte, seejärel sisestage järgmine kood uude märkmiku lahtrisse:

%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

Sul peaks olema tulemuseks pilt allpool, kus IPyWidgets genereerib lehekülje UI-elemendi, mis toimub interaktiivselt algkoodiga, samuti Matplotlib väljastab koodi tulemuse pildina nagu funktsiooni graafik:

Palju näiteid IPyWidgets võid leida õpetustes siin

Mis veel? ^

Oled suurepärased, kui jäid ja jõudsid artikli lõpuni. Ma tahtsin teadlikult mitte jagada artikli lõpus valmis skripti, mis installiks JupyterLab ühe klõpsuga, et julgustada töötajaid 🙂 Kuid sa saad seda ise teha, kuna juba tead, kuidas, kogudes käsud üheks Bash skriptiks 🙂

Samuti saad:

• Määrata konteineri jaoks võrgunime IP-aadressi asemel, kirjutades see lihtsasse /etc/hosts ja brauseris kirjutada aadress http://jupyter.local:8888
• Mängida ressursi piirangutega konteineris, selle jaoks loe peatükki LXD põhilistes võimalustes või saa rohkem teavet LXD arendaja veebilehelt.
• Kujunda ümberkujundus:

Ja palju muud saate! 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 laienduste halduri aktiveerimise kirjelduse juurde JupyterLab
UUENDUS: 16.04.2020 10:40 — Parandasin leitud vead tekstis ja muutsin natuke paremaks peatüki „Põhjaliku tarkvara installimine ja süsteemi seadistamine”

Allikas: habr.com