ProHoster > Blog > Administracja > Uruchamiamy Jupyter na orbicie LXD

Uruchamiamy Jupyter na orbicie LXD

Czy kiedykolwiek eksperymentowałeś z kodem lub systemowymi narzędziami w systemie Linux w taki sposób, aby nie bać się o podstawowy system i nie zniszczyć wszystkiego w przypadku błędu kodu, który powinien działać z uprawnieniami root?

A co, jeśli trzeba przetestować lub uruchomić cały klaster różnych mikroserwisów na jednej maszynie? Sto lub nawet tysiąc?

Z wirtualnymi maszynami zarządzanymi przez hipernadzorcę można by to osiągnąć, ale jakim kosztem? Na przykład kontener w LXD oparty na dystrybucji Alpine Linux minimalnie zużywa 7.60MB RAM, a po uruchomieniu, partycja główna zajmuje 9.5MB! Co ty na to, Elon Musk? Polecam zapoznać się z podstawowymi możliwościami LXD — systemy kontenerów w Linuxie.

Po tym, jak ogólnie stało się jasne, czym są kontenery LXD, przejdźmy dalej i pomyślmy, co by było, gdyby istniała platforma-kombajn, w której można bezpiecznie uruchamiać kod dla hosta, generować wykresy, dynamicznie (interaktywnie) łączyć widgety interfejsu użytkownika z twoim kodem, uzupełniać kod tekstem z blackjackiem… formatowaniem? Coś jak interaktywny blog? Wow… Chcę! Chcę! 🙂

Zajrzyj pod załącznik, gdzie uruchomimy w kontenerze JupyterLab — następna generacja interfejsu użytkownika zamiast przestarzałego Jupyter Notebook, a także zainstalujemy takie moduły Pythona jak NumPy, Pandas, Matplotlib, IPyWidgets które pozwolą nam na wszystko, o czym mówiliśmy wcześniej i zapisać to wszystko w specjalnym pliku — notatniku IPython.

Uruchamiamy Jupyter na orbicie LXD

Plan startu na orbitę ^

Uruchamiamy Jupyter na orbicie LXD

Sporządźmy krótki plan działań, aby ułatwić sobie realizację powyższej schemy:

  • Zainstalujemy i uruchomimy kontener oparty na dystrybucji Alpine Linux. Użyjemy tej dystrybucji, ponieważ jest ukierunkowana na minimalizm i zainstalujemy w niej tylko najpotrzebniejsze oprogramowanie, nic ponad to.
  • Dodamy dodatkowy wirtualny dysk w kontenerze, któremu nadamy nazwę — hostfs i zamontujemy do systemu plików. Ten dysk umożliwi korzystanie z plików na hoście z określonego katalogu wewnątrz kontenera. Dzięki temu dane będą niezależne od kontenera. W przypadku usunięcia kontenera, dane pozostaną na hoście. Schemat ten jest także przydatny do dzielenia danych między wieloma kontenerami bez użycia standardowych mechanizmów sieciowych dystrybucji kontenera.
  • Zainstalujemy Bash, sudo, niezbędne biblioteki, dodamy i skonfigurujemy użytkownika systemowego.
  • Zainstalujemy Pythona, moduły i skompilujemy dla nich zależności binarne.
  • Zainstalujemy i uruchomimy. JupyterLab, skonfigurujemy wygląd, zainstalujemy dla niego rozszerzenia.

W tym artykule rozpoczniemy od uruchomienia kontenera, nie będziemy omawiać instalacji i konfiguracji LXD, wszystko to można znaleźć w innym artykule — Podstawowe możliwości LXD — systemu kontenerów w Linuxie.

Instalacja i konfiguracja podstawowego systemu ^

Tworzymy kontener za pomocą polecenia, w którym wskazujemy obraz — alpine3, identyfikator kontenera — jupyterlab i, jeśli to konieczne, profile konfiguracji:

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

Tutaj używam profilu konfiguracji hddroot , który wskazuje na utworzenie kontenera z partycją root na Pula pamięci masowej umiejscowioną 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 w moim systemie 🙂, dla którego stworzyłem oddzielny profil konfiguracji. ssdroot.

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

