Prohoster > Blog > quản lý > Phóng Jupyter lên quỹ đạo LXD

Phóng Jupyter lên quỹ đạo LXD

Bạn đã bao giờ phải thử nghiệm mã hoặc tiện ích hệ thống trong Linux để không phải lo lắng về hệ thống cơ sở và không phá bỏ mọi thứ trong trường hợp xảy ra lỗi trong mã phải chạy với quyền root chưa?

Nhưng thực tế là bạn cần kiểm tra hoặc chạy toàn bộ cụm vi dịch vụ khác nhau trên một máy thì sao? Một trăm hay thậm chí một nghìn?

Với các máy ảo được quản lý bởi một hypervisor, những vấn đề như vậy có thể và sẽ được giải quyết, nhưng với cái giá nào? Ví dụ: một vùng chứa trong LXD dựa trên bản phân phối Alpine Linux chỉ tiêu thụ 7.60MB RAM và nơi chiếm giữ phân vùng gốc sau khi khởi động 9.5MB! Bạn thích điều đó thế nào, Elon Musk? Tôi khuyên bạn nên kiểm tra các khả năng cơ bản của LXD - một hệ thống container trong Linux

Sau khi đã rõ tổng thể vùng chứa LXD là gì, chúng ta hãy đi xa hơn và suy nghĩ, điều gì sẽ xảy ra nếu có một nền tảng thu hoạch như vậy nơi bạn có thể chạy mã cho máy chủ một cách an toàn, tạo biểu đồ, liên kết linh hoạt (tương tác) các tiện ích UI với mã của bạn, bổ sung mã bằng văn bản có định dạng blackjack...? Một số loại blog tương tác? Ôi... tôi muốn nó! Muốn! 🙂

Nhìn bên dưới con mèo nơi chúng ta sẽ phóng vào thùng chứa phòng thí nghiệm jupyter - thế hệ giao diện người dùng tiếp theo thay vì Notebook Jupyter lỗi thời và chúng tôi cũng sẽ cài đặt các mô-đun Python như numpy, Gấu trúc, Matplotlib, IPyWidget điều này sẽ cho phép bạn thực hiện mọi thứ được liệt kê ở trên và lưu tất cả vào một tệp đặc biệt - máy tính xách tay IPython.

Phóng Jupyter lên quỹ đạo LXD

Kế hoạch cất cánh vào quỹ đạo ^

Phóng Jupyter lên quỹ đạo LXD

Hãy phác thảo một kế hoạch hành động ngắn gọn để giúp chúng ta thực hiện kế hoạch trên dễ dàng hơn:

  • Hãy cài đặt và khởi chạy một container dựa trên bộ phân phối Núi cao Linux. Chúng tôi sẽ sử dụng bản phân phối này vì nó hướng đến sự tối giản và sẽ chỉ cài đặt những phần mềm cần thiết nhất trong đó, không có gì thừa.
  • Hãy thêm một đĩa ảo bổ sung vào vùng chứa và đặt tên cho nó - hostfs và gắn nó vào hệ thống tập tin gốc. Đĩa này sẽ cho phép sử dụng các tệp trên máy chủ từ một thư mục nhất định bên trong vùng chứa. Do đó, dữ liệu của chúng tôi sẽ độc lập với vùng chứa. Nếu vùng chứa bị xóa, dữ liệu sẽ vẫn còn trên máy chủ. Ngoài ra, lược đồ này hữu ích để chia sẻ cùng một dữ liệu giữa nhiều vùng chứa mà không cần sử dụng các cơ chế mạng tiêu chuẩn của phân phối vùng chứa.
  • Hãy cài đặt Bash, sudo, các thư viện cần thiết, thêm và định cấu hình người dùng hệ thống
  • Hãy cài đặt Python, các mô-đun và biên dịch các phụ thuộc nhị phân cho chúng
  • Hãy cài đặt và khởi chạy phòng thí nghiệm jupyter, tùy chỉnh giao diện, cài đặt tiện ích mở rộng cho nó.

Trong bài viết này, chúng tôi sẽ bắt đầu với việc khởi chạy vùng chứa, chúng tôi sẽ không xem xét việc cài đặt và định cấu hình LXD, bạn có thể tìm thấy tất cả những điều này trong một bài viết khác - Tính năng cơ bản của LXD - Hệ thống container Linux.

