Wystrzelenie Jowisza na orbitę LXD

Czy kiedykolwiek eksperymentowałeś z kodem lub narzędziami systemowymi? Linux Dzięki temu nie musisz martwić się o system bazowy i wszystko zniszczyć, jeśli w kodzie, który musi zostać uruchomiony z uprawnieniami roota, pojawi się błąd?

A co z, powiedzmy, potrzebą przetestowania lub uruchomienia całego klastra różnych mikrousług na jednej maszynie? Setki, a nawet tysiąca?

Maszyny wirtualne zarządzane przez hiperwizor mogą rozwiązać takie problemy, ale jakim kosztem? Na przykład kontener LXD oparty na dystrybucji Alpine. Linux zużywa minimalną ilość wszystkiego 7.60MB Pamięć RAM i miejsce zajmowane przez partycję główną po uruchomieniu 9.5MB! Jak ci się to podoba, Elon Musk? Polecam sprawdzić podstawowe możliwości LXD – systemu kontenerowego w Linux

Teraz, gdy mamy ogólne pojęcie o tym, czym są kontenery LXD, przejdźmy dalej i pomyślmy, co by było, gdyby istniała platforma-kombinacja, na której można by bezpiecznie uruchamiać kod dla hosta, generować wykresy, dynamicznie (interaktywnie) wiązać widżety UI z kodem, rozszerzać kod o tekst z blackjackiem... formatowaniem? Coś w rodzaju interaktywnego bloga? Wow... Chcę to! Chcę to! 🙂

Spójrz pod wycięcie, gdzie będziemy wypływać w kontenerze laboratorium jupytera — następna generacja interfejsu użytkownika, która zastąpi przestarzały Jupyter Notebook, a także zainstaluje moduły Pythona, takie jak numpy, Pandy, Biblioteki Matplotu, Widżety IPy co pozwoli Ci wykonać wszystkie czynności wymienione powyżej i zapisać je w specjalnym pliku - laptopie IPython.

Nawigacja

• Plan startu orbitalnego
• Instalacja i konfiguracja systemu podstawowego
• Instalacja podstawowego oprogramowania i konfiguracja systemu
• Instalowanie i konfigurowanie JupyterLab
• Udostępnianie danych hostowi
• Witaj świecie!
• Rozszerzanie możliwości Pythona
• Testowanie modułów w JupyterLab
• Co jeszcze?

Plan startu orbitalnego ^

Naszkicujmy krótki plan działania, który ułatwi nam wdrożenie powyższego schematu:

• Zainstalujmy i uruchommy kontener na podstawie dystrybucji Alpejski LinuxSkorzystamy z tej dystrybucji, ponieważ jest ona nastawiona na minimalizm. Zainstalujemy tylko najpotrzebniejsze oprogramowanie, nic dodatkowego.
• Dodajmy do kontenera dodatkowy dysk wirtualny i nadajmy mu nazwę - hostfs i zamontować go do głównego systemu plików. Ten dysk umożliwi korzystanie z plików na hoście z określonego katalogu wewnątrz kontenera. W ten sposób nasze dane będą niezależne od kontenera. W przypadku usunięcia kontenera dane pozostaną na hoście. Ponadto ten schemat jest przydatny do dzielenia tych samych danych między wiele kontenerów bez korzystania ze standardowych mechanizmów sieciowych dystrybucji kontenerów.
• Zainstalujemy Bash, sudo, niezbędne biblioteki, dodamy i skonfigurujemy użytkownika systemu
• Zainstalujmy Pythona, moduły i skompilujmy dla nich zależności binarne
• Zainstalujmy i uruchommy laboratorium jupytera, dostosuj wygląd, zainstaluj rozszerzenia.

W tym artykule zaczniemy od uruchomienia kontenera, nie będziemy rozważać instalacji i konfiguracji LXD, wszystko to znajdziesz w innym artykule - Podstawowe możliwości LXD, systemu kontenerowego w Linux.

Instalacja i konfiguracja systemu podstawowego ^

Tworzymy kontener za pomocą polecenia, w którym określamy obraz — alpine3, identyfikator kontenera — jupyterlab i w razie potrzeby profile konfiguracyjne:

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

Tutaj używam profilu konfiguracji hddroot który określa utworzenie kontenera z partycją główną w Pula pamięci znajduje się na fizycznym dysku twardym:

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