lxc start jupyterlab

Wyświetlimy listę kontenerów w LXD, używając klucza -c , który wskazuje, które ckolumny wyświetlić na ekranie:

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

Przy tworzeniu kontenera adres IP został wybrany losowo, ponieważ używaliśmy profilu konfiguracji default , który został wcześniej skonfigurowany w artykule. Podstawowe możliwości LXD — systemu kontenerów w Linuxie.

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

Tworzymy interfejs sieciowy eth0 który łączymy z przełącznikiem (mostem sieciowym) lxdbr0 w którym włączyliśmy NAT zgodnie z poprzednim artykułem i kontener będzie teraz miał dostęp do Internetu, a także interfejsowi przypisujemy 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, kontener należy zrestartować:

lxc restart jupyterlab

Sprawdzamy status kontenera:

lxc list -c ns4b
+------------+---------+------------------+--------------+
|    NAZWA   | STAN    |       IPV4       | PULPIT MAGAZYNOWY |
+------------+---------+------------------+--------------+
| jupyterlab | DZIAŁA  | 10.0.5.5 (eth0)  | hddpool      |
+------------+---------+------------------+--------------+

Instalacja podstawowego oprogramowania i konfiguracja systemu ^

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

Pakiet
Opis

bash
GNU Bourne Again shell

bash-completion
Programowalne uzupełnianie dla powłoki bash

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

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

tzdata
Zasoby dla strefy czasowej i danych o czasie letnim

nano
Klon edytora Pico z ulepszeniami

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

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

Przeanalizujmy polecenia i opcje, które wykorzystaliśmy:

  • lxc — Wywołanie klienta LXD
  • exec — Metoda klienta LXD, która uruchamia polecenie w kontenerze
  • jupyterlab — Identyfikator kontenera
  • -- — Specjalny klucz, który wskazuje, aby nie interpretować dalszych kluczy jako kluczy dla lxc i przekazać całą resztę linii jako jest do kontenera
  • apk — Menedżer pakietów dystrybucji Alpine Linux
  • add — Metoda menedżera pakietów, która instaluje wymienione pakiety po poleceniu

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

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

Po zainstalowaniu strefy czasowej, pakiet tzdata w systemie jest już niepotrzebny, zajmie miejsce, więc go usuniemy:

lxc exec jupyterlab -- apk del tzdata

Sprawdzamy strefę czasową:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Aby nie tracić dużo czasu na konfigurację Bash dla nowych użytkowników w kontenerze, w następnych krokach skopiujemy gotowe pliki skel z systemu hosta. Pozwoli to na upiększenie Bash w kontenerze w trybie interaktywnym. Mój system hosta to Manjaro Linux, a kopiowane pliki to /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors zasadniczo nadają się do Alpine Linux i nie powodują krytycznych problemów, ale może być to inna dystrybucja i musisz samodzielnie poradzić sobie w przypadku błędu uruchamianego Bash w kontenerze.

Kopiujemy 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

Dla już istniejącego użytkownika root skopiujemy do jego katalogu domowego właśnie skopiowane do kontenera pliki skel:

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 Alpine Linux dla użytkowników ustawia się powłokę systemową /bin/sh, zamienimy ją u root użytkownika na Bash:

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

Aby root użytkownik nie miał hasła, musi ustawić hasło. Poniższa komenda wygeneruje i ustawi nowe losowe hasło, które zobaczysz na ekranie konsoli po jej 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 "Nowe hasło: $PASSWD""

Nowe hasło: sFiXEvBswuWA

Utworzymy także nowego użytkownika systemowego — jupyter dla którego później skonfigurujemy JupyterLab:

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

Wygenerujemy i ustawimy mu 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 "Nowe hasło: $PASSWD""

Nowe hasło: ZIcbzWrF8tki

Następnie wykonamy dwie komendy, pierwsza utworzy grupę systemową sudo, a druga doda do niej użytkownika jupyter:

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