Cài đặt và cấu hình hệ thống cơ bản ^

Chúng tôi tạo một vùng chứa bằng lệnh trong đó chúng tôi chỉ định hình ảnh - alpine3, mã định danh cho vùng chứa - jupyterlab và, nếu cần, hồ sơ cấu hình:

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

Ở đây tôi đang sử dụng hồ sơ cấu hình hddroot trong đó chỉ định tạo một thùng chứa có phân vùng gốc trong Bể chứa nằm trên đĩa cứng vật lý:

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

Điều này cho tôi cơ hội thử nghiệm các vùng chứa trên đĩa HDD, tiết kiệm tài nguyên của đĩa SSD, vốn cũng có sẵn trong hệ thống của tôi 🙂 mà tôi đã tạo một hồ sơ cấu hình riêng cho nó ssdroot.

Sau khi container được tạo, nó ở trạng thái STOPPED, vì vậy chúng ta cần khởi động nó bằng cách chạy hệ thống init trong đó:

lxc start jupyterlab

Hãy hiển thị danh sách các container trong LXD bằng phím -c cái nào chỉ ra cái nào chiển thị cột:

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

Khi tạo vùng chứa, địa chỉ IP được chọn ngẫu nhiên vì chúng tôi đã sử dụng hồ sơ cấu hình default đã được cấu hình trước đó trong bài viết Tính năng cơ bản của LXD - Hệ thống container Linux.

Chúng tôi sẽ thay đổi địa chỉ IP này thành một địa chỉ dễ nhớ hơn bằng cách tạo giao diện mạng ở cấp vùng chứa chứ không phải ở cấp hồ sơ cấu hình như hiện tại trong cấu hình hiện tại. Bạn không cần phải làm điều này, bạn có thể bỏ qua nó.

Tạo giao diện mạng eth0 mà chúng tôi liên kết với bộ chuyển mạch (cầu nối mạng) lxdbr0 trong đó chúng tôi đã bật NAT theo bài viết trước và vùng chứa giờ đây sẽ có quyền truy cập Internet và chúng tôi cũng chỉ định địa chỉ IP tĩnh cho giao diện - 10.0.5.5:

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

Sau khi thêm thiết bị, vùng chứa phải được khởi động lại:

lxc restart jupyterlab

Kiểm tra trạng thái của container:

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

Cài đặt phần mềm cơ bản và setup hệ thống ^

Để quản trị container của chúng tôi, bạn cần cài đặt phần mềm sau:

Đóng gói
Mô tả

bash
Vỏ GNU Bourne Again

bash-hoàn thành
Lập trình hoàn thành cho bash shell

sudo
Cung cấp cho một số người dùng khả năng chạy một số lệnh với quyền root

bóng tối
Bộ công cụ quản lý tài khoản và mật khẩu có hỗ trợ tệp bóng và PAM

dữ liệu
Nguồn dữ liệu về múi giờ và thời gian tiết kiệm ánh sáng ban ngày

nano
Bản sao trình chỉnh sửa Pico với các cải tiến

Ngoài ra, bạn có thể cài đặt hỗ trợ trong trang man của hệ thống bằng cách cài đặt các gói sau − man man-pages mdocml-apropos less

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

Hãy xem các lệnh và phím chúng tôi đã sử dụng:

  • lxc - Gọi cho khách hàng LXD
  • exec - Phương thức máy khách LXD chạy lệnh trong vùng chứa
  • jupyterlab - ID vùng chứa
  • -- — Một khóa đặc biệt quy định không hiểu các khóa khác là khóa cho lxc và chuyển phần còn lại của chuỗi vào vùng chứa
  • apk — Trình quản lý gói phân phối Alpine Linux
  • add — Phương thức quản lý gói cài đặt các gói được chỉ định sau lệnh

Tiếp theo chúng ta sẽ thiết lập múi giờ trong hệ thống Europe/Moscow:

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

Sau khi cài đặt múi giờ, gói tzdata không còn cần thiết trong hệ thống, nó sẽ chiếm dung lượng, vì vậy hãy xóa nó:

