იუპიტერის გაშვება LXD ორბიტაზე

ოდესმე გქონიათ ლინუქსის კოდის ან სისტემის კომუნალური პროგრამების ექსპერიმენტების გატარება ძირითადი სისტემის შესახებ ფიქრის გარეშე და ყველაფრის დანგრევის გარეშე კოდის შეცდომის შემთხვევაში, რომელიც უნდა იმუშაოს root პრივილეგიებით?

მაგრამ რა შეიძლება ითქვას იმ ფაქტზე, რომ ვთქვათ, თქვენ გჭირდებათ სხვადასხვა მიკროსერვისების მთელი კლასტერის ტესტირება ან გაშვება ერთ მანქანაზე? ასი ან თუნდაც ათასი?

ჰიპერვიზორის მიერ მართული ვირტუალური მანქანებით, ასეთი პრობლემები შეიძლება და მოგვარდება, მაგრამ რა ფასად? მაგალითად, კონტეინერი LXD-ში, რომელიც დაფუძნებულია Alpine Linux დისტრიბუციაზე, მოიხმარს მხოლოდ 7.60MB ოპერატიული მეხსიერება და სადაც root დანაყოფი იკავებს გაშვების შემდეგ 9.5MB! როგორ მოგწონს ეს, ელონ მასკ? გირჩევთ შეამოწმოთ LXD-ის ძირითადი შესაძლებლობები - კონტეინერის სისტემა Linux-ში

მას შემდეგ, რაც გაირკვა ზოგადად რა არის LXD კონტეინერები, მოდით წავიდეთ უფრო შორს და ვიფიქროთ, თუ არსებობდა ასეთი მოსავლის პლატფორმა, სადაც შეგიძლიათ უსაფრთხოდ გაუშვათ კოდი ჰოსტისთვის, გენერირებათ გრაფიკები, დინამიურად (ინტერაქტიულად) დააკავშიროთ UI- ვიჯეტები თქვენს კოდთან. კოდის დამატება ტექსტით ბლექჯეკით... ფორმატირება? რაიმე სახის ინტერაქტიული ბლოგი? ვაა... მინდა! გინდა! 🙂

შეხედეთ კატის ქვეშ, სადაც კონტეინერში ჩავფრინდებით იუპიტერის ლაბორატორია - შემდეგი თაობის მომხმარებლის ინტერფეისი მოძველებული Jupyter Notebook-ის ნაცვლად და ჩვენ ასევე დავაინსტალირებთ Python მოდულებს, როგორიცაა ნუმპი, პანდა, matplotlib, IPyWidgets რაც საშუალებას მოგცემთ გააკეთოთ ყველაფერი ზემოთ ჩამოთვლილი და შეინახოთ ეს ყველაფერი სპეციალურ ფაილში - IPython ლეპტოპში.

ნავიგაცია

• ორბიტალური აფრენის გეგმა
• ძირითადი სისტემის ინსტალაცია და კონფიგურაცია
• ძირითადი პროგრამული უზრუნველყოფის ინსტალაცია და სისტემის დაყენება
• JupyterLab-ის ინსტალაცია და კონფიგურაცია
• მონაცემთა გაზიარება მასპინძელთან
• Გამარჯობა მსოფლიო!
• პითონის შესაძლებლობების გაფართოება
• მოდულების ტესტირება JupyterLab-ში
• Სხვა რა?

ორბიტალური აფრენის გეგმა ^

მოდით გამოვყოთ მოკლე სამოქმედო გეგმა, რათა გაგვიადვილდეს ზემოთ მოცემული სქემის განხორციელება:

• მოდით დავაყენოთ და გავუშვათ კონტეინერი სადისტრიბუციო ნაკრების საფუძველზე ალპური ენა. ჩვენ გამოვიყენებთ ამ დისტრიბუციას, რადგან ის მიზნად ისახავს მინიმალიზმს და მასში დავაინსტალირებთ მხოლოდ ყველაზე საჭირო პროგრამულ უზრუნველყოფას, არაფერი ზედმეტი.
• მოდით დავამატოთ დამატებითი ვირტუალური დისკი კონტეინერში და მივცეთ სახელი - hostfs და დააინსტალირეთ ის root ფაილურ სისტემაში. ეს დისკი შესაძლებელს გახდის ფაილების გამოყენებას ჰოსტზე მოცემული დირექტორიადან კონტეინერის შიგნით. ამრიგად, ჩვენი მონაცემები დამოუკიდებელი იქნება კონტეინერისგან. თუ კონტეინერი წაიშლება, მონაცემები დარჩება ჰოსტზე. ასევე, ეს სქემა სასარგებლოა იგივე მონაცემების გაზიარებისთვის ბევრ კონტეინერს შორის კონტეინერის განაწილების სტანდარტული ქსელური მექანიზმების გამოყენების გარეშე.
• დავაინსტალიროთ Bash, sudo, საჭირო ბიბლიოთეკები, დავამატოთ და დავაკონფიგურიროთ სისტემის მომხმარებელი
• მოდით დავაყენოთ პითონი, მოდულები და შევადგინოთ ორობითი დამოკიდებულებები მათთვის
• მოდით დავაყენოთ და გავუშვათ იუპიტერის ლაბორატორია, შეცვალეთ გარეგნობა, დააინსტალირეთ გაფართოებები.

ამ სტატიაში ჩვენ დავიწყებთ კონტეინერის გაშვებას, არ განვიხილავთ LXD-ის ინსტალაციას და კონფიგურაციას, თქვენ შეგიძლიათ იპოვოთ ეს ყველაფერი სხვა სტატიაში - LXD - Linux კონტეინერის სისტემების ძირითადი მახასიათებლები.

ძირითადი სისტემის ინსტალაცია და კონფიგურაცია ^

ჩვენ ვქმნით კონტეინერს ბრძანებით, რომელშიც ვაზუსტებთ სურათს - alpine3, კონტეინერის იდენტიფიკატორი - jupyterlab და, საჭიროების შემთხვევაში, კონფიგურაციის პროფილები:

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

აქ მე ვიყენებ კონფიგურაციის პროფილს hddroot რომელიც განსაზღვრავს კონტეინერის შექმნას root დანაყოფით საცავის აუზი მდებარეობს ფიზიკურ 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

ეს მაძლევს შესაძლებლობას ექსპერიმენტი ჩავატარო კონტეინერებზე HDD დისკზე, დაზოგო SSD დისკის რესურსები, რომელიც ასევე ხელმისაწვდომია ჩემს სისტემაში 🙂 რისთვისაც მე შევქმენი ცალკე კონფიგურაციის პროფილი ssdroot.

კონტეინერის შექმნის შემდეგ ის მდგომარეობაშია STOPPEDასე რომ, ჩვენ უნდა დავიწყოთ მასში init სისტემის გაშვებით:

lxc start jupyterlab

მოდით გამოვაჩინოთ კონტეინერების სია LXD-ში გასაღების გამოყენებით -c რომელიც მიუთითებს რომელი cსვეტების ჩვენება:

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

კონტეინერის შექმნისას, IP მისამართი შემთხვევით შეირჩა, რადგან ჩვენ გამოვიყენეთ კონფიგურაციის პროფილი default რომელიც ადრე იყო კონფიგურირებული სტატიაში LXD - Linux კონტეინერის სისტემების ძირითადი მახასიათებლები.

ჩვენ შევცვლით ამ IP მისამართს უფრო დასამახსოვრებელს ქსელის ინტერფეისის შექმნით კონტეინერის დონეზე და არა კონფიგურაციის პროფილის დონეზე, როგორც ეს ახლა არის მიმდინარე კონფიგურაციაში. თქვენ არ გჭირდებათ ამის გაკეთება, შეგიძლიათ გამოტოვოთ იგი.