Sprawdźmy, do jakich grup należy użytkownik jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Wszystko — w porządku, przechodzimy dalej.

Pozwólmy wszystkim użytkownikom, którzy należą do grupy sudo korzystać z polecenia sudo. W tym celu wykonaj następujący skrypt, który sed odkomentuje linię 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"

Instalacja i konfiguracja JupyterLab ^

JupyterLab — to aplikacja Python, dlatego najpierw musimy zainstalować ten interpreter. Ponadto, JupyterLab będziemy instalować za pomocą menedżera pakietów Pythona, pip, a nie systemowego, ponieważ w systemowym repozytorium może być przestarzały, dlatego musimy ręcznie zezwolić na jego 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

Zaktualizujemy moduły Pythona i menedżera pakietów pip do najnowszej wersji:

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

Instalujemy JupyterLab przez menedżera pakietów pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Ponieważ rozszerzenia w JupyterLab są eksperymentalne i nie są dostarczane razem z pakietem jupyterlab, musimy zainstalować i skonfigurować je ręcznie.

Zainstalujemy NodeJS i menedżera pakietów dla niego — NPM, ponieważ JupyterLab używa ich do swoich rozszerzeń:

lxc exec jupyterlab -- apk add nodejs npm

Aby zainstalowane rozszerzenia dla JupyterLab działały, muszą być instalowane w katalogu użytkownika, ponieważ aplikacja będzie uruchamiana z uprawnieniami użytkownika jupyter. Problem polega na tym, że nie ma parametru w poleceniu uruchomienia, którego można by użyć do przekazania katalogu, aplikacja przyjmuje tylko zmienną środowiskową, dlatego musimy ją zdefiniować. W tym celu napiszemy polecenie eksportu zmiennej JUPYTERLAB_DIR w środowisku użytkownika jupyter, w pliku .bashrc, który jest wykonywany za każdym razem, gdy użytkownik loguje się do systemu:

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

Następnym poleceniem zainstalujemy specjalne rozszerzenie — menedżera rozszerzeń w 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"

Teraz wszystko jest gotowe do pierwszego uruchomienia JupyterLab, ale możemy jeszcze zainstalować kilka przydatnych rozszerzeń:

  • toc — Spis Treści, generuje listę nagłówków w artykule/notatniku
  • jupyterlab-horizon-theme — Temat UI
  • jupyterlab_neon_theme — Temat UI
  • jupyterlab-ubu-theme — Jeszcze jeden temat od autora tego artykułu 🙂 Ale w tym przypadku instalacja będzie pokazana z repozytorium GitHub

Więc, wykonaj 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 przy instalacji podano klucz --no-build aby zaoszczędzić czas. Teraz znacznie przyspieszymy, kompilując je razem za jednym razem:

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

Teraz wykonaj następujące dwa polecenia dla pierwszego uruchomienia JupyterLab. Można by go uruchomić jednym poleceniem, ale w takim przypadku polecenie uruchomienia, które będziemy trzymać w pamięci, zostanie zapamiętane przez bash w kontenerze, a nie na hoście, gdzie i tak jest wystarczająco dużo poleceń do zapisania w historii 🙂

Logujemy się do kontenera jako użytkownik jupyter:

lxc exec jupyterlab -- su -l jupyter

Następnie uruchom JupyterLab z kluczami i parametrami, jak podano:

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

Przejdź w przeglądarce internetowej pod adres http://10.0.5.5:8888 i na otwartej stronie wpisz token dostęp, który zobaczysz na konsoli. Skopiuj go i wklej na stronie, a następnie naciśnij Zaloguj się. Po zalogowaniu przejdź do menu rozszerzeń po lewej stronie, jak pokazano na poniższym obrazku, gdzie zostaniesz poproszony o zaakceptowanie ryzyka związanego z bezpieczeństwem przy aktywacji menedżera rozszerzeń instalując rozszerzenia od osób trzecich, za które zespół JupyterLab development nie ponosi odpowiedzialności:

Uruchamiamy Jupyter na orbicie LXD

