ProHoster > Blog > administrasi > Meluncurkan Jupyter ke orbit LXD

Meluncurkan Jupyter ke orbit LXD

Pernahkah Anda bereksperimen dengan kode atau utilitas sistem di Linux Jadi, Anda tidak perlu khawatir tentang sistem yang mendasarinya dan menghancurkan segalanya jika ada kesalahan dalam kode yang perlu dijalankan dengan hak akses root?

Namun bagaimana dengan fakta bahwa katakanlah Anda perlu menguji atau menjalankan seluruh cluster dari berbagai layanan mikro pada satu mesin? Seratus atau bahkan seribu?

Mesin virtual yang dikelola oleh hypervisor mungkin dapat menyelesaikan masalah tersebut, tetapi berapa biayanya? Misalnya, kontainer LXD yang berbasis pada distribusi Alpine. Linux mengonsumsi segala sesuatu seminimal mungkin. 7.60MB RAM, dan di mana partisi root menempati setelah startup 9.5MB! Bagaimana Anda menyukainya, Elon Musk? Saya sarankan untuk memeriksanya kemampuan dasar LXD - sebuah sistem kontainer di Linux

Setelah menjadi jelas secara umum apa itu wadah LXD, mari kita melangkah lebih jauh dan berpikir, bagaimana jika ada platform pemanen di mana Anda dapat dengan aman menjalankan kode untuk host, menghasilkan grafik, menghubungkan widget UI secara dinamis (interaktif) dengan kode Anda, melengkapi kode dengan teks dengan format blackjack...? Semacam blog interaktif? Wah... aku menginginkannya! Ingin! 🙂

Lihat di bawah kucing di mana kita akan meluncurkannya dalam sebuah wadah laboratorium jupyter - antarmuka pengguna generasi berikutnya alih-alih Notebook Jupyter yang sudah ketinggalan zaman, dan kami juga akan menginstal modul Python seperti JumlahPy, Panda, Matplotlib, Widget IPy yang memungkinkan Anda melakukan semua hal di atas dan menyimpan semuanya dalam file khusus - laptop IPython.

Meluncurkan Jupyter ke orbit LXD

Rencana lepas landas orbit ^

Meluncurkan Jupyter ke orbit LXD

Mari kita uraikan rencana aksi singkat untuk memudahkan kita menerapkan skema di atas:

  • Mari kita instal dan luncurkan container berdasarkan kit distribusi Alpine Linux. Kami akan menggunakan distribusi ini karena ditujukan untuk minimalis dan hanya akan menginstal perangkat lunak yang paling diperlukan ke dalamnya, tidak ada yang berlebihan.
  • Mari tambahkan disk virtual tambahan ke dalam wadah dan beri nama - hostfs dan pasang ke sistem file root. Disk ini memungkinkan untuk menggunakan file di host dari direktori tertentu di dalam container. Dengan demikian, data kita tidak bergantung pada wadahnya. Jika penampung dihapus, data akan tetap ada di host. Selain itu, skema ini berguna untuk berbagi data yang sama antara banyak container tanpa menggunakan mekanisme jaringan standar distribusi container.
  • Mari instal Bash, sudo, perpustakaan yang diperlukan, tambahkan dan konfigurasikan pengguna sistem
  • Mari instal Python, modul, dan kompilasi dependensi biner untuknya
  • Mari kita instal dan luncurkan laboratorium jupyter, sesuaikan tampilan, instal ekstensi untuk itu.

Pada artikel ini kami akan mulai dengan meluncurkan container, kami tidak akan mempertimbangkan instalasi dan konfigurasi LXD, Anda dapat menemukan semua ini di artikel lain - Kemampuan dasar LXD, sebuah sistem kontainer di Linux.

Instalasi dan konfigurasi sistem dasar ^

Kami membuat wadah dengan perintah di mana kami menentukan gambar - alpine3, pengidentifikasi untuk wadah - jupyterlab dan, jika perlu, profil konfigurasi:

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

Di sini saya menggunakan profil konfigurasi hddroot yang menentukan untuk membuat wadah dengan partisi root Kolam Penyimpanan terletak di disk HDD fisik:

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

Ini memberi saya kesempatan untuk bereksperimen dengan wadah pada disk HDD, menghemat sumber daya disk SSD, yang juga tersedia di sistem saya 🙂 yang mana saya telah membuat profil konfigurasi terpisah ssdroot.

