ProHoster > Blog > administracja > Wystrzelenie Jowisza na orbitę LXD

Wystrzelenie Jowisza na orbitę LXD

Czy kiedykolwiek musiałeś eksperymentować z kodem lub narzędziami systemowymi w Linuksie, aby nie martwić się o system bazowy i nie zburzyć wszystkiego w przypadku błędu w kodzie, który powinien działać z uprawnieniami roota?

A co z faktem, że załóżmy, że musisz przetestować lub uruchomić cały klaster różnych mikrousług na jednym komputerze? Sto, a nawet tysiąc?

Dzięki maszynom wirtualnym zarządzanym przez hypervisor takie problemy mogą i zostaną rozwiązane, ale jakim kosztem? Na przykład kontener w LXD oparty na dystrybucji Alpine Linux zużywa tylko 7.60MB RAM i miejsce, w którym po uruchomieniu zajmuje się partycja główna 9.5MB! Jak ci się to podoba, Elonie Musku? Polecam sprawdzić podstawowe możliwości LXD - systemu kontenerowego w systemie Linux

Gdy już stało się jasne czym są kontenery LXD, pójdźmy dalej i zastanówmy się, co by było, gdyby istniała taka platforma harwesterowa, na której można by bezpiecznie uruchamiać kod dla hosta, generować wykresy, dynamicznie (interaktywnie) łączyć widżety UI ze swoim kodem, uzupełnij kod tekstem za pomocą blackjacka... formatowanie? Jakiś interaktywny blog? Wow... Chcę tego! Chcieć! 🙂

Zajrzyj pod kota gdzie będziemy wystrzeliwać w pojemniku laboratorium jupytera - następna generacja interfejsu użytkownika w miejsce przestarzałego Jupyter Notebook, a także zainstalujemy moduły Pythona takie jak numpy, Pandy, Biblioteki Matplotu, IPyWidgets co pozwoli ci zrobić wszystko wymienione powyżej i zapisać to wszystko w specjalnym pliku - laptopie IPython.

Wystrzelenie Jowisza na orbitę LXD

Plan startu orbitalnego ^

Wystrzelenie Jowisza na orbitę LXD

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

  • Zainstalujmy i uruchommy kontener w oparciu o zestaw dystrybucyjny Alpine Linux. Będziemy korzystać z tej dystrybucji, ponieważ jest ona nastawiona na minimalizm i zainstalujemy w niej tylko najbardziej potrzebne oprogramowanie, nic zbędnego.
  • Dodajmy do kontenera dodatkowy dysk wirtualny i nadajmy mu nazwę - hostfs i zamontuj go w głównym systemie plików. Dysk ten umożliwi wykorzystanie plików na hoście z danego katalogu wewnątrz kontenera. Dzięki temu nasze dane będą niezależne od kontenera. Jeśli kontener zostanie usunięty, dane pozostaną na hoście. Schemat ten jest również przydatny do udostępniania tych samych danych pomiędzy wieloma kontenerami bez korzystania ze standardowych mechanizmów sieciowych dystrybucji kontenerów.
  • Zainstalujmy Bash, Sudo, niezbędne biblioteki, dodajmy i skonfigurujmy użytkownika systemowego
  • Zainstalujmy Pythona, moduły i skompilujmy dla nich zależności binarne
  • Zainstalujmy i uruchommy laboratorium jupytera, dostosuj wygląd, zainstaluj dla niego rozszerzenia.

W tym artykule zaczniemy od uruchomienia kontenera, nie będziemy rozważać instalacji i konfiguracji LXD, wszystko to znajdziesz w innym artykule - Podstawowe cechy LXD - Linuxowe systemy kontenerowe.

Instalacja i konfiguracja systemu podstawowego ^

Tworzymy kontener za pomocą polecenia, w którym podajemy obraz - alpine3, identyfikator kontenera - jupyterlab oraz w razie potrzeby profile konfiguracyjne:

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