Daje mi to możliwość eksperymentowania z kontenerami na dysku HDD, oszczędzając jednocześnie zasoby na dysku SSD, który również znajduje się w moim systemie :) dla którego stworzyłem osobny profil konfiguracji ssdroot.

Po utworzeniu kontenera znajduje się on w stanie STOPPED, więc musimy go uruchomić poprzez uruchomienie w nim systemu init:

lxc start jupyterlab

Wypiszmy kontenery w LXD, używając klucza -c co wskazuje, który ckolumny wyświetlane na ekranie:

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

Podczas tworzenia kontenera adres IP został wybrany losowo, ponieważ użyliśmy profilu konfiguracyjnego. default który został wcześniej skonfigurowany w artykule Podstawowe możliwości LXD, systemu kontenerowego w Linux.

Zmienimy ten adres IP na coś bardziej zapadającego w pamięć, tworząc interfejs sieciowy na poziomie kontenera, a nie na poziomie profilu konfiguracji, jak to jest teraz w bieżącej konfiguracji. Nie jest to wymagane, możesz to pominąć.

Utwórz interfejs sieciowy eth0 który łączymy z przełącznikiem (mostem sieciowym) lxdbr0 w którym zgodnie z poprzednim artykułem włączyliśmy NAT i kontener będzie miał teraz dostęp do Internetu, a także przypisaliśmy interfejsowi statyczny adres IP — 10.0.5.5:

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

Po dodaniu urządzenia należy ponownie uruchomić kontener:

lxc restart jupyterlab

Sprawdzanie statusu kontenera:

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

Instalacja podstawowego oprogramowania i konfiguracja systemu ^

Aby zarządzać naszym kontenerem, musisz zainstalować następujące oprogramowanie:

Pakiet
OPIS

bash
Powłoka GNU Bourne Again

ukończenie bash
Programowalne uzupełnianie dla powłoki bash

sudo
Daj niektórym użytkownikom możliwość uruchamiania niektórych poleceń jako root

cień
Zestaw narzędzi do zarządzania hasłami i kontami z obsługą plików shadow i PAM

tzdata
Źródła danych o strefach czasowych i czasie letnim

nano
Klon edytora Pico z ulepszeniami

Dodatkowo możesz zainstalować obsługę w systemie stron podręcznika, instalując następujące pakiety — man man-pages mdocml-apropos less

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

Przyjrzyjmy się poleceniom i klawiszom, których użyliśmy:

• lxc — Wywołanie klienta LXD
• exec — Metoda klienta LXD, która uruchamia polecenie w kontenerze
• jupyterlab — Identyfikator kontenera
• -- — Specjalny klucz, który wskazuje, że kluczy nie należy interpretować dalej jako kluczy do lxc i przekaż cały pozostały ciąg do kontenera
• apk — Menedżer pakietów dystrybucyjnych Alpine Linux
• add — Metoda menedżera pakietów, która instaluje pakiety określone po poleceniu

Następnie ustawimy strefę czasową w systemie. Europe/Moscow:

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

Po ustawieniu strefy czasowej pakiet tzdata nie jest już potrzebny w systemie, zajmie miejsce, więc usuńmy go:

lxc exec jupyterlab -- apk del tzdata

Sprawdzanie strefy czasowej:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Aby zaoszczędzić czas na konfiguracji Basha dla nowych użytkowników w kontenerze, skopiujemy do niego gotowe pliki skel z systemu hosta. Pozwoli nam to dostosować Basha w kontenerze w trybie interaktywnym. Moim systemem hosta jest Manjaro. Linux i skopiowane pliki /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors w zasadzie pasują do Alpine Linux i nie powodują problemów krytycznych, ale możesz mieć inną dystrybucję i będziesz musiał samodzielnie sprawdzić, czy podczas uruchamiania powłoki Bash w kontenerze występuje błąd.

Kopiuj pliki skel do kontenera. Klucz --create-dirs utworzy niezbędne katalogi, jeśli nie istnieją:

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

W przypadku istniejącego użytkownika root kopiujemy pliki skel skopiowane właśnie do kontenera do katalogu domowego:

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

W Alpach Linux dla użytkowników zainstalowana jest powłoka systemowa /bin/sh, zastąpimy to root użytkownik na Bash:

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

Że root użytkownik nie był bez hasła, musi ustawić hasło. Poniższe polecenie wygeneruje i ustawi dla niego nowe losowe hasło, które zobaczysz na ekranie konsoli po jego wykonaniu:

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