Jednak właśnie w tym celu całkowicie izolujemy JupyterLab i umieszczamy go w kontenerze, aby zewnętrzne rozszerzenia wymagające i korzystające z NodeJS nie mogły przynajmniej ukraść danych na dysku poza tymi, które otworzymy wewnątrz kontenera. Dotarcie do twoich prywatnych dokumentów na hoście /home z procesów w kontenerze raczej się nie uda, a jeśli tak, to potrzebne są odpowiednie uprawnienia do plików w systemie hosta, ponieważ uruchamiamy kontener w trybie bez uprawnień. Na podstawie tych informacji możesz ocenić ryzyko związane z włączeniem rozszerzeń w JupyterLab.

Tworzone notatniki IPython (strony w JupyterLab) będą teraz tworzone w katalogu domowym użytkownika — /home/jupyter, ale mamy w planach podzielić dane (udostępnić) między hostem a kontenerem, dlatego wróć do konsoli i zatrzymaj JupyterLab używając skrótu — CTRL+C i odpowiadając y na zapytanie. Następnie zakończ interaktywną sesję użytkownika jupyter używając skrótu CTRL+D.

Udostępnianie danych z hostem ^

Aby podzielić dane z hostem, musisz stworzyć w kontenerze takie urządzenie, które to umożliwia, i aby to zrobić, wykonaj następujące polecenie, w którym wskazujemy następujące klucze:

  • lxc config device add — Polecenie dodaje konfigurację urządzenia
  • jupyter — Identyfikator kontenera, do którego dodawana jest konfiguracja
  • hostfs — Id urządzenia. Możesz nadać dowolną nazwę.
  • dysk — Wskazuje typ urządzenia
  • path — Wskazuje ścieżkę w kontenerze, do którego LXD zamontuje to urządzenie
  • source — Wskazuje źródło, ścieżkę do katalogu na hoście, który chcesz podzielić z kontenerem. Podaj ścieżkę zgodnie z własnymi preferencjami
lxc config device add jupyterlab hostfs disk path=\/mnt\/hostfs source=\/home\/dv\/projects\/ipython-notebooks

Dla katalogu /home/dv/projects/ipython-notebooks musi być przypisane uprawnienie użytkownikowi kontenera, który obecnie ma UID równy SubUID + UID, zobacz rozdział Bezpieczeństwo. Uprawnienia kontenerów w artykule Podstawowe możliwości LXD — systemu kontenerów w Linuxie.

Przypisujemy uprawnienia na hoście, gdzie właścicielem będzie użytkownik kontenera jupyter, a zmienna $USER wskaże twojego użytkownika hosta jako grupę:

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

Witaj, świecie! ^

Jeśli wciąż masz otwartą sesję konsolową w kontenerze z JupyterLab, to zrestartuj ją z nowym kluczem --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 notatnik, klikając przycisk na stronie, jak pokazano na poniższym obrazku:

Uruchamiamy Jupyter na orbicie LXD

Następnie w polu na stronie wpisz kod w języku Python, który wyświetli klasyczny Hello World!. Po zakończeniu wpisywania naciśnij CTRL+ENTER lub przycisk „play” na górnym pasku narzędzi, aby JupyterLab to wykonał:

Uruchamiamy Jupyter na orbicie LXD

Na tym prawie wszystko jest gotowe do użycia, ale będzie nudno, jeśli nie zainstalujemy dodatkowych modułów Pythona (pełnych aplikacji), które znacznie rozszerzają standardowe możliwości Pythona w JupyterLab, więc idziemy dalej 🙂

P.S. Ciekawe, że stara wersja Jupyter pod nazwą kodową Jupyter Notebook wcale nie zniknęła i istnieje równolegle z JupyterLab. Aby przejść do starej wersji, idź do linku, dodając do adresu sufiks/tree, a przejście do nowej wersji odbywa się z sufiksem /lab, ale nie trzeba go podawać:

Rozszerzamy możliwości Pythona ^

W tej sekcji zainstalujemy potężne moduły języka Python, których wyniki będą integrowane w notatnikach NumPy, Pandas, Matplotlib, IPyWidgets Zanim zainstalujemy wymienione moduły Pythona przez menedżera pakietów JupyterLab.