Tutaj używam profilu konfiguracyjnego hddroot który określa utworzenie kontenera z partycją główną Pula pamięci zlokalizowane na fizycznym dysku HDD:

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 zasoby dysku SSD, który również jest dostępny w moim systemie 🙂 dla którego stworzyłem osobny profil konfiguracyjny ssdroot.

Po utworzeniu kontener znajduje się w stanie STOPPED, więc musimy go uruchomić, uruchamiając w nim system init:

lxc start jupyterlab

Wyświetlmy listę kontenerów w LXD za pomocą klucza -c co wskazuje które cwyświetlanie kolumn:

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ż wykorzystaliśmy profil konfiguracyjny default który został wcześniej skonfigurowany w artykule Podstawowe cechy LXD - Linuxowe systemy kontenerowe.

Zmienimy ten adres IP na bardziej zapamiętywalny tworząc interfejs sieciowy na poziomie kontenera, a nie na poziomie profilu konfiguracyjnego jak to ma teraz miejsce w bieżącej konfiguracji. Nie musisz tego robić, możesz to pominąć.

Tworzenie interfejsu sieciowego eth0 które łączymy z przełącznikiem (mostkiem 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 przypiszemy 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 zrestartować 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 administrować naszym kontenerem należy zainstalować następujące oprogramowanie:

Pakiet
Opis

bash
Powłoka GNU Bourne Again

ukończenie bash
Programowalne uzupełnienie powłoki bash

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

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

tzdata
Źródła danych dotyczących strefy czasowej i czasu letniego

nano
Klon edytora Pico z ulepszeniami

Dodatkowo możesz zainstalować wsparcie na stronach podręcznika systemu, 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żywaliśmy:

  • lxc — Zadzwoń do klienta LXD
  • exec - Metoda klienta LXD, która uruchamia polecenie w kontenerze
  • jupyterlab — Identyfikator kontenera
  • -- - Specjalny klucz, który określa, że ​​dalsze klucze nie mają być interpretowane jako klucze lxc i przekaż resztę ciągu w niezmienionej postaci 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 ustalamy strefę czasową w systemie. Europe/Moscow:

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

Po zainstalowaniu 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 nie tracić dużo czasu na konfigurowanie Basha dla nowych użytkowników w kontenerze, w kolejnych krokach skopiujemy do niego gotowe pliki skel z systemu hosta. Umożliwi to interaktywne upiększanie Basha w kontenerze. Mój system hosta to Manjaro Linux i kopiowane pliki /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors w zasadzie są one odpowiednie dla Alpine Linux i nie powodują krytycznych problemów, ale możesz mieć inną dystrybucję i musisz samodzielnie dowiedzieć się, czy podczas uruchamiania Basha w kontenerze nie występuje błąd.

Skopiuj 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 już istniejącego użytkownika root skopiuj właśnie skopiowane pliki skel 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

Alpine Linux instaluje powłokę systemową dla użytkowników /bin/sh, zastąpimy go root użytkownik w Bashu:

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

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

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.

Zezwalaj wszystkim użytkownikom będącym członkami grupy sudo użyj polecenia sudo. Aby to zrobić, uruchom następujący skrypt, gdzie sed usuwa komentarz z linii parametrów 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"

Instalacja i konfiguracja JupyterLab ^

laboratorium jupytera jest aplikacją w języku Python, dlatego musimy najpierw zainstalować ten interpreter. Również, laboratorium jupytera zainstalujemy za pomocą menedżera pakietów Python pip, a nie systemowy, gdyż może być on nieaktualny w repozytorium systemu i w związku z tym musimy ręcznie rozwiązać dla niego zależności 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 aktualnej wersji:

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

zainstalować laboratorium jupytera za pośrednictwem menedżera pakietów pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

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

Zainstalujmy NodeJS i menedżera pakietów dla niego - 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, zadziałały, należy je zainstalować w katalogu użytkownika, ponieważ aplikacja zostanie uruchomiona z poziomu użytkownika jupyter. Problem polega na tym, że w poleceniu uruchomienia nie ma parametru, który można przekazać do katalogu; aplikacja akceptuje jedynie zmienną środowiskową i dlatego musimy ją zdefiniować. Aby to zrobić, napiszemy polecenie eksportu zmiennej JUPYTERLAB_DIR w środowisku użytkownika jupyter, do pliku .bashrcktóry jest wykonywany przy każdym logowaniu użytkownika:

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żer 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 do pierwszego uruchomienia laboratorium jupytera, ale nadal możemy zainstalować kilka przydatnych rozszerzeń:

  • toc — Spis treści, generuje spis nagłówków artykułu/zeszytu
  • jupyterlab-horizon-theme — Motyw interfejsu użytkownika
  • jupyterlab_neon_theme — Motyw interfejsu użytkownika
  • jupyterlab-ubu-theme - Inny temat od autora ten artykuł :) Ale w tym przypadku pokazana zostanie instalacja z repozytorium GitHub