lxc exec jupyterlab -- apk del tzdata

Kiểm tra múi giờ:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

Để không mất nhiều thời gian thiết lập Bash cho người dùng mới trong vùng chứa, trong các bước sau, chúng tôi sẽ sao chép các tệp skel tạo sẵn từ hệ thống máy chủ vào đó. Điều này sẽ cho phép bạn làm đẹp Bash trong một thùng chứa một cách tương tác. Hệ thống máy chủ của tôi là Manjaro Linux và các tệp đang được sao chép /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors về nguyên tắc, chúng phù hợp với Alpine Linux và không gây ra vấn đề nghiêm trọng, nhưng bạn có thể có một bản phân phối khác và bạn cần phải tự mình tìm hiểu xem có lỗi khi chạy Bash trong vùng chứa hay không.

Sao chép các tập tin skel vào vùng chứa. Chìa khóa --create-dirs sẽ tạo các thư mục cần thiết nếu chúng không tồn tại:

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

Đối với người dùng root hiện có, hãy sao chép các tệp skel vừa sao chép vào vùng chứa vào thư mục chính:

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 cài đặt shell hệ thống cho người dùng /bin/sh, chúng ta sẽ thay thế nó bằng root người dùng trong Bash:

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

Đó root người dùng không có mật khẩu, anh ta cần đặt mật khẩu. Lệnh sau sẽ tạo và đặt mật khẩu ngẫu nhiên mới cho anh ta, bạn sẽ thấy mật khẩu này trên màn hình bảng điều khiển sau khi thực thi:

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

Ngoài ra, hãy tạo một người dùng hệ thống mới - jupyter mà chúng ta sẽ cấu hình sau phòng thí nghiệm jupyter:

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

Hãy tạo và đặt mật khẩu cho nó:

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

Tiếp theo, chúng ta sẽ thực thi hai lệnh, lệnh đầu tiên sẽ tạo một nhóm hệ thống sudovà cái thứ hai sẽ thêm người dùng vào nó jupyter:

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

Hãy xem người dùng thuộc nhóm nào jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

Mọi thứ đều ổn, chúng ta hãy tiếp tục.

Cho phép tất cả người dùng là thành viên của nhóm sudo sử dụng lệnh sudo. Để thực hiện việc này, hãy chạy tập lệnh sau, trong đó sed bỏ ghi chú dòng tham số trong file cấu hình /etc/sudoers:

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

Cài đặt và cấu hình JupyterLab ^

phòng thí nghiệm jupyter là một ứng dụng Python nên trước tiên chúng ta phải cài đặt trình thông dịch này. Cũng, phòng thí nghiệm jupyter chúng tôi sẽ cài đặt bằng trình quản lý gói Python pip, chứ không phải hệ thống, vì nó có thể đã lỗi thời trong kho lưu trữ hệ thống và do đó, chúng ta phải giải quyết thủ công các phần phụ thuộc cho nó bằng cách cài đặt các gói sau − python3 python3-dev gcc libc-dev zeromq-dev:

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

Hãy cập nhật các mô-đun python và trình quản lý gói pip đến phiên bản hiện tại:

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

Đặt phòng thí nghiệm jupyter thông qua trình quản lý gói pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

Vì các phần mở rộng trong phòng thí nghiệm jupyter là bản thử nghiệm và không được cung cấp chính thức cùng với gói jupyterlab, vì vậy chúng tôi phải cài đặt và định cấu hình thủ công.

Hãy cài đặt NodeJS và trình quản lý gói cho nó - NPM, vì phòng thí nghiệm jupyter sử dụng chúng cho các phần mở rộng của nó:

lxc exec jupyterlab -- apk add nodejs npm

Đến phần mở rộng cho phòng thí nghiệm jupyter mà chúng tôi sẽ cài đặt đã hoạt động, chúng cần được cài đặt trong thư mục người dùng vì ứng dụng sẽ được khởi chạy từ người dùng jupyter. Vấn đề là không có tham số nào trong lệnh khởi chạy có thể được chuyển đến một thư mục; ứng dụng chỉ chấp nhận một biến môi trường và do đó chúng ta phải xác định nó. Để làm điều này, chúng ta sẽ viết lệnh xuất biến JUPYTERLAB_DIR trong môi trường của người dùng jupyter, nộp .bashrcđược thực thi mỗi khi người dùng đăng nhập:

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