ქსელის ინტერფეისის შექმნა eth0 რომელსაც ჩვენ ვუკავშირებთ გადამრთველს (ქსელის ხიდი) lxdbr0 რომელშიც ჩვენ გავააქტიურეთ NAT წინა სტატიის მიხედვით და კონტეინერს ახლა ექნება წვდომა ინტერნეტზე, ასევე ინტერფეისს ვანიჭებთ სტატიკური IP მისამართს - 10.0.5.5:

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

მოწყობილობის დამატების შემდეგ, კონტეინერი უნდა გადატვირთოთ:

lxc restart jupyterlab

კონტეინერის სტატუსის შემოწმება:

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

ძირითადი პროგრამული უზრუნველყოფის ინსტალაცია და სისტემის დაყენება ^

ჩვენი კონტეინერის ადმინისტრირებისთვის, თქვენ უნდა დააინსტალიროთ შემდეგი პროგრამული უზრუნველყოფა:

პაკეტი
აღწერა

Bash
GNU Bourne Again ჭურვი

ბაშ-დასრულება
პროგრამირებადი დასრულება bash shell-ისთვის

sudo
მიეცით გარკვეულ მომხმარებლებს შესაძლებლობა გაუშვან ზოგიერთი ბრძანება root-ის სახით

shadow
პაროლისა და ანგარიშის მართვის ხელსაწყოების კომპლექტი ჩრდილოვანი ფაილებისა და PAM-ის მხარდაჭერით

ცძატა
დროის სარტყლისა და დღის შუქის დროის მონაცემების წყაროები

nano
Pico რედაქტორის კლონი გაუმჯობესებებით

გარდა ამისა, შეგიძლიათ დააინსტალიროთ მხარდაჭერა სისტემის man-pages შემდეგი პაკეტების დაყენებით - man man-pages mdocml-apropos less

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

მოდით შევხედოთ ჩვენ მიერ გამოყენებულ ბრძანებებს და გასაღებებს:

• lxc — დარეკეთ LXD კლიენტთან
• exec - LXD კლიენტის მეთოდი, რომელიც აწარმოებს ბრძანებას კონტეინერში
• jupyterlab - კონტეინერის ID
• -- - სპეციალური გასაღები, რომელიც განსაზღვრავს, რომ არ მოხდეს შემდგომი გასაღებების ინტერპრეტაცია გასაღებად lxc და გადაიტანეთ დანარჩენი სტრიქონი ისე, როგორც არის კონტეინერში
• apk — Alpine Linux სადისტრიბუციო პაკეტის მენეჯერი
• add - პაკეტის მენეჯერის მეთოდი, რომელიც აყენებს ბრძანების შემდეგ მითითებულ პაკეტებს

შემდეგი, ჩვენ დავაყენებთ დროის სარტყელს სისტემაში Europe/Moscow:

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

დროის ზონის დაყენების შემდეგ, პაკეტი tzdata სისტემაში აღარ არის საჭირო, ის ადგილს დაიკავებს, ამიტომ წავშალოთ:

lxc exec jupyterlab -- apk del tzdata

დროის ზონის შემოწმება:

lxc exec jupyterlab -- date

Wed Apr 15 10:49:56 MSK 2020

იმისთვის, რომ კონტეინერში ახალი მომხმარებლებისთვის Bash-ის დაყენებაზე დიდი დრო არ დახარჯოთ, შემდეგ ნაბიჯებში ჩვენ მასში მასპინძელი სისტემიდან დავაკოპირებთ მზა სკელის ფაილებს. ეს საშუალებას მოგცემთ გაალამაზოთ Bash კონტეინერში ინტერაქტიულად. ჩემი მასპინძელი სისტემა არის Manjaro Linux და ფაილები კოპირებულია /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors პრინციპში, ისინი შესაფერისია Alpine Linux-ისთვის და არ იწვევს კრიტიკულ პრობლემებს, მაგრამ შეიძლება გქონდეთ განსხვავებული განაწილება და დამოუკიდებლად უნდა გაარკვიოთ, არის თუ არა შეცდომა Bash-ის კონტეინერში გაშვებისას.

