ProHoster > Blog > yönetim > Jüpyter'in LXD yörüngesine fırlatılması

Jüpyter'in LXD yörüngesine fırlatılması

Temel sistem hakkında endişelenmemek ve kök ayrıcalıklarıyla çalışması gereken kodda bir hata olması durumunda her şeyi mahvetmemek için Linux'ta kod veya sistem yardımcı programları ile denemeler yapmak zorunda kaldınız mı?

Peki, diyelim ki, çeşitli mikro hizmetlerden oluşan bir kümeyi tek bir makinede test etmeniz veya çalıştırmanız gerektiği gerçeğine ne dersiniz? Yüz, hatta bin mi?

Bir hipervizör tarafından yönetilen sanal makinelerle bu tür sorunlar çözülebilir ve çözülecektir, ancak bunun maliyeti nedir? Örneğin, Alpine Linux dağıtımını temel alan LXD'deki bir konteyner yalnızca 7.60MB RAM ve başlatma sonrasında kök bölümünün kapladığı yer 9.5MB! Bunu beğendin mi Elon Musk? Kontrol etmenizi öneririm Linux'ta bir konteyner sistemi olan LXD'nin temel yetenekleri

Genel olarak LXD konteynerlerinin ne olduğu netleştikten sonra, daha da ileri gidelim ve düşünelim: Ana bilgisayar için güvenli bir şekilde kod çalıştırabileceğiniz, grafikler oluşturabileceğiniz, UI widget'larını kodunuza dinamik (etkileşimli) olarak bağlayabileceğiniz böyle bir hasat platformu olsaydı ne olurdu? kodu blackjack... biçimlendirmeli metinle tamamla? Bir çeşit etkileşimli blog mu? Vay... İstiyorum! İstek! 🙂

Bir konteynere fırlatacağımız kedinin altına bakın JüpyterLab - eski Jupyter Notebook yerine yeni nesil kullanıcı arayüzü ve ayrıca aşağıdaki gibi Python modüllerini de kuracağız: Dizi, Pandalar, matplotlib, IPyWidget'lar bu, yukarıda listelenen her şeyi yapmanıza ve hepsini özel bir dosyaya - bir IPython dizüstü bilgisayara - kaydetmenize olanak tanır.

Jüpyter'in LXD yörüngesine fırlatılması

Yörünge kalkış planı ^

Jüpyter'in LXD yörüngesine fırlatılması

Yukarıdaki planın uygulanmasını kolaylaştıracak kısa bir eylem planının ana hatlarını çizelim:

  • Dağıtım kitini temel alarak bir konteyner kurup çalıştıralım Alp Linux. Bu dağıtımı minimalizmi hedeflediği ve yalnızca en gerekli yazılımı kuracağı için kullanacağız, gereksiz hiçbir şey yok.
  • Kabın içine ek bir sanal disk ekleyelim ve ona bir isim verelim - hostfs ve onu kök dosya sistemine bağlayın. Bu disk, ana bilgisayardaki dosyaların kapsayıcının içindeki belirli bir dizinden kullanılmasını mümkün kılacaktır. Böylece verilerimiz konteynerden bağımsız olacaktır. Konteyner silinirse veriler ana bilgisayarda kalacaktır. Ayrıca bu şema, konteyner dağıtımının standart ağ mekanizmalarını kullanmadan aynı verileri birçok konteyner arasında paylaşmak için kullanışlıdır.
  • Bash'i, sudo'yu, gerekli kütüphaneleri kuralım, bir sistem kullanıcısı ekleyelim ve yapılandıralım
  • Python'u, modülleri kuralım ve onlar için ikili bağımlılıkları derleyelim
  • Haydi kurup başlatalım JüpyterLab, görünümü özelleştirin, bunun için uzantılar yükleyin.

Bu yazıda konteyneri başlatmakla başlayacağız, LXD'yi kurmayı ve yapılandırmayı düşünmeyeceğiz, tüm bunları başka bir makalede bulabilirsiniz - LXD - Linux konteyner sistemlerinin temel özellikleri.

Temel sistemin kurulumu ve konfigürasyonu ^

Görüntüyü belirttiğimiz komutla bir kap oluşturuyoruz - alpine3, konteynerin tanımlayıcısı - jupyterlab ve gerekirse konfigürasyon profilleri:

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

Burada bir konfigürasyon profili kullanıyorum hddroot içinde kök bölümü olan bir kap oluşturulacağını belirtir Depolama havuzu fiziksel bir HDD diskinde bulunur:

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