Lệnh tiếp theo sẽ cài đặt một tiện ích mở rộng đặc biệt - trình quản lý tiện ích mở rộng trong phòng thí nghiệm 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"

Bây giờ mọi thứ đã sẵn sàng cho lần ra mắt đầu tiên phòng thí nghiệm jupyter, nhưng chúng ta vẫn có thể cài đặt một số tiện ích mở rộng hữu ích:

  • toc — Mục lục, tạo danh sách các tiêu đề trong một bài viết/sổ ghi chép
  • jupyterlab-horizon-theme - chủ đề giao diện người dùng
  • jupyterlab_neon_theme - chủ đề giao diện người dùng
  • jupyterlab-ubu-theme - Một cái khác chủ đề từ tác giả bài viết này :) Nhưng trong trường hợp này, cài đặt từ kho GitHub sẽ được hiển thị

Vì vậy, hãy chạy tuần tự các lệnh sau để cài đặt các tiện ích mở rộng này:

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"

Sau khi cài đặt các tiện ích mở rộng, chúng tôi phải biên dịch chúng, vì trước đó, trong quá trình cài đặt, chúng tôi đã chỉ định khóa --no-build Để tiết kiệm thời gian. Bây giờ chúng ta sẽ tăng tốc đáng kể bằng cách biên dịch chúng lại với nhau trong một lần:

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

Bây giờ hãy chạy hai lệnh sau để chạy nó lần đầu tiên phòng thí nghiệm jupyter. Có thể khởi chạy nó bằng một lệnh, nhưng trong trường hợp này, lệnh khởi chạy, rất khó nhớ trong đầu bạn, sẽ được ghi nhớ bằng bash trong vùng chứa chứ không phải trên máy chủ, nơi đã có đủ lệnh để ghi lại chúng trong lịch sử :)

Đăng nhập vào vùng chứa với tư cách người dùng jupyter:

lxc exec jupyterlab -- su -l jupyter

Tiếp theo, chạy phòng thí nghiệm jupyter với các phím và thông số như được chỉ ra:

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

Đi đến địa chỉ trong trình duyệt web của bạn http://10.0.5.5:8888 và trên trang mở ra, hãy nhập mã thông báo truy cập mà bạn sẽ thấy trong bảng điều khiển. Sao chép và dán nó vào trang, sau đó nhấp vào Đăng nhập. Sau khi đăng nhập, hãy chuyển đến menu tiện ích mở rộng ở bên trái, như trong hình bên dưới, nơi bạn sẽ được nhắc khi kích hoạt trình quản lý tiện ích mở rộng, chấp nhận rủi ro bảo mật bằng cách cài đặt tiện ích mở rộng từ bên thứ ba mà lệnh Phát triển JupyterLab không chịu trách nhiệm:

Phóng Jupyter lên quỹ đạo LXD

Tuy nhiên, chúng tôi đang cô lập toàn bộ phòng thí nghiệm jupyter và đặt nó vào một vùng chứa để các tiện ích mở rộng của bên thứ ba yêu cầu và sử dụng NodeJS ít nhất không thể lấy cắp dữ liệu trên đĩa ngoài những dữ liệu mà chúng tôi mở bên trong vùng chứa. Truy cập các tài liệu riêng tư của bạn trên máy chủ trong /home các quy trình từ vùng chứa khó có thể thành công và nếu thành công thì bạn cần có đặc quyền đối với các tệp trên hệ thống máy chủ, vì chúng tôi chạy vùng chứa trong chế độ không có đặc quyền. Dựa trên thông tin này, bạn có thể đánh giá rủi ro khi đưa các tiện ích mở rộng vào phòng thí nghiệm jupyter.

Đã tạo sổ ghi chép IPython (các trang trong phòng thí nghiệm jupyter) bây giờ sẽ được tạo trong thư mục chính của người dùng - /home/jupyter, nhưng kế hoạch của chúng tôi là phân chia dữ liệu (chia sẻ) giữa máy chủ và vùng chứa, vì vậy hãy quay lại bảng điều khiển và dừng phòng thí nghiệm jupyter bằng cách thực hiện phím nóng - CTRL+C và trả lời y theo yêu cầu. Sau đó chấm dứt phiên tương tác của người dùng jupyter hoàn thành một phím nóng CTRL+D.