დააკოპირეთ ჩონჩხის ფაილები კონტეინერში. Გასაღები --create-dirs შექმნიან საჭირო დირექტორიებს, თუ ისინი არ არსებობს:

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

უკვე არსებული root მომხმარებლისთვის დააკოპირეთ სკელის ფაილები, რომლებიც ახლახან დაკოპირებულია კონტეინერში სახლის დირექტორიაში:

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 აყენებს სისტემის გარსს მომხმარებლებისთვის /bin/sh, ჩვენ შევცვლით root მომხმარებელი Bash-ში:

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

რომ root მომხმარებელი არ იყო პაროლის გარეშე, მას სჭირდება პაროლის დაყენება. შემდეგი ბრძანება გამოიმუშავებს და დააყენებს მისთვის ახალ შემთხვევით პაროლს, რომელსაც მისი შესრულების შემდეგ ნახავთ კონსოლის ეკრანზე:

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

ასევე, შევქმნათ სისტემის ახალი მომხმარებელი - jupyter რომლის კონფიგურაციასაც მოგვიანებით გავაკეთებთ იუპიტერის ლაბორატორია:

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

მოდით შევქმნათ და დავაყენოთ პაროლი:

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

შემდეგი, ჩვენ შევასრულებთ ორ ბრძანებას, პირველი შექმნის სისტემის ჯგუფს sudoდა მეორე დაამატებს მას მომხმარებელს jupyter:

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

ვნახოთ, რომელ ჯგუფს მიეკუთვნება მომხმარებელი jupyter:

lxc exec jupyterlab -- id -Gn jupyter

jupyter sudo

ყველაფერი კარგადაა, მოდი გავაგრძელოთ.

ჯგუფის წევრი ყველა მომხმარებლის დაშვება sudo გამოიყენეთ ბრძანება sudo. ამისათვის გაუშვით შემდეგი სკრიპტი, სადაც sed უკომენტარებს პარამეტრის ხაზს კონფიგურაციის ფაილში /etc/sudoers:

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

JupyterLab-ის ინსტალაცია და კონფიგურაცია ^

იუპიტერის ლაბორატორია არის პითონის აპლიკაცია, ამიტომ ჯერ უნდა დავაყენოთ ეს თარჯიმანი. ასევე, იუპიტერის ლაბორატორია ჩვენ დავაინსტალირებთ Python პაკეტის მენეჯერის გამოყენებით pip, და არა სისტემური, რადგან ის შეიძლება მოძველებული იყოს სისტემის საცავში და ამიტომ, ჩვენ ხელით უნდა მოვაგვაროთ მისთვის დამოკიდებულებები შემდეგი პაკეტების დაყენებით − python3 python3-dev gcc libc-dev zeromq-dev:

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

მოდით განაახლოთ პითონის მოდულები და პაკეტის მენეჯერი pip მიმდინარე ვერსიამდე:

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

უცნობია იუპიტერის ლაბორატორია პაკეტის მენეჯერის საშუალებით pip:

lxc exec jupyterlab -- python3 -m pip install jupyterlab

მას შემდეგ, რაც გაფართოებები შევიდა იუპიტერის ლაბორატორია არის ექსპერიმენტული და ოფიციალურად არ იგზავნება jupyterlab პაკეტით, ამიტომ ჩვენ უნდა დავაინსტალიროთ და დააკონფიგურიროთ ხელით.

მოდით დავაყენოთ NodeJS და ამისთვის პაკეტის მენეჯერი - NPM, მას შემდეგ იუპიტერის ლაბორატორია იყენებს მათ გაფართოებებისთვის:

lxc exec jupyterlab -- apk add nodejs npm