Setelah wadah dibuat, ia berada dalam status STOPPED, jadi kita perlu memulainya dengan menjalankan sistem init di dalamnya:

lxc start jupyterlab

Mari kita tampilkan daftar container di LXD menggunakan kuncinya -c yang menunjukkan yang mana ctampilan kolom:

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

Saat membuat penampung, alamat IP dipilih secara acak, karena kami menggunakan profil konfigurasi default yang sebelumnya dikonfigurasi dalam artikel Kemampuan dasar LXD, sebuah sistem kontainer di Linux.

Kami akan mengubah alamat IP ini menjadi lebih mudah diingat dengan membuat antarmuka jaringan di tingkat kontainer, dan bukan di tingkat profil konfigurasi seperti yang sekarang terjadi pada konfigurasi saat ini. Anda tidak harus melakukan ini, Anda bisa melewatkannya.

Membuat antarmuka jaringan eth0 yang kita tautkan ke switch (jembatan jaringan) lxdbr0 di mana kami mengaktifkan NAT sesuai dengan artikel sebelumnya dan penampung sekarang akan memiliki akses ke Internet, dan kami juga menetapkan alamat IP statis ke antarmuka - 10.0.5.5:

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

Setelah menambahkan perangkat, wadah harus di-boot ulang:

lxc restart jupyterlab

Memeriksa status kontainer:

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

Menginstal perangkat lunak dasar dan mengatur sistem ^

Untuk mengelola container kami, Anda perlu menginstal perangkat lunak berikut:

Paket
Deskripsi

menampar
Cangkang GNU Bourne Again

penyelesaian bash
Penyelesaian yang dapat diprogram untuk bash shell

sudo
Berikan pengguna tertentu kemampuan untuk menjalankan beberapa perintah sebagai root

bayangan
Rangkaian alat manajemen kata sandi dan akun dengan dukungan untuk file bayangan dan PAM

tzdata
Sumber data zona waktu dan waktu musim panas

nano
Klon editor Pico dengan penyempurnaan

Selain itu, Anda dapat menginstal dukungan di halaman manual sistem dengan menginstal paket berikut - man man-pages mdocml-apropos less

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

Mari kita lihat perintah dan tombol yang kami gunakan:

  • lxc — Hubungi klien LXD
  • exec - Metode klien LXD yang menjalankan perintah dalam wadah
  • jupyterlab — ID Kontainer
  • -- - Kunci khusus yang menentukan untuk tidak menafsirkan kunci selanjutnya sebagai kunci lxc dan meneruskan sisa string apa adanya ke wadah
  • apk — Manajer paket distribusi Alpine Linux
  • add — Metode manajer paket yang menginstal paket yang ditentukan setelah perintah

Selanjutnya, kita akan mengatur zona waktu di sistem Europe/Moscow:

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

Setelah menginstal zona waktu, paketnya tzdata tidak lagi diperlukan dalam sistem, ini akan memakan ruang, jadi mari kita hapus:

lxc exec jupyterlab -- apk del tzdata

Memeriksa zona waktu:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Untuk menghemat waktu dalam menyiapkan Bash untuk pengguna baru di dalam container, kita akan menyalin file skel yang sudah jadi dari sistem host ke dalamnya. Ini akan memungkinkan kita untuk menyesuaikan Bash di dalam container dalam mode interaktif. Sistem host saya adalah Manjaro. Linux dan menyalin file /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors Pada prinsipnya, mereka cocok untuk Alpine. Linux dan tidak menyebabkan masalah kritis, tetapi Anda mungkin memiliki distribusi yang berbeda dan Anda perlu mencari tahu sendiri apakah ada kesalahan saat menjalankan Bash di dalam kontainer.

Salin file skel ke wadah. Kunci --create-dirs akan membuat direktori yang diperlukan jika tidak ada:

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

Untuk pengguna root yang sudah ada, salin file skel yang baru saja disalin ke dalam container ke direktori home:

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

Di Alpen Linux shell sistem diinstal untuk pengguna. /bin/sh, kami akan menggantinya dengan root pengguna di Bash:

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

Bahwa root pengguna tidak memiliki kata sandi, dia perlu mengatur kata sandi. Perintah berikut akan menghasilkan dan menetapkan kata sandi acak baru untuknya, yang akan Anda lihat di layar konsol setelah dijalankan:

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

Juga, mari buat pengguna sistem baru - jupyter yang akan kita konfigurasikan nanti laboratorium jupyter:

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