Bu bana, sistemimde de bulunan SSD diskinin kaynaklarından tasarruf ederek HDD diskindeki kapları deneme fırsatı veriyor 🙂 bunun için ayrı bir yapılandırma profili oluşturdum ssdroot.

Container oluşturulduktan sonra bu durumda olur. STOPPED, bu yüzden içindeki init sistemini çalıştırarak başlatmamız gerekiyor:

lxc start jupyterlab

tuşunu kullanarak LXD'de konteynerlerin listesini görüntüleyelim -c bu hangisini gösterir columns ekranı:

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

Kapsayıcıyı oluştururken, bir yapılandırma profili kullandığımız için IP adresi rastgele seçildi default daha önce makalede yapılandırılmış olan LXD - Linux konteyner sistemlerinin temel özellikleri.

Şu anda mevcut konfigürasyonda olduğu gibi konfigürasyon profili seviyesinde değil, konteyner seviyesinde bir ağ arayüzü oluşturarak bu IP adresini daha akılda kalıcı bir adresle değiştireceğiz. Bunu yapmak zorunda değilsiniz, atlayabilirsiniz.

Ağ arayüzü oluşturma eth0 anahtara bağladığımız (ağ köprüsü) lxdbr0 önceki makaleye göre NAT'ı etkinleştirdiğimiz ve konteynerin artık İnternet'e erişebileceği ve ayrıca arayüze statik bir IP adresi atadığımız - 10.0.5.5:

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

Bir cihaz ekledikten sonra konteynerin yeniden başlatılması gerekir:

lxc restart jupyterlab

Konteynerin durumunun kontrol edilmesi:

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

Temel yazılımın kurulması ve sistemin kurulması ^

Konteynerimizi yönetmek için aşağıdaki yazılımı yüklemeniz gerekir:

paket
Açıklama

darbe
GNU Bourne Again kabuğu

bash tamamlama
Bash kabuğu için programlanabilir tamamlama

sudo
Belirli kullanıcılara bazı komutları root olarak çalıştırma yeteneği verin

gölge
Gölge dosyaları ve PAM desteğine sahip şifre ve hesap yönetimi araç paketi

tzveri
Saat dilimi ve yaz saati uygulaması verileri için kaynaklar

nano
Geliştirmelere sahip Pico düzenleyici klonu

Ek olarak, aşağıdaki paketleri yükleyerek sistem kılavuz sayfalarına destek yükleyebilirsiniz: man man-pages mdocml-apropos less

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

Kullandığımız komutlara ve tuşlara bakalım:

  • lxc — LXD istemcisini arayın
  • exec - Kapta bir komut çalıştıran LXD istemci yöntemi
  • jupyterlab — Konteyner Kimliği
  • -- - Daha fazla anahtarın anahtar olarak yorumlanmayacağını belirten özel bir anahtar lxc ve dizenin geri kalanını olduğu gibi kaba iletin
  • apk — Alpine Linux dağıtım paketi yöneticisi
  • add — Komuttan sonra belirtilen paketleri yükleyen bir paket yöneticisi yöntemi

Daha sonra sistemde bir saat dilimi ayarlayacağız Europe/Moscow:

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

Saat dilimini yükledikten sonra paket tzdata Artık sistemde gerekli değil, yer kaplayacak, o yüzden silelim:

lxc exec jupyterlab -- apk del tzdata

Saat dilimini kontrol etme:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Container'da yeni kullanıcılar için Bash'i kurarken çok fazla zaman harcamamak adına, aşağıdaki adımlarda hazır skel dosyalarını ana sistemden ona kopyalayacağız. Bu, Bash'i bir kapta etkileşimli olarak güzelleştirmenize olanak tanır. Ana sistemim Manjaro Linux ve kopyalanan dosyalar /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors prensip olarak Alpine Linux için uygundurlar ve kritik sorunlara neden olmazlar, ancak farklı bir dağıtıma sahip olabilirsiniz ve Bash'i kapta çalıştırırken bir hata olup olmadığını bağımsız olarak anlamanız gerekir.

Skel dosyalarını konteynere kopyalayın. Anahtar --create-dirs mevcut değilse gerekli dizinleri oluşturacaktır:

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

Mevcut bir kök kullanıcı için, kaba kopyalanan skel dosyalarını ana dizine kopyalayın:

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, kullanıcılar için bir sistem kabuğu kurar /bin/sh, onu şununla değiştireceğiz: root Bash'teki kullanıcı:

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

O root Kullanıcı şifresiz değildi, bir şifre belirlemesi gerekiyor. Aşağıdaki komut, yürütüldükten sonra konsol ekranında göreceğiniz, onun için yeni bir rastgele şifre oluşturacak ve ayarlayacaktır:

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