გაფართოებებისთვის ამისთვის იუპიტერის ლაბორატორია რომელსაც ჩვენ დავაინსტალირებთ მუშაობდა, ისინი უნდა იყოს დაინსტალირებული მომხმარებლის დირექტორიაში, ვინაიდან აპლიკაცია ამოქმედდება მომხმარებლისგან jupyter. პრობლემა ის არის, რომ გაშვების ბრძანებაში არ არის პარამეტრი, რომელიც შეიძლება გადავიდეს დირექტორიაში; აპლიკაცია იღებს მხოლოდ გარემოს ცვლადს და ამიტომ ჩვენ უნდა განვსაზღვროთ იგი. ამისათვის ჩვენ დავწერთ ცვლადის ექსპორტის ბრძანებას JUPYTERLAB_DIR მომხმარებლის გარემოში jupyter, შეიტანოს .bashrcრომელიც სრულდება ყოველ ჯერზე მომხმარებლის შესვლისას:

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

შემდეგი ბრძანება დააყენებს სპეციალურ გაფართოებას - გაფართოების მენეჯერს იუპიტერის ლაბორატორია:

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

ახლა ყველაფერი მზად არის პირველი გაშვებისთვის იუპიტერის ლაბორატორია, მაგრამ ჩვენ მაინც შეგვიძლია დავაყენოთ რამდენიმე სასარგებლო გაფართოება:

• toc — სარჩევი, ქმნის სტატიის/რვეულის სათაურების ჩამონათვალს
• jupyterlab-horizon-theme - UI თემა
• jupyterlab_neon_theme - UI თემა
• jupyterlab-ubu-theme - Სხვა თემა ავტორისგან ეს სტატია :) მაგრამ ამ შემთხვევაში ნაჩვენები იქნება ინსტალაცია GitHub საცავიდან

ასე რომ, გაუშვით შემდეგი ბრძანებები თანმიმდევრულად ამ გაფართოებების დასაყენებლად:

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"

გაფართოებების დაყენების შემდეგ, ჩვენ უნდა შევადგინოთ ისინი, რადგან ადრე, ინსტალაციის დროს, ჩვენ დავაზუსტეთ გასაღები --no-build დროის დაზოგვის მიზნით. ახლა ჩვენ მნიშვნელოვნად დავაჩქარებთ მათ ერთად შედგენით:

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

ახლა გაუშვით შემდეგი ორი ბრძანება პირველად გასაშვებად იუპიტერის ლაბორატორია. მისი გაშვება შესაძლებელი იქნებოდა ერთი ბრძანებით, მაგრამ ამ შემთხვევაში გაშვების ბრძანება, რომელიც ძნელი დასამახსოვრებელია თქვენს გონებაში, დაიმახსოვრება ბაში კონტეინერში და არა ჰოსტზე, სადაც უკვე არის საკმარისი ბრძანებები. ისტორიაში რომ ჩავწერო :)

შედით კონტეინერში, როგორც მომხმარებელი jupyter:

lxc exec jupyterlab -- su -l jupyter

შემდეგი, გაიქეცი იუპიტერის ლაბორატორია კლავიშებით და პარამეტრებით, როგორც მითითებულია:

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

გადადით თქვენს ბრაუზერში მისამართზე http://10.0.5.5:8888 და იმ გვერდზე, რომელიც იხსნება, შეიყვანეთ ნიშნად წვდომა, რომელსაც ნახავთ კონსოლში. დააკოპირეთ და ჩასვით გვერდზე, შემდეგ დააწკაპუნეთ შესვლა. შესვლის შემდეგ, გადადით გაფართოებების მენიუში მარცხნივ, როგორც ნაჩვენებია ქვემოთ მოცემულ სურათზე, სადაც მოგეთხოვებათ გაფართოების მენეჯერის გააქტიურებისას უსაფრთხოების რისკების აღება მესამე მხარის გაფართოებების ინსტალაციით, რისთვისაც ბრძანება JupyterLab-ის განვითარება არ არის პასუხისმგებელი:

თუმცა, ჩვენ მთლიანად იზოლაციაში ვართ იუპიტერის ლაბორატორია და მოათავსეთ იგი კონტეინერში ისე, რომ მესამე მხარის გაფართოებებმა, რომლებიც საჭიროებენ და გამოიყენებენ NodeJS-ს, არ შეუძლიათ მაინც მოიპარონ მონაცემები დისკზე, გარდა იმისა, რასაც ჩვენ ვხსნით კონტეინერის შიგნით. მიიღეთ თქვენი პირადი დოკუმენტები მასპინძელზე /home კონტეინერიდან პროცესები ნაკლებად სავარაუდოა, რომ წარმატებული იყოს და თუ წარმატებას მიაღწევს, მაშინ თქვენ უნდა გქონდეთ პრივილეგიები მასპინძელ სისტემაში არსებულ ფაილებზე, რადგან ჩვენ კონტეინერს ვატარებთ არაპრივილეგირებული რეჟიმი. ამ ინფორმაციის საფუძველზე, შეგიძლიათ შეაფასოთ გაფართოებების ჩართვის რისკი იუპიტერის ლაბორატორია.

შექმენით IPython ნოუთბუქები (გვერდები იუპიტერის ლაბორატორია) ახლა შეიქმნება მომხმარებლის მთავარ დირექტორიაში - /home/jupyter, მაგრამ ჩვენი გეგმებია მონაცემების (გაზიარების) გაყოფა ჰოსტსა და კონტეინერს შორის, ამიტომ დაბრუნდით კონსოლში და გააჩერეთ იუპიტერის ლაბორატორია ცხელი კლავიშის შესრულებით - CTRL+C და პასუხობს y თხოვნის საფუძველზე. შემდეგ შეწყვიტე მომხმარებლის ინტერაქტიული სესია jupyter ცხელი კლავიშის დასრულება CTRL+D.

მონაცემთა გაზიარება მასპინძელთან ^

ჰოსტთან მონაცემების გასაზიარებლად, თქვენ უნდა შექმნათ მოწყობილობა კონტეინერში, რომელიც ამის საშუალებას მოგცემთ და ამისათვის აწარმოეთ შემდეგი ბრძანება, სადაც განვსაზღვრავთ შემდეგ კლავიშებს:

• lxc config device add — ბრძანება ამატებს მოწყობილობის კონფიგურაციას
• jupyter — კონტეინერის ID, რომელსაც ემატება კონფიგურაცია
• hostfs - მოწყობილობის ID. თქვენ შეგიძლიათ დააყენოთ ნებისმიერი სახელი.
• disk — მითითებულია მოწყობილობის ტიპი
• path — განსაზღვრავს ბილიკს კონტეინერში, რომელზეც LXD დაამონტაჟებს ამ მოწყობილობას
• source — მიუთითეთ წყარო, გზა ჰოსტის დირექტორიაში, რომლის გაზიარებაც გსურთ კონტეინერთან. მიუთითეთ გზა თქვენი პრეფერენციების მიხედვით

lxc config device add jupyterlab hostfs disk path=/mnt/hostfs source=/home/dv/projects/ipython-notebooks

კატალოგისთვის /home/dv/projects/ipython-notebooks ნებართვა უნდა იყოს მითითებული კონტეინერის მომხმარებელზე, რომელსაც ამჟამად აქვს UID ტოლი SubUID + UID, იხილეთ თავი Უსაფრთხოება. კონტეინერის პრივილეგიები სტატიაში LXD - Linux კონტეინერის სისტემების ძირითადი მახასიათებლები.

დააყენეთ ნებართვა ჰოსტზე, სადაც მფლობელი იქნება კონტეინერის მომხმარებელი jupyterდა ცვლადი $USER დააკონკრეტებს თქვენს მასპინძელ მომხმარებელს ჯგუფად:

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

Გამარჯობა მსოფლიო! ^