Chia sẻ dữ liệu với máy chủ ^

Để chia sẻ dữ liệu với máy chủ, bạn cần tạo một thiết bị trong vùng chứa cho phép bạn thực hiện việc này và để thực hiện việc này, hãy chạy lệnh sau trong đó chúng tôi chỉ định các khóa sau:

  • lxc config device add — Lệnh thêm cấu hình thiết bị
  • jupyter - ID của vùng chứa mà cấu hình được thêm vào
  • hostfs - ID thiết bị. Bạn có thể đặt bất kỳ tên nào.
  • disk - Loại thiết bị được chỉ định
  • path - Chỉ định đường dẫn trong vùng chứa mà LXD sẽ gắn thiết bị này vào
  • source — Chỉ định nguồn, đường dẫn đến thư mục trên máy chủ mà bạn muốn chia sẻ với vùng chứa. Chỉ định đường dẫn theo sở thích của bạn
lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

Đối với danh mục /home/dv/projects/ipython-notebooks quyền phải được đặt cho người dùng vùng chứa hiện có UID bằng SubUID + UID, xem chương Sự an toàn. Đặc quyền vùng chứa trong bài báo Tính năng cơ bản của LXD - Hệ thống container Linux.

Đặt quyền trên máy chủ, trong đó chủ sở hữu sẽ là người dùng vùng chứa jupyter, và biến $USER sẽ chỉ định người dùng máy chủ của bạn thành một nhóm:

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

Chào thế giới! ^

Nếu bạn vẫn mở phiên bảng điều khiển trong vùng chứa với phòng thí nghiệm jupyter, sau đó khởi động lại bằng khóa mới --notebook-dir bằng cách thiết lập giá trị /mnt/hostfs làm đường dẫn đến thư mục gốc của máy tính xách tay trong vùng chứa thiết bị mà chúng tôi đã tạo ở bước trước:

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

Sau đó vào trang http://10.0.5.5:8888 và tạo máy tính xách tay đầu tiên của bạn bằng cách nhấp vào nút trên trang như trong hình bên dưới:

Phóng Jupyter lên quỹ đạo LXD

Sau đó, trong trường trên trang, nhập mã Python sẽ hiển thị kiểu cổ điển Hello World!. Khi nhập xong nhấn CTRL+ENTER hoặc nút "phát" trên thanh công cụ ở trên cùng để JupyterLab thực hiện việc này:

Phóng Jupyter lên quỹ đạo LXD

Tại thời điểm này, hầu hết mọi thứ đã sẵn sàng để sử dụng, nhưng sẽ thật nhàm chán nếu chúng ta không cài đặt thêm các mô-đun Python (ứng dụng chính thức) có thể mở rộng đáng kể các khả năng tiêu chuẩn của Python trong phòng thí nghiệm jupyter, do đó, hãy tiếp tục :)

PS Điều thú vị là cách triển khai cũ jupyter dưới tên mã Máy tính xách tay Jupyter vẫn chưa biến mất và nó tồn tại song song với phòng thí nghiệm jupyter. Để chuyển về phiên bản cũ bạn theo link thêm hậu tố vào địa chỉ/tree, và việc chuyển sang phiên bản mới được thực hiện với hậu tố /lab, nhưng nó không cần phải được chỉ định:

Mở rộng khả năng của Python ^

Trong phần này, chúng tôi sẽ cài đặt các mô-đun ngôn ngữ Python mạnh mẽ như numpy, Gấu trúc, Matplotlib, IPyWidget kết quả được tích hợp vào máy tính xách tay phòng thí nghiệm jupyter.

Trước khi cài đặt các mô-đun Python được liệt kê thông qua trình quản lý gói pip trước tiên chúng ta phải giải quyết các phần phụ thuộc của hệ thống trong Alpine Linux:

  • g++ — Cần thiết để biên dịch các mô-đun, vì một số mô-đun được triển khai bằng ngôn ngữ C + + và kết nối với Python khi chạy dưới dạng mô-đun nhị phân
  • freetype-dev - phụ thuộc vào mô-đun Python Matplotlib