musimy najpierw rozwiązać zależności systemowe w Alpine Linux: pip — Potrzebny do kompilacji modułów, ponieważ niektóre z nich są zrealizowane w języku

  • g++ — Potrzebny do kompilacji modułów, ponieważ niektóre z nich są zrealizowane w języku C++ i łączą się z Pythonem w czasie wykonywania jako moduły binarne
  • freetype-dev — zależność dla modułu Pythona Matplotlib

Instalujemy zależności:

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

Jest jeden problem, w obecnym stanie dystrybucji Alpine Linux nie uda się skompilować nowej wersji NumPy, wystąpi błąd kompilacji, którego nie udało mi się rozwiązać:

ERROR: Nie można zbudować kółek dla numpy, które używają PEP 517 i nie można ich zainstalować bezpośrednio

Dlatego ten moduł zainstalujemy jako pakiet systemowy, który dystrybuuje już skompilowaną wersję, ale nieco starszą niż ta dostępna obecnie na stronie:

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

Następnie instalujemy moduły Pythona za pośrednictwem menedżera pakietów pip. Miej trochę cierpliwości, ponieważ niektóre moduły będą kompilowane i to zajmie kilka minut. Na mojej maszynie kompilacja zajęła około 15 minut:

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

Czyścimy pamięci podręczne 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 uruchomiony JupyterLab, zrestartuj go, aby nowe zainstalowane moduły aktywowały się. W tym celu w sesji konsolowej naciśnij CTRL+C tam, gdzie jest uruchomiony i wpisz y na prośbę o zatrzymanie, a następnie uruchom ponownie JupyterLab naciskając strzałkę w górę na klawiaturze, aby nie wpisywać komendy ponownie, a potem Enter aby uruchomić:

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

Przejdź na stronę http://10.0.5.5:8888/lab lub odśwież stronę w przeglądarce, a następnie wpisz następujący 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ś uzyskać wynik jak na poniższym obrazku, gdzie IPyWidgets generuje element UI na stronie, który działa interaktywnie z kodem źródłowym oraz Matplotlib wyświetla wynik kodu w postaci obrazu jak wykres funkcji:

Uruchamiamy Jupyter na orbicie LXD

Wiele przykładów IPyWidgets możesz znaleźć w samouczkach tutaj

Co jeszcze? ^

Jesteście świetni, jeśli zostaliście i dotarliście do samego końca artykułu. Specjalnie nie zamieściłem gotowego skryptu na końcu artykułu, który zainstalowałby JupyterLab w „jednym kliknięciu”, aby zachęcić pracowników 🙂 Ale możecie to zrobić sami, ponieważ już wiecie jak, zbierając komendy w jeden skrypt Bash 🙂

Możesz także:

  • Nadać nazwę sieciową dla kontenera zamiast adresu IP, wpisując go w prostym /etc/hosts i w przeglądarce wpisywać adres http://jupyter.local:8888
  • Zabawa z ograniczeniem zasobów dla kontenera, w tym celu przeczytaj rozdział w podstawowych możliwościach LXD lub uzyskaj więcej informacji na stronie dewelopera LXD.
  • Zmień motyw:

Uruchamiamy Jupyter na orbicie LXD

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

AKTUALIZACJA: 15.04.2020 18:30 — Poprawiłem błędy w rozdziale „Hello, World!”
AKTUALIZACJA: 16.04.2020 10:00 — Skorygowałem i dodałem tekst w opisie aktywacji menedżera rozszerzeń JupyterLab
AKTUALIZACJA: 16.04.2020 10:40 — Poprawiłem znalezione błędy w tekście i nieco poprawiłem rozdział „Instalacja podstawowego oprogramowania i konfiguracja systemu”

Źródło: habr.com

Kup solidny hosting stron z ochroną przed DDoS, serwery VPS VDS 🔥 Kup solidny hosting stron z ochroną przed DDoS, serwery VPS VDS | ProHoster