Uruchom więc kolejno następujące polecenia, aby zainstalować te rozszerzenia:

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 określiliśmy klucz --no-build oszczędzać czas. Teraz znacznie przyspieszymy, kompilując je za jednym razem:

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, aby uruchomić je po raz pierwszy laboratorium jupytera. Można by go uruchomić jednym poleceniem, ale w tym przypadku polecenie uruchomienia, które trudno zapamię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ź pod adres w swojej przeglądarce internetowej http://10.0.5.5:8888 i na stronie, która się otworzy, wprowadź żeton dostęp, który zobaczysz w konsoli. Skopiuj i wklej go na stronę, a następnie kliknij Zaloguj. Po zalogowaniu przejdź do menu rozszerzeń po lewej stronie, jak pokazano na poniższym rysunku, gdzie podczas aktywacji menedżera rozszerzeń zostaniesz poproszony o podjęcie ryzyka bezpieczeństwa poprzez zainstalowanie rozszerzeń stron trzecich, dla których polecenie Rozwój JupyterLab nie jest odpowiedzialny:

Wystrzelenie Jowisza na orbitę LXD

Całość jednak izolujemy laboratorium jupytera i umieść go w kontenerze, aby rozszerzenia innych firm wymagające i korzystające z NodeJS nie mogły przynajmniej ukraść danych z dysku innych niż te, które otwieramy w kontenerze. Uzyskaj dostęp do swoich prywatnych dokumentów na hoście w /home procesy z kontenera raczej nie zakończą się sukcesem, a jeśli tak, to musisz mieć uprawnienia do plików w systemie hosta, ponieważ uruchamiamy kontener w tryb nieuprzywilejowany. Na podstawie tych informacji możesz ocenić ryzyko włączenia rozszerzeń laboratorium jupytera.

Utworzono notatniki IPython (strony w formacie laboratorium jupytera) zostanie teraz utworzony w katalogu domowym użytkownika - /home/jupyter, ale nasze plany są takie, aby podzielić dane (udział) pomiędzy hostem a kontenerem, więc wróć do konsoli i zatrzymaj się laboratorium jupytera wykonując skrót klawiszowy - CTRL+C i odpowiadanie y na żądanie. Następnie zakończ interaktywną sesję użytkownika jupyter wykonanie skrótu CTRL+D.

Udostępnianie danych hostowi ^

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

  • lxc config device add — Polecenie dodaje konfigurację urządzenia
  • jupyter — Identyfikator kontenera, do którego dodana jest konfiguracja
  • hostfs - Identyfikator urzadzenia. Możesz ustawić dowolną nazwę.
  • disk — Wskazany jest 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 być ustawione na użytkownika kontenera, który aktualnie ma UID równy SubUID + UID, patrz rozdział Bezpieczeństwo. Przywileje kontenerowe w artykule Podstawowe cechy LXD - Linuxowe systemy kontenerowe.

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 za pomocą laboratorium jupytera, a następnie uruchom go ponownie za pomocą nowego klucza --notebook-dir poprzez ustawienie wartości /mnt/hostfs jako ścieżka do katalogu głównego laptopów w kontenerze dla urządzenia, który 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 utwórz swój pierwszy laptop klikając w przycisk na stronie jak na obrazku poniżej:

Wystrzelenie Jowisza na orbitę LXD

Następnie w polu na stronie wpisz kod Pythona, który wyświetli klasykę Hello World!. Po zakończeniu wprowadzania naciśnij CTRL+ENTER lub przycisk „odtwórz” na pasku narzędzi u góry, aby JupyterLab zrobił to:

Wystrzelenie Jowisza na orbitę LXD

W tym momencie prawie wszystko jest gotowe do użycia, jednak nie będzie ciekawie, jeśli nie zainstalujemy dodatkowych modułów Pythona (pełnoprawnych aplikacji), które mogą znacznie rozszerzyć standardowe możliwości Pythona w laboratorium jupyterazatem idziemy dalej :)

PS Ciekawostką jest to, że stara implementacja jupiter pod kryptonimem Notebook Jupyter nie zniknął i istnieje równolegle z laboratorium jupytera. Aby przejść do starej wersji należy kliknąć link dodając przyrostek w adresie/tree, a przejście do nowej wersji odbywa się za pomocą przyrostka /lab, ale nie musi być to określone:

Rozszerzanie możliwości Pythona ^

W tej sekcji zainstalujemy tak potężne moduły języka Python jak numpy, Pandy, Biblioteki Matplotu, IPyWidgets których wyniki są zintegrowane z laptopami laboratorium jupytera.

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

  • g++ — Potrzebne do kompilacji modułów, ponieważ niektóre z nich są zaimplementowane w języku C + + i połącz się 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

Jest jeden problem: w obecnym stanie dystrybucji Alpine Linux nie będzie możliwości skompilowania nowej wersji NumPy; pojawi się błąd kompilacji, którego nie udało mi się rozwiązać:

BŁĄD: Nie można zbudować kół dla numpy, które korzystają z PEP 517 i nie można ich zainstalować bezpośrednio

Dlatego zainstalujemy ten moduł jako pakiet systemowy, który dystrybuuje już skompilowaną wersję, ale nieco starszą niż ta, 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. Prosimy o cierpliwość, ponieważ niektóre moduły się skompilują i może to zająć 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 biegasz laboratorium jupytera, uruchom go ponownie, aby nowo zainstalowane moduły zostały aktywowane. Aby to zrobić, w sesji konsoli kliknij CTRL+C gdzie masz to uruchomione i wejdź y aby zatrzymać żądanie i rozpocząć od nowa laboratorium jupytera naciskając strzałkę w górę na klawiaturze, aby nie wprowadzać polecenia ponownie Enter aby to rozpocząć:

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, a następnie w nowej komórce notatnika wpisz następujący kod:

%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ś uzyskać wynik jak na obrazku poniżej, gdzie IPyWidgets generuje na stronie element UI, który wchodzi w interakcję z kodem źródłowym, a także Biblioteki Matplotu wyświetla wynik kodu w postaci obrazu jako wykres funkcji:

Wystrzelenie Jowisza na orbitę LXD

Wiele przykładów IPyWidgets znajdziesz to w tutorialach tutaj

Co jeszcze? ^

Dobra robota, jeśli zostałeś i dotarłeś do samego końca artykułu. Celowo nie zamieściłem na końcu artykułu gotowego skryptu, który miałby się zainstalować laboratorium jupytera w „jednym kliknięciu”, aby zachęcić pracowników :) Ale możesz to zrobić sam, ponieważ już wiesz, jak to zrobić, po zebraniu poleceń w jednym skrypcie Bash :)

Możesz również:

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

Wystrzelenie Jowisza na orbitę LXD

I wiele więcej możesz zrobić! To wszystko. Życzę Ci sukcesu!

AKTUALIZACJA: 15.04.2020 18:30 - Poprawiono błędy w rozdziale „Hello, World!”
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 na lepsze rozdział „Instalacja podstawowego oprogramowania i konfiguracja systemu”

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

Dodaj komentarz