Mari buat dan tetapkan kata sandi untuk itu:

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

Selanjutnya kita akan menjalankan dua perintah, yang pertama akan membuat grup sistem sudo, dan yang kedua akan menambahkan pengguna ke dalamnya jupyter:

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

Mari kita lihat di grup mana pengguna tersebut berada jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Semuanya baik-baik saja, mari kita lanjutkan.

Izinkan semua pengguna yang menjadi anggota grup sudo gunakan perintah sudo. Untuk melakukan ini, jalankan skrip berikut, di mana sed batalkan komentar pada baris parameter di file konfigurasi /etc/sudoers:

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

Menginstal dan mengonfigurasi JupyterLab ^

laboratorium jupyter adalah aplikasi Python, jadi kita harus menginstall interpreter ini terlebih dahulu. Juga, laboratorium jupyter kami akan menginstal menggunakan manajer paket Python pip, dan bukan yang sistem, karena mungkin sudah ketinggalan jaman di repositori sistem dan oleh karena itu, kita harus menyelesaikan dependensinya secara manual dengan menginstal paket berikut - python3 python3-dev gcc libc-dev zeromq-dev:

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

Mari perbarui modul python dan manajer paket pip ke versi saat ini:

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

Mengatur laboratorium jupyter melalui manajer paket pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Sejak ekstensi di laboratorium jupyter bersifat eksperimental dan tidak dikirimkan secara resmi bersama paket jupyterlab, jadi kami harus menginstal dan mengkonfigurasinya secara manual.

Mari kita instal NodeJS dan manajer paketnya - NPM laboratorium jupyter menggunakannya untuk ekstensinya:

lxc exec jupyterlab -- apk add nodejs npm

Untuk ekstensi untuk laboratorium jupyter yang akan kita instal berfungsi, mereka harus diinstal di direktori pengguna karena aplikasi akan diluncurkan dari pengguna jupyter. Masalahnya adalah tidak ada parameter dalam perintah peluncuran yang dapat diteruskan ke direktori; aplikasi hanya menerima variabel lingkungan dan oleh karena itu kita harus mendefinisikannya. Untuk melakukan ini, kita akan menulis perintah ekspor variabel JUPYTERLAB_DIR di lingkungan pengguna jupyter, untuk mengajukan .bashrcyang dijalankan setiap kali pengguna login:

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

Perintah selanjutnya akan menginstal ekstensi khusus - manajer ekstensi di laboratorium jupyter:

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

Sekarang semuanya siap untuk peluncuran pertama laboratorium jupyter, namun kami masih dapat memasang beberapa ekstensi yang berguna:

  • toc — Daftar Isi, menghasilkan daftar judul dalam artikel/buku catatan
  • jupyterlab-horizon-theme — Tema UI
  • jupyterlab_neon_theme — Tema UI
  • jupyterlab-ubu-theme - Yang lainnya tema dari penulis artikel ini :) Namun dalam kasus ini, instalasi dari repositori GitHub akan ditampilkan

Jadi, jalankan perintah berikut secara berurutan untuk menginstal ekstensi ini:

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"

Setelah menginstal ekstensi, kita harus mengkompilasinya, karena sebelumnya, selama instalasi, kami menentukan kuncinya --no-build untuk menghemat waktu. Sekarang kita akan mempercepatnya secara signifikan dengan menggabungkannya sekaligus:

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

Sekarang jalankan dua perintah berikut untuk menjalankannya pertama kali laboratorium jupyter. Dimungkinkan untuk meluncurkannya dengan satu perintah, tetapi dalam kasus ini, perintah peluncuran, yang sulit diingat dalam pikiran Anda, akan diingat oleh bash di dalam wadah, dan bukan di host, di mana sudah terdapat cukup banyak perintah. untuk mencatatnya dalam sejarah :)

Masuk ke wadah sebagai pengguna jupyter:

lxc exec jupyterlab -- su -l jupyter

Selanjutnya, jalankan laboratorium jupyter dengan kunci dan parameter seperti yang ditunjukkan:

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

Buka alamat di browser web Anda http://10.0.5.5:8888 dan pada halaman yang terbuka, enter token akses yang akan Anda lihat di konsol. Salin dan tempel di halaman, lalu klik Masuk. Setelah masuk, buka menu ekstensi di sebelah kiri, seperti yang ditunjukkan pada gambar di bawah, di mana Anda akan diminta, saat mengaktifkan manajer ekstensi, untuk mengambil risiko keamanan dengan memasang ekstensi dari pihak ketiga yang perintahnya Pengembangan JupyterLab tidak bertanggung jawab:

Meluncurkan Jupyter ke orbit LXD

Namun, kami mengisolasi keseluruhannya laboratorium jupyter dan letakkan di dalam container agar ekstensi pihak ketiga yang membutuhkan dan menggunakan NodeJS setidaknya tidak bisa mencuri data di disk selain yang kita buka di dalam container tersebut. Dapatkan dokumen pribadi Anda di host /home proses dari penampung kemungkinan besar tidak akan berhasil, dan jika berhasil, maka Anda harus memiliki hak istimewa pada file di sistem host, karena kami menjalankan penampung di mode tanpa hak istimewa. Berdasarkan informasi ini, Anda dapat menilai risiko memasukkan ekstensi ke dalamnya laboratorium jupyter.

Membuat buku catatan IPython (halaman dalam laboratorium jupyter) sekarang akan dibuat di direktori home pengguna - /home/jupyter, tetapi rencana kami adalah membagi data (berbagi) antara host dan penampung, jadi kembali ke konsol dan berhenti laboratorium jupyter dengan menjalankan tombol pintas - CTRL+C dan menjawab y berdasarkan permintaan. Kemudian akhiri sesi interaktif pengguna jupyter menyelesaikan tombol pintas CTRL+D.

Berbagi data dengan tuan rumah ^

Untuk berbagi data dengan host, Anda perlu membuat perangkat dalam wadah yang memungkinkan Anda melakukan hal ini dan untuk melakukan hal ini, jalankan perintah berikut di mana kami menentukan kunci berikut:

  • lxc config device add — Perintah menambahkan konfigurasi perangkat
  • jupyter — ID kontainer yang konfigurasinya ditambahkan
  • hostfs — ID Perangkat. Anda dapat menetapkan nama apa pun.
  • disk — Jenis perangkat ditunjukkan
  • path — Menentukan jalur dalam wadah tempat LXD akan memasang perangkat ini
  • source — Tentukan sumber, jalur ke direktori pada host yang ingin Anda bagikan dengan container. Tentukan jalur sesuai dengan preferensi Anda
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Untuk katalog /home/dv/projects/ipython-notebooks izin harus disetel ke pengguna kontainer yang saat ini memiliki UID yang sama SubUID + UID, lihat bab Keamanan. Hak Istimewa Kontainer di artikel Kemampuan dasar LXD, sebuah sistem kontainer di Linux.

Tetapkan izin pada host, dimana pemiliknya akan menjadi pengguna container jupyter, dan variabelnya $USER akan menentukan pengguna host Anda sebagai grup:

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

Halo Dunia! ^

Jika Anda masih memiliki sesi konsol yang terbuka di wadah dengan laboratorium jupyter, lalu mulai ulang dengan kunci baru --notebook-dir dengan menetapkan nilainya /mnt/hostfs sebagai path menuju root laptop pada container perangkat yang sudah kita buat pada langkah sebelumnya :

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

Kemudian pergi ke halaman http://10.0.5.5:8888 dan buat laptop pertama anda dengan mengklik tombol pada halaman seperti terlihat pada gambar di bawah ini:

Meluncurkan Jupyter ke orbit LXD

Kemudian, pada kolom halaman tersebut, masukkan kode Python yang akan menampilkan klasik Hello World!. Jika sudah selesai masuk, tekan CTRL+ENTER atau tombol "putar" pada toolbar di bagian atas agar JupyterLab melakukan ini:

Meluncurkan Jupyter ke orbit LXD

Pada titik ini, hampir semuanya siap digunakan, tetapi tidak akan menarik jika kita tidak menginstal modul Python tambahan (aplikasi lengkap) yang secara signifikan dapat memperluas kemampuan standar Python di laboratorium jupyter, oleh karena itu, mari kita lanjutkan :)

PS Yang menarik adalah implementasinya yang lama jupyter di bawah nama kode Notebook Jupyter belum hilang dan itu ada secara paralel dengan laboratorium jupyter. Untuk beralih ke versi lama, ikuti tautan yang menambahkan akhiran di alamat/tree, dan transisi ke versi baru dilakukan dengan akhiran /lab, tetapi tidak harus ditentukan:

Memperluas kemampuan Python ^