Cài đặt phụ thuộc:

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

Có một vấn đề: trong tình trạng hiện tại của bản phân phối Alpine Linux, sẽ không thể biên dịch phiên bản NumPy mới; một lỗi biên dịch sẽ xuất hiện mà tôi không thể giải quyết:

ERROR: Không thể tạo bánh xe cho numpy sử dụng PEP 517 và không thể cài đặt trực tiếp

Do đó, chúng tôi sẽ cài đặt mô-đun này dưới dạng gói hệ thống phân phối phiên bản đã được biên dịch, nhưng cũ hơn một chút so với phiên bản hiện có trên trang web:

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

Tiếp theo, cài đặt các mô-đun Python thông qua trình quản lý gói pip. Hãy kiên nhẫn vì một số mô-đun sẽ biên dịch và có thể mất vài phút. Trên máy của tôi, quá trình biên dịch mất ~ 15 phút:

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

Xóa bộ nhớ đệm cài đặt:

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

Kiểm tra các mô-đun trong JupyterLab ^

Nếu bạn đang chạy phòng thí nghiệm jupyter, hãy khởi động lại nó để các mô-đun mới cài đặt được kích hoạt. Để thực hiện việc này, trong phiên bảng điều khiển, hãy nhấp vào CTRL+C nơi bạn chạy nó và nhập y để dừng yêu cầu và sau đó bắt đầu lại phòng thí nghiệm jupyter bằng cách nhấn mũi tên lên trên bàn phím để không nhập lại lệnh và sau đó Enter để bắt đầu nó:

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

Đi đến trang http://10.0.5.5:8888/lab hoặc làm mới trang trong trình duyệt của bạn, rồi nhập mã sau vào ô sổ tay mới:

%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

Bạn sẽ nhận được kết quả như trong hình bên dưới, trong đó IPyWidget tạo thành phần giao diện người dùng trên trang tương tác tương tác với mã nguồn, đồng thời Matplotlib hiển thị kết quả của mã dưới dạng hình ảnh dưới dạng biểu đồ hàm:

Phóng Jupyter lên quỹ đạo LXD

Nhiều ví dụ IPyWidget bạn có thể tìm thấy nó trong phần hướng dẫn đây

Còn gì nữa? ^

Làm tốt lắm nếu bạn ở lại và đi đến cuối bài viết. Mình cố tình không đăng đoạn script làm sẵn ở cuối bài sẽ cài đặt phòng thí nghiệm jupyter trong “một cú nhấp chuột” để khuyến khích người lao động :) Nhưng bạn có thể tự mình làm điều đó, vì bạn đã biết cách thực hiện, sau khi đã thu thập các lệnh thành một tập lệnh Bash duy nhất :)

Bạn cũng có thể:

  • Đặt tên mạng cho vùng chứa thay vì địa chỉ IP bằng cách viết nó một cách đơn giản /etc/hosts và gõ địa chỉ vào trình duyệt http://jupyter.local:8888
  • Hãy thử xem xét giới hạn tài nguyên cho vùng chứa, để biết điều này hãy đọc chương trong khả năng LXD cơ bản hoặc nhận thêm thông tin trên trang web của nhà phát triển LXD.
  • Thay đổi chủ đề:

Phóng Jupyter lên quỹ đạo LXD

Và nhiều hơn nữa bạn có thể làm! Đó là tất cả. Chúc các bạn thành công!

CẬP NHẬT: 15.04.2020/18/30 XNUMX:XNUMX - Đã sửa lỗi trong chương “Hello, World!”
CẬP NHẬT: 16.04.2020/10/00 XNUMX:XNUMX - Đã sửa và thêm văn bản trong phần mô tả kích hoạt trình quản lý tiện ích mở rộng phòng thí nghiệm jupyter
CẬP NHẬT: 16.04.2020/10/40 XNUMX:XNUMX — Đã sửa các lỗi trong văn bản và thay đổi một chút để chương “Cài đặt phần mềm cơ bản và thiết lập hệ thống” hoàn thiện hơn

Nguồn: www.habr.com

Thêm một lời nhận xét