Ayrıca yeni bir sistem kullanıcısı oluşturalım - jupyter bunun için daha sonra yapılandıracağız JüpyterLab:

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

Bunun için bir şifre oluşturup belirleyelim:

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

Sonra iki komutu uygulayacağız, ilki bir sistem grubu oluşturacak sudove ikincisi buna bir kullanıcı ekleyecektir jupyter:

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

Kullanıcının hangi gruplara ait olduğunu görelim jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Her şey yolunda, devam edelim.

Grubun üyesi olan tüm kullanıcılara izin ver sudo komutu kullan sudo. Bunu yapmak için aşağıdaki betiği çalıştırın; sed yapılandırma dosyasındaki parametre satırının açıklamasını kaldırır /etc/sudoers:

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

JupyterLab'ı kurma ve yapılandırma ^

JüpyterLab bir Python uygulamasıdır, bu yüzden önce bu yorumlayıcıyı kurmamız gerekir. Ayrıca, JüpyterLab Python paket yöneticisini kullanarak kurulum yapacağız pip, sistem paketi değil, çünkü sistem deposunda güncelliğini kaybetmiş olabilir ve bu nedenle aşağıdaki paketleri yükleyerek bağımlılıkları manuel olarak çözmemiz gerekir - python3 python3-dev gcc libc-dev zeromq-dev:

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

Python modüllerini ve paket yöneticisini güncelleyelim pip güncel versiyona:

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

Ayarlamak JüpyterLab paket yöneticisi aracılığıyla pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Uzantılardan beri JüpyterLab deneyseldir ve resmi olarak jupyterlab paketiyle birlikte gönderilmez, bu nedenle onu manuel olarak kurup yapılandırmamız gerekir.

NodeJS'yi ve bunun için paket yöneticisini (NPM) yükleyelim, çünkü JüpyterLab bunları uzantıları için kullanır:

lxc exec jupyterlab -- apk add nodejs npm

Uzantılara JüpyterLab kuracağımız işe yaradı, uygulama kullanıcı tarafından başlatılacağı için kullanıcı dizinine kurulmaları gerekiyor jupyter. Sorun, başlatma komutunda bir dizine aktarılabilecek hiçbir parametrenin bulunmamasıdır; uygulama yalnızca bir ortam değişkenini kabul eder ve bu nedenle onu tanımlamamız gerekir. Bunu yapmak için değişken bir dışa aktarma komutu yazacağız. JUPYTERLAB_DIR kullanıcının ortamında jupyter, dosyalamak .bashrcKullanıcı her oturum açtığında yürütülür:

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

Bir sonraki komut, özel bir uzantı - uzantı yöneticisi yükleyecektir. JüpyterLab:

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

Artık ilk lansman için her şey hazır JüpyterLab, ancak yine de birkaç yararlı uzantı yükleyebiliriz:

  • toc — İçindekiler Tablosu, bir makale/defterdeki başlıkların listesini oluşturur
  • jupyterlab-horizon-theme — Kullanıcı arayüzü teması
  • jupyterlab_neon_theme — Kullanıcı arayüzü teması
  • jupyterlab-ubu-theme - Bir diğeri yazardan tema bu makale :) Ancak bu durumda GitHub deposundan kurulum gösterilecektir

Bu nedenle, bu uzantıları yüklemek için aşağıdaki komutları sırayla çalıştırın:

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"

Uzantıları yükledikten sonra bunları derlememiz gerekir, çünkü daha önce kurulum sırasında anahtarı belirtmiştik. --no-build zaman kazanma. Şimdi bunları tek seferde derleyerek önemli ölçüde hız kazanacağız:

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

Şimdi ilk kez çalıştırmak için aşağıdaki iki komutu çalıştırın JüpyterLab. Tek komutla başlatmak mümkün olabilir ancak bu durumda aklınızda hatırlaması zor olan başlatma komutu, zaten yeterli komutun bulunduğu ana bilgisayarda değil, konteynerdeki bash tarafından hatırlanacaktır. bunları tarihe not etmek için :)

Kapsayıcıda kullanıcı olarak oturum açın jupyter:

lxc exec jupyterlab -- su -l jupyter

Sonra koş JüpyterLab belirtildiği gibi tuşlar ve parametrelerle:

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

Web tarayıcınızdaki adrese gidin http://10.0.5.5:8888 ve açılan sayfada enter simge Konsolda göreceğiniz erişim. Kopyalayıp sayfaya yapıştırın ve ardından tıklayın. Giriş Yap. Giriş yaptıktan sonra, aşağıdaki şekilde gösterildiği gibi soldaki uzantılar menüsüne gidin; burada uzantı yöneticisini etkinleştirirken, komutun geçerli olduğu üçüncü taraflardan uzantılar yükleyerek güvenlik riskleri almanız istenecektir. JupyterLab geliştirme sorumlu değildir:

Jüpyter'in LXD yörüngesine fırlatılması

Ancak tüm alanı izole ediyoruz. JüpyterLab ve onu bir konteynere yerleştirin, böylece NodeJS gerektiren ve kullanan üçüncü taraf uzantılar, en azından konteynerin içinde açtıklarımız dışındaki diskteki verileri çalamaz. Ana makinedeki özel belgelerinize ulaşın /home Konteynerden gelen işlemlerin başarılı olma ihtimali düşüktür ve başarılı olurlarsa, konteyneri çalıştırdığımız için ana bilgisayar sistemindeki dosyalar üzerinde ayrıcalıklara sahip olmanız gerekir. ayrıcalıksız mod. Bu bilgilere dayanarak uzantıları dahil etmenin riskini değerlendirebilirsiniz. JüpyterLab.

IPython not defterleri oluşturuldu (sayfalar JüpyterLab) şimdi kullanıcının ana dizininde oluşturulacak - /home/jupyter, ancak planlarımız verileri Ana Bilgisayar ile kapsayıcı arasında bölmek (paylaşmak), bu nedenle konsola geri dönün ve durun JüpyterLab kısayol tuşunu çalıştırarak - CTRL+C ve cevap veriyorum y talep üzerine. Daha sonra kullanıcının etkileşimli oturumunu sonlandırın jupyter kısayol tuşunu tamamlama CTRL+D.

Verileri ana bilgisayarla paylaşma ^

Verileri ana bilgisayarla paylaşmak için, konteynerde bunu yapmanıza izin veren bir cihaz oluşturmanız ve bunu yapmak için aşağıdaki anahtarları belirttiğimiz aşağıdaki komutu çalıştırmanız gerekir:

  • lxc config device add — Komut, cihaz yapılandırmasını ekler
  • jupyter — Yapılandırmanın eklendiği konteynerin kimliği
  • hostfs — Cihaz Kimliği. Herhangi bir adı ayarlayabilirsiniz.
  • disk — Cihazın türü belirtilir
  • path — LXD'nin bu cihazı bağlayacağı kapsayıcıdaki yolu belirtir
  • source — Konteynerle paylaşmak istediğiniz ana bilgisayardaki dizinin yolunu ve kaynağını belirtin. Tercihlerinize göre yolu belirtin
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Katalog için /home/dv/projects/ipython-notebooks Şu anda UID'si şuna eşit olan kapsayıcı kullanıcısına izin ayarlanmalıdır: SubUID + UID, bölüme bakın Emniyet. Konteyner Ayrıcalıkları makalede LXD - Linux konteyner sistemlerinin temel özellikleri.

Sahibin konteyner kullanıcısı olacağı ana bilgisayardaki izni ayarlayın jupyterve değişken $USER ana bilgisayar kullanıcınızı bir grup olarak belirleyecektir:

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

Selam Dünya! ^

Kapta hala açık bir konsol oturumunuz varsa JüpyterLab, ardından yeni bir anahtarla yeniden başlatın --notebook-dir değeri ayarlayarak /mnt/hostfs önceki adımda oluşturduğumuz cihazın kapsayıcısındaki dizüstü bilgisayarların kök dizininin yolu olarak:

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

Sonra sayfaya git http://10.0.5.5:8888 ve aşağıdaki resimde gösterildiği gibi sayfadaki butona tıklayarak ilk dizüstü bilgisayarınızı oluşturun:

Jüpyter'in LXD yörüngesine fırlatılması

Ardından sayfadaki alana klasikleri görüntüleyecek Python kodunu girin. Hello World!. Girişi tamamladığınızda tuşuna basın. CTRL+ENTER veya JupyterLab'ın bunu yapması için üstteki araç çubuğundaki "oynat" düğmesine basın:

Jüpyter'in LXD yörüngesine fırlatılması

Bu noktada hemen hemen her şey kullanıma hazır, ancak Python'un standart yeteneklerini önemli ölçüde genişletebilecek ek Python modülleri (tam teşekküllü uygulamalar) kurmazsak ilgi çekici olmayacaktır. JüpyterLabo yüzden devam edelim :)

PS İlginç olan şu ki, eski uygulama Jüpiter kod adı altında Jupyter Not Defteri kaybolmadı ve buna paralel olarak var JüpyterLab. Eski sürüme geçmek için adrese son eki ekleyen bağlantıyı takip edin/tree, yeni sürüme geçiş ise son ek ile gerçekleştirilmektedir. /lab, ancak belirtilmesi gerekmez:

Python'un yeteneklerini genişletmek ^

Bu bölümde aşağıdaki gibi güçlü Python dil modüllerini kuracağız: Dizi, Pandalar, matplotlib, IPyWidget'lar sonuçları dizüstü bilgisayarlara entegre ediliyor JüpyterLab.

Listelenen Python modüllerini paket yöneticisi aracılığıyla kurmadan önce pip Alpine Linux'ta öncelikle sistem bağımlılıklarını çözmeliyiz:

  • g++ — Bazıları dilde uygulandığından modülleri derlemek için gereklidir C + + ve çalışma zamanında Python'a ikili modüller olarak bağlanın
  • freetype-dev - Python modülüne bağımlılık matplotlib

Bağımlılıkları yükleme:

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

Bir sorun var: Alpine Linux dağıtımının mevcut durumunda NumPy'nin yeni sürümünü derlemek mümkün olmayacak; çözemediğim bir derleme hatası ortaya çıkacak:

HATA: Numpy için PEP 517 kullanan ve doğrudan yüklenemeyen tekerlekler oluşturulamadı

Bu nedenle, bu modülü önceden derlenmiş bir sürümü dağıtan, ancak sitede şu anda mevcut olandan biraz daha eski olan bir sistem paketi olarak kuracağız:

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

Daha sonra Python modüllerini paket yöneticisi aracılığıyla yükleyin pip. Bazı modüller derleneceğinden ve birkaç dakika sürebileceğinden lütfen sabırlı olun. Benim makinemde derleme ~15 dakika sürdü:

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

Kurulum önbelleklerini temizleme:

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

JupyterLab'da modülleri test etme ^

Eğer koşuyorsan JüpyterLab, yeni kurulan modüllerin etkinleştirilmesi için yeniden başlatın. Bunu yapmak için konsol oturumunda CTRL+C onu çalıştırdığınız yer ve girin y isteği durdurup yeniden başlatmak için JüpyterLab komutu tekrar girmemek için klavyedeki yukarı oka basarak ve ardından Enter başlatmak için:

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

sayfaya git http://10.0.5.5:8888/lab veya tarayıcınızda sayfayı yenileyin ve ardından yeni bir not defteri hücresine aşağıdaki kodu girin:

%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

Aşağıdaki resimdeki gibi bir sonuç almalısınız. IPyWidget'lar sayfada kaynak koduyla etkileşimli olarak etkileşime giren bir kullanıcı arayüzü öğesi oluşturur ve ayrıca matplotlib kodun sonucunu bir fonksiyon grafiği olarak resim biçiminde görüntüler:

Jüpyter'in LXD yörüngesine fırlatılması

Birçok örnek IPyWidget'lar bunu eğitimlerde bulabilirsin burada

Başka ne ^

Kalırsanız ve makalenin sonuna ulaşırsanız ne kadar iyi olur. Yazının sonunda kurulum yapacak hazır bir scripti bilinçli olarak yayınlamadım. JüpyterLab işçileri teşvik etmek için "tek tıklamayla" :) Ancak komutları tek bir Bash betiğinde toplayarak nasıl yapılacağını zaten bildiğiniz için bunu kendiniz yapabilirsiniz :)

Ayrıca şunları da yapabilirsiniz:

  • Basit bir şekilde yazarak kapsayıcı için IP adresi yerine bir ağ adı belirleyin. /etc/hosts ve adresi tarayıcıya yazın http://jupyter.local:8888
  • Konteynerin kaynak sınırıyla oynayın, bunun için bölümündeki bölümü okuyun. temel LXD yetenekleri veya LXD geliştirici sitesinden daha fazla bilgi edinin.
  • Temayı değiştirin:

Jüpyter'in LXD yörüngesine fırlatılması

Ve çok daha fazlasını yapabilirsiniz! Bu kadar. Sana başarılar diliyorum!

GÜNCELLEME: 15.04.2020 18:30 - “Merhaba Dünya!” bölümündeki hatalar düzeltildi.
GÜNCELLEME: 16.04.2020/10/00 XNUMX:XNUMX — Uzantı yöneticisi etkinleştirme açıklamasındaki metin düzeltildi ve eklendi JüpyterLab
GÜNCELLEME: 16.04.2020 10:40 — Metinde bulunan hatalar düzeltildi ve “Temel yazılımın kurulması ve sistemin kurulması” bölümü daha iyi olacak şekilde biraz değiştirildi

Kaynak: habr.com

Yorum ekle