Utwórzmy także nowego użytkownika systemu - jupyter dla którego skonfigurujemy później laboratorium jupytera:

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

Wygenerujmy i ustawmy dla niego hasło:

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

Następnie wykonamy dwa polecenia, pierwsze utworzy grupę systemową sudo, a drugi doda do niego użytkownika jupyter:

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

Zobaczmy, do jakich grup należy użytkownik jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Wszystko w porządku, idziemy dalej.

Pozwólmy wszystkim użytkownikom, którzy są częścią grupy sudo użyj polecenia sudoAby to zrobić, uruchom następujący skrypt, gdzie sed odkomentuj wiersz parametru w pliku konfiguracyjnym /etc/sudoers:

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

Instalowanie i konfigurowanie JupyterLab ^

laboratorium jupytera — to aplikacja Python, więc najpierw musimy zainstalować ten interpreter. Ponadto, laboratorium jupytera zainstalujemy używając menedżera pakietów Python pip, a nie systemowy, ponieważ w repozytorium systemowym może być nieaktualny i dlatego musimy ręcznie rozwiązać zależności dla niego, instalując następujące pakiety - python3 python3-dev gcc libc-dev zeromq-dev:

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

Zaktualizujmy moduły Pythona i menedżera pakietów pip do wersji bieżącej:

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

zainstalować laboratorium jupytera poprzez menedżera pakietów pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Ponieważ rozszerzenia w laboratorium jupytera są eksperymentalne i nie są oficjalnie zawarte w pakiecie jupyterlab, dlatego musimy je zainstalować i skonfigurować ręcznie.

Zainstalujmy NodeJS i jego menedżera pakietów NPM, ponieważ laboratorium jupytera używa ich do swoich rozszerzeń:

lxc exec jupyterlab -- apk add nodejs npm

Do rozszerzeń dla laboratorium jupytera które zainstalujemy, aby działały, należy je zainstalować w katalogu użytkownika, ponieważ aplikacja będzie uruchamiana z poziomu użytkownika jupyter. Problem polega na tym, że w poleceniu launch nie ma parametru, który mógłby przekazać katalog, aplikacja akceptuje tylko zmienną środowiskową, dlatego musimy ją zdefiniować. Aby to zrobić, napiszemy polecenie eksportu zmiennej JUPYTERLAB_DIR w środowisku użytkownika jupyter, złożyć .bashrc, który jest wykonywany za każdym razem, gdy użytkownik się loguje:

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

Następne polecenie zainstaluje specjalne rozszerzenie - menedżera rozszerzeń w laboratorium jupytera:

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

Teraz wszystko jest gotowe na pierwsze uruchomienie. laboratorium jupytera, ale możemy także zainstalować kilka przydatnych rozszerzeń:

• toc — Spis treści, generuje listę nagłówków w artykule/notatniku
• jupyterlab-horizon-theme — Motyw interfejsu użytkownika
• jupyterlab_neon_theme — Motyw interfejsu użytkownika
• jupyterlab-ubu-theme - Jeszcze jeden. motyw projektu autorstwa autora ten artykuł :) Ale w tym przypadku zostanie wyświetlona instalacja z repozytorium GitHub

Aby zainstalować te rozszerzenia, uruchom kolejno następujące polecenia:

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"

Po zainstalowaniu rozszerzeń musimy je skompilować, ponieważ wcześniej podczas instalacji podaliśmy klucz --no-build aby zaoszczędzić czas. Teraz znacznie przyspieszymy proces, kompilując je razem na raz:

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

Teraz uruchom następujące dwa polecenia w celu pierwszego uruchomienia laboratorium jupytera. Można by go uruchomić jednym poleceniem, ale w tym przypadku polecenie uruchomienia, o którym trudno pamiętać, zostanie zapamiętane przez bash w kontenerze, a nie na hoście, gdzie jest już wystarczająco dużo poleceń, aby zapisać je w historii 🙂

Zaloguj się do kontenera jako użytkownik jupyter:

lxc exec jupyterlab -- su -l jupyter

Dalej biegnij laboratorium jupytera z kluczami i parametrami jak wskazano:

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