თუ თქვენ ჯერ კიდევ გაქვთ კონსოლის სესია გახსნილი კონტეინერში იუპიტერის ლაბორატორია, შემდეგ გადატვირთეთ ახალი გასაღებით --notebook-dir ღირებულების დაყენებით /mnt/hostfs როგორც გზა ლეპტოპების ძირამდე კონტეინერში მოწყობილობისთვის, რომელიც ჩვენ შევქმენით წინა ეტაპზე:

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

შემდეგ გადადით გვერდზე http://10.0.5.5:8888 და შექმენით თქვენი პირველი ლეპტოპი გვერდზე ღილაკზე დაჭერით, როგორც ნაჩვენებია ქვემოთ მოცემულ სურათზე:

შემდეგ, გვერდის ველში შეიყვანეთ პითონის კოდი, რომელიც აჩვენებს კლასიკას Hello World!. შესვლის დასრულების შემდეგ დააჭირეთ CTRL+ENTER ან ღილაკი "თამაში" ინსტრუმენტთა პანელზე ზედა, რათა JupyterLab-მა გააკეთოს ეს:

ამ ეტაპზე, თითქმის ყველაფერი მზად არის გამოსაყენებლად, მაგრამ უინტერესო იქნება, თუ არ დავაინსტალირებთ Python-ის დამატებით მოდულებს (სრულფასოვან აპლიკაციებს), რომლებსაც შეუძლიათ მნიშვნელოვნად გააფართოვონ Python-ის სტანდარტული შესაძლებლობები. იუპიტერის ლაბორატორიაამიტომ გავაგრძელოთ :)

PS საინტერესო ის არის, რომ ძველი განხორციელება იუპიტერი კოდის სახელით იუპიტერის რვეული არ გაქრა და პარალელურად არსებობს იუპიტერის ლაბორატორია. ძველ ვერსიაზე გადასასვლელად მიჰყევით ბმულს, რომელშიც დაამატეთ სუფიქსი მისამართში/tree, ხოლო ახალ ვერსიაზე გადასვლა ხდება სუფიქსით /lab, მაგრამ ეს არ უნდა იყოს მითითებული:

• იუპიტერის ნოუთბუქი - http://10.0.5.5:8888/tree
• იუპიტერის ლაბორატორია - http://10.0.5.5:8888/lab

პითონის შესაძლებლობების გაფართოება ^

ამ განყოფილებაში ჩვენ დავაინსტალირებთ Python ენის ისეთ მძლავრ მოდულებს, როგორიცაა ნუმპი, პანდა, matplotlib, IPyWidgets რომლის შედეგები ინტეგრირებულია ლეპტოპებში იუპიტერის ლაბორატორია.

ჩამოთვლილი Python მოდულების დაყენებამდე პაკეტის მენეჯერის მეშვეობით pip ჩვენ ჯერ უნდა გადავწყვიტოთ სისტემის დამოკიდებულებები Alpine Linux-ში:

• g++ — საჭიროა მოდულების შედგენისთვის, რადგან ზოგიერთი მათგანი ენაზეა დანერგილი C + + და დაუკავშირდით Python-ს გაშვების დროს, როგორც ორობითი მოდულები
• freetype-dev - დამოკიდებულება პითონის მოდულზე matplotlib

დამოკიდებულებების დაყენება:

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

არის ერთი პრობლემა: Alpine Linux დისტრიბუციის ამჟამინდელ მდგომარეობაში, NumPy-ის ახალი ვერსიის შედგენა შეუძლებელი იქნება; გამოჩნდება შედგენის შეცდომა, რომლის მოგვარებაც ვერ მოვახერხე:

ERROR: ვერ ავაშენე ბორბლები numpy-სთვის, რომლებიც იყენებენ PEP 517 და არ შეიძლება პირდაპირ დამონტაჟდეს

ამიტომ, ჩვენ დავაინსტალირებთ ამ მოდულს, როგორც სისტემის პაკეტს, რომელიც ავრცელებს უკვე შედგენილ ვერსიას, მაგრამ ცოტა უფრო ძველი ვიდრე ამჟამად ხელმისაწვდომია საიტზე:

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