Di bagian ini, kita akan menginstal modul bahasa Python yang kuat seperti JumlahPy, Panda, Matplotlib, Widget IPy yang hasilnya diintegrasikan ke dalam laptop laboratorium jupyter.

Sebelum menginstal modul Python yang terdaftar melalui manajer paket pip Pertama-tama kita harus menyelesaikan ketergantungan sistem di Alpine. Linux:

  • g++ — Diperlukan untuk mengkompilasi modul, karena beberapa di antaranya diimplementasikan dalam bahasa tersebut C + + dan terhubung ke Python saat runtime sebagai modul biner
  • freetype-dev - ketergantungan untuk modul Python Matplotlib

Menginstal dependensi:

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

Ada satu masalah dengan kondisi distribusi Alpine saat ini. Linux Saya tidak dapat mengkompilasi versi baru NumPy; saya mendapatkan kesalahan kompilasi yang tidak dapat saya atasi:

ERROR: Tidak dapat membuat roda untuk numpy yang menggunakan PEP 517 dan tidak dapat dipasang secara langsung

Oleh karena itu, kami akan menginstal modul ini sebagai paket sistem yang mendistribusikan versi yang sudah dikompilasi, tetapi sedikit lebih lama dari yang saat ini tersedia di situs:

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

Selanjutnya, instal modul Python melalui manajer paket pip. Harap bersabar karena beberapa modul akan dikompilasi dan mungkin memerlukan waktu beberapa menit. Di mesin saya, kompilasi memakan waktu ~15 menit:

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

Menghapus cache instalasi:

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

Menguji modul di JupyterLab ^

Jika Anda sedang berlari laboratorium jupyter, restart agar modul yang baru diinstal diaktifkan. Untuk melakukannya, di sesi konsol, klik CTRL+C di mana Anda menjalankannya dan masuk y untuk menghentikan permintaan dan kemudian memulai lagi laboratorium jupyter dengan cara menekan tanda panah atas pada keyboard agar tidak memasukkan perintah lagi dan lagi Enter untuk memulainya:

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

Pergi ke halaman http://10.0.5.5:8888/lab atau segarkan halaman di browser Anda, lalu masukkan kode berikut di sel buku catatan baru:

%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

Anda harus mendapatkan hasil seperti pada gambar di bawah ini, dimana Widget IPy menghasilkan elemen UI pada halaman yang berinteraksi secara interaktif dengan kode sumber, dan juga Matplotlib menampilkan hasil kode berupa gambar sebagai grafik fungsi:

Meluncurkan Jupyter ke orbit LXD

Banyak contoh Widget IPy Anda dapat menemukannya di tutorial di sini

Apa lagi? ^

Bagus sekali jika Anda tetap tinggal dan mencapai akhir artikel. Sengaja saya tidak memposting script yang sudah jadi di akhir artikel yang akan saya install laboratorium jupyter dalam "satu klik" untuk mendorong pekerja :) Tapi Anda bisa melakukannya sendiri, karena Anda sudah tahu caranya, setelah mengumpulkan perintah ke dalam satu skrip Bash :)

Anda juga bisa:

  • Tetapkan nama jaringan untuk penampung alih-alih alamat IP dengan menuliskannya secara sederhana /etc/hosts dan ketik alamatnya di browser http://jupyter.local:8888
  • Bermain-main dengan batas sumber daya untuk wadah, untuk ini bacalah bab di kemampuan dasar LXD atau dapatkan informasi lebih lanjut di situs pengembang LXD.
  • Ubah tema:

Meluncurkan Jupyter ke orbit LXD

Dan masih banyak lagi yang dapat Anda lakukan! Itu saja. Aku harap kamu berhasil!

PEMBARUAN: 15.04.2020/18/30 XNUMX:XNUMX - Memperbaiki kesalahan pada bab "Halo, Dunia!"
PEMBARUAN: 16.04.2020/10/00 XNUMX:XNUMX — Memperbaiki dan menambahkan teks dalam deskripsi aktivasi manajer ekstensi laboratorium jupyter
PEMBARUAN: 16.04.2020/10/40 XNUMX:XNUMX — Kesalahan yang ditemukan dalam teks diperbaiki dan sedikit diubah menjadi lebih baik pada bab “Menginstal perangkat lunak dasar dan mengatur sistem”

Sumber: www.habr.com

Beli hosting yang andal untuk situs dengan perlindungan DDoS, server VPS VDS 🔥 Beli hosting website andal dengan perlindungan DDoS, server VPS VDS | ProHoster