Przejdź do następującego adresu w swojej przeglądarce internetowej http://10.0.5.5:8888 i na stronie, która się otworzy, wpisz jako unikalny cyfrowy, niezmienny certyfikat, który dostęp, który zobaczysz w konsoli. Skopiuj go i wklej na stronie, a następnie kliknij Zaloguj. Po zalogowaniu przejdź do menu rozszerzeń po lewej stronie, jak pokazano na poniższym obrazku, gdzie zostaniesz poproszony o zaakceptowanie ryzyka bezpieczeństwa podczas instalowania rozszerzeń innych firm podczas aktywacji menedżera rozszerzeń, dla którego polecenie Rozwój JupyterLab nie ponosi odpowiedzialności:

Jednakże izolujemy całość właśnie w tym celu. laboratorium jupytera i umieść go w kontenerze, aby rozszerzenia innych firm, które wymagają i używają NodeJS, nie mogły przynajmniej ukraść danych na dysku, z wyjątkiem tych, które otwieramy w kontenerze. Uzyskaj dostęp do swoich prywatnych dokumentów na hoście w /home procesy z kontenera prawdopodobnie nie zakończą się powodzeniem, a jeśli tak się stanie, musisz mieć uprawnienia do plików w systemie hosta, ponieważ uruchamiamy kontener w tryb nieuprzywilejowanyNa podstawie tych informacji możesz ocenić ryzyko uwzględnienia rozszerzeń w laboratorium jupytera.

Utworzono notatniki IPython (strony w laboratorium jupytera) zostanie teraz utworzony w katalogu domowym użytkownika - /home/jupyter, ale planujemy podzielić dane (udostępnić) między hostem a kontenerem, więc wróć do konsoli i zatrzymaj laboratorium jupytera wykonując skrót klawiszowy — CTRL+C i odpowiedział y na żądanie. Następnie zakończ interaktywną sesję użytkownika. jupyter wykonując klawisz skrótu CTRL+D.

Udostępnianie danych hostowi ^

Aby udostępnić dane hostowi, należy utworzyć w kontenerze urządzenie, które na to pozwala, i w tym celu uruchomić następujące polecenie, w którym podajemy następujące klucze:

• lxc config device add — Polecenie dodaje konfigurację urządzenia
• jupyter — Identyfikator kontenera, do którego dodawana jest konfiguracja
• hostfs — Identyfikator urządzenia. Możesz ustawić dowolną nazwę.
• disk — Wskazano typ urządzenia
• path — Określa ścieżkę w kontenerze, do którego LXD zamontuje to urządzenie
• source — Określ źródło, ścieżkę do katalogu na hoście, który chcesz udostępnić kontenerowi. Określ ścieżkę zgodnie ze swoimi preferencjami

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

Do katalogu /home/dv/projects/ipython-notebooks uprawnienie musi zostać ustawione dla użytkownika kontenera, który obecnie ma UID równy SubUID + UID, zobacz rozdział Bezpieczeństwo: uprawnienia kontenera w artykule Podstawowe możliwości LXD, systemu kontenerowego w Linux.

Ustaw uprawnienia na hoście, którego właścicielem będzie użytkownik kontenera jupyteri zmienna $USER określi użytkownika hosta jako grupę:

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

Witaj świecie! ^

Jeśli nadal masz otwartą sesję konsoli w kontenerze z laboratorium jupytera, a następnie uruchom go ponownie za pomocą nowego klucza --notebook-dir ustawiając wartość /mnt/hostfs jako ścieżkę do katalogu głównego notatników w kontenerze dla urządzenia, które utworzyliśmy w poprzednim kroku:

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

Następnie przejdź do strony http://10.0.5.5:8888 i stwórz swój pierwszy laptop klikając przycisk na stronie, jak pokazano na poniższym obrazku:

Następnie w polu na stronie wprowadź kod Pythona, który wygeneruje klasyczny kod Hello World!. Po zakończeniu wprowadzania naciśnij CTRL+ENTER lub przycisk „Odtwórz” na pasku narzędzi u góry, aby JupyterLab wykonał tę czynność:

W tym momencie prawie wszystko jest gotowe do użycia, ale nie będzie ciekawie, jeśli nie zainstalujemy dodatkowych modułów Pythona (pełnoprawnych aplikacji), które pozwolą nam znacznie rozszerzyć standardowe możliwości Pythona w laboratorium jupytera, więc przejdźmy dalej 🙂

P.S. Ciekawe, że stara implementacja jupiter pod kryptonimem Notebook Jupyter nie odeszło nigdzie i istnieje równolegle laboratorium jupyteraAby przejść do starej wersji, kliknij link, dodając sufiks do adresu/tree, a przejście do nowej wersji odbywa się za pomocą sufiksu /lab, ale nie jest konieczne jego określenie:

• Notatnik Jupyter — http://10.0.5.5:8888/tree
• Laboratorium Jupyter — http://10.0.5.5:8888/lab

Rozszerzanie możliwości Pythona ^

W tej sekcji zainstalujemy wydajne moduły Pythona, takie jak: numpy, Pandy, Biblioteki Matplotu, Widżety IPy których wyniki pracy są integrowane w laptopach laboratorium jupytera.

Przed zainstalowaniem wymienionych modułów Pythona za pomocą menedżera pakietów pip Najpierw musimy rozwiązać zależności systemowe w Alpine Linux:

• g++ — Konieczne do skompilowania modułów, ponieważ część z nich jest zaimplementowana w języku C + + i są połączone z Pythonem w czasie wykonywania jako moduły binarne
• freetype-dev — zależność dla modułu Python Biblioteki Matplotu

Instalowanie zależności:

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

Obecny stan dystrybucji alpejskiego ma jeden problem. Linux Nie mogę skompilować nowej wersji NumPy. Pojawia się błąd kompilacji, którego nie potrafię rozwiązać:

BŁĄD: Nie można zbudować kół dla numpy, które używają PEP 517 i nie mogą być instalowane bezpośrednio

Dlatego zainstalujemy ten moduł jako pakiet systemowy, który będzie dystrybuował już skompilowaną wersję, ale trochę starszą od tej, która jest obecnie dostępna na stronie:

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

Następnie zainstaluj moduły Pythona za pomocą menedżera pakietów pip. Bądź cierpliwy, ponieważ niektóre moduły zostaną skompilowane i zajmie to kilka minut. Na moim komputerze kompilacja zajęła ~15 minut:

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

Czyszczenie pamięci podręcznej instalacji:

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

Testowanie modułów w JupyterLab ^

Jeśli masz to uruchomione laboratorium jupytera, uruchom go ponownie, aby nowo zainstalowane moduły zostały aktywowane. Aby to zrobić, w sesji konsoli naciśnij CTRL+C gdzie to uruchomiłeś i wprowadź y do żądania zatrzymania i ponownego uruchomienia laboratorium jupytera naciskając strzałkę w górę na klawiaturze, aby nie wprowadzać ponownie polecenia, a następnie Enter biegać:

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

Przejdź do strony http://10.0.5.5:8888/lab lub odśwież stronę w przeglądarce i wprowadź poniższy kod w nowej komórce notatnika:

%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

Powinieneś otrzymać wynik taki jak na poniższym obrazku, gdzie Widżety IPy generuje element interfejsu użytkownika na stronie, który wchodzi w interakcję z kodem źródłowym, i Biblioteki Matplotu wyprowadza wynik kodu jako obraz w postaci wykresu funkcji:

Wiele przykładów Widżety IPy możesz to znaleźć w samouczkach tutaj

Co jeszcze? ^

Dobrze, jeśli zostałeś i dotarłeś do samego końca artykułu. Celowo nie zamieściłem gotowego skryptu na końcu artykułu, który by zainstalował laboratorium jupytera w „jednym kliknięciu”, aby zachęcić pracowników 🙂 Ale możesz to zrobić sam, skoro już wiesz jak, zbierając polecenia w jednym skrypcie Bash 🙂

Możesz również:

• Ustaw nazwę sieciową kontenera zamiast adresu IP, wpisując ją w prostym kodzie /etc/hosts i wpisz adres w przeglądarce http://jupyter.local:8888
• Pobaw się limitem zasobów dla kontenera, przeczytaj w tym celu rozdział podstawowe możliwości LXD lub uzyskaj więcej informacji na stronie internetowej dewelopera LXD.
• Zmień motyw:

I możesz zrobić jeszcze wiele! To wszystko. Życzę powodzenia!

AKTUALIZACJA: 15.04.2020 18:30 — Naprawiono błędy w rozdziale „Witaj, świecie!”
AKTUALIZACJA: 16.04.2020 10:00 — Poprawiono i dodano tekst w opisie aktywacji menedżera rozszerzeń laboratorium jupytera
AKTUALIZACJA: 16.04.2020 10:40 — Poprawiono błędy znalezione w tekście i nieznacznie zmieniono rozdział „Instalacja podstawowego oprogramowania i konfiguracja systemu” na lepsze

Źródło: www.habr.com