შემდეგი, დააინსტალირეთ Python მოდულები პაკეტის მენეჯერის მეშვეობით pip. გთხოვთ იყოთ მოთმინება, რადგან ზოგიერთი მოდული შედგენილია და შეიძლება რამდენიმე წუთი დასჭირდეს. ჩემს აპარატზე კომპილაციას ~ 15 წუთი დასჭირდა:

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

ინსტალაციის ქეშის გასუფთავება:

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

მოდულების ტესტირება JupyterLab-ში ^

თუ დარბიხარ იუპიტერის ლაბორატორია, გადატვირთეთ ისე, რომ ახლად დაყენებული მოდულები გააქტიურდეს. ამისათვის, კონსოლის სესიაზე დააწკაპუნეთ CTRL+C სადაც გაქვს გაშვებული და შედი y შეწყვიტოს მოთხოვნა და შემდეგ თავიდან დაიწყოს იუპიტერის ლაბორატორია კლავიატურაზე ზევით ისრის დაჭერით, რომ ბრძანება ისევ არ შევიდეს და მერე Enter დასაწყებად:

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

გადადით გვერდზე http://10.0.5.5:8888/lab ან განაახლეთ გვერდი თქვენს ბრაუზერში და შემდეგ შეიყვანეთ შემდეგი კოდი ნოუთბუქის ახალ უჯრედში:

%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

თქვენ უნდა მიიღოთ შედეგი, როგორც ქვემოთ მოცემულ სურათზე, სადაც IPyWidgets ქმნის UI ელემენტს გვერდზე, რომელიც ინტერაქტიულად ურთიერთქმედებს წყაროს კოდთან და ასევე matplotlib აჩვენებს კოდის შედეგს სურათის სახით ფუნქციის გრაფიკის სახით:

ბევრი მაგალითი IPyWidgets შეგიძლიათ იპოვოთ ის გაკვეთილებში აქ

Სხვა რა? ^

კარგია, თუ დარჩით და მიაღწიეთ სტატიის ბოლომდე. მე განზრახ არ გამოვაქვეყნე მზა სკრიპტი სტატიის ბოლოს, რომელიც დაინსტალირდებოდა იუპიტერის ლაბორატორია მუშების წახალისებისთვის "ერთი დაწკაპუნებით" :) მაგრამ თქვენ თვითონ შეგიძლიათ ამის გაკეთება, რადგან თქვენ უკვე იცით როგორ, ბრძანებები შეაგროვეთ ერთ Bash სკრიპტში :)

Ასევე შეგიძლიათ:

• დააყენეთ კონტეინერის ქსელის სახელი IP მისამართის ნაცვლად, მარტივი ჩაწერით /etc/hosts და ჩაწერეთ მისამართი ბრაუზერში http://jupyter.local:8888
• ითამაშე კონტეინერის რესურსის ლიმიტით, ამისათვის წაიკითხეთ თავი ძირითადი LXD შესაძლებლობები ან მიიღეთ მეტი ინფორმაცია LXD დეველოპერის საიტზე.
• შეცვალეთ თემა:

და კიდევ ბევრი რამის გაკეთება შეგიძლიათ! Სულ ეს არის. Წარმატებას გისურვებ!

განახლება: 15.04.2020/18/30 XNUMX:XNUMX - შესწორებული შეცდომები თავში "გამარჯობა, სამყარო!"
განახლება: 16.04.2020/10/00 XNUMX:XNUMX — შესწორებული და დამატებული ტექსტი გაფართოების მენეჯერის გააქტიურების აღწერაში იუპიტერის ლაბორატორია
განახლება: 16.04.2020/10/40 XNUMX:XNUMX — ტექსტში აღმოჩენილი შეცდომების გასწორება და უკეთესობისკენ ოდნავ შეცვლილი თავი „ძირითადი პროგრამული უზრუნველყოფის დაყენება და სისტემის დაყენება“

წყარო: www.habr.com