ការបាញ់បង្ហោះ Jupyter ចូលទៅក្នុងគន្លង LXD

តើអ្នកធ្លាប់សាកល្បងជាមួយកូដ ឬឧបករណ៍ប្រើប្រាស់ប្រព័ន្ធនៅក្នុងលីនុច ដោយមិនខ្វល់ពីប្រព័ន្ធមូលដ្ឋាន និងបំផ្លាញអ្វីៗទាំងអស់ក្នុងករណីមានកំហុសនៅក្នុងកូដដែលសន្មត់ថាដំណើរការដោយសិទ្ធិជា root ទេ?

ប៉ុន្តែចុះយ៉ាងណាចំពោះការពិតដែលនិយាយថា អ្នកត្រូវការសាកល្បង ឬដំណើរការនូវចង្កោមនៃសេវាកម្មមីក្រូផ្សេងៗនៅលើម៉ាស៊ីនតែមួយ? មួយរយ ឬមួយពាន់?

ជាមួយនឹងម៉ាស៊ីននិម្មិតដែលគ្រប់គ្រងដោយ hypervisor បញ្ហាបែបនេះអាចនិងត្រូវបានដោះស្រាយ ប៉ុន្តែតើត្រូវចំណាយប៉ុន្មាន? ឧទាហរណ៍ កុងតឺន័រនៅក្នុង LXD ផ្អែកលើការចែកចាយលីនុច Alpine ប្រើប្រាស់តែប៉ុណ្ណោះ 7.60MB RAM និងកន្លែងដែលភាគថាសជា root កាន់កាប់បន្ទាប់ពីការចាប់ផ្តើម 9.5MB! យល់​យ៉ាង​ណា​ដែរ Elon Musk? ខ្ញុំសូមណែនាំឱ្យពិនិត្យមើល សមត្ថភាពជាមូលដ្ឋាននៃ LXD - ប្រព័ន្ធកុងតឺន័រនៅក្នុងលីនុច

បន្ទាប់ពីវាច្បាស់ជាជាទូទៅថាតើធុង LXD ជាអ្វីហើយ តោះទៅមើលបន្ថែមទៀត ហើយគិតថាតើមានអ្វីកើតឡើងប្រសិនបើមានវេទិកាប្រមូលផលបែបនេះ ដែលអ្នកអាចដំណើរការកូដសម្រាប់ម៉ាស៊ីនដោយសុវត្ថិភាព បង្កើតក្រាហ្វ ភ្ជាប់ UI-ធាតុក្រាហ្វិកដោយថាមវន្ត (អន្តរកម្ម) ជាមួយកូដរបស់អ្នក បន្ថែមកូដជាមួយអត្ថបទជាមួយ blackjack... ការធ្វើទ្រង់ទ្រាយ? ប្រភេទប្លុកអន្តរកម្មមួយចំនួន? អីយ៉ា... ចង់បាន! ចង់! 🙂

រកមើលនៅក្រោមឆ្មាដែលយើងនឹងបើកនៅក្នុងធុងមួយ។ ជូទីតឡាប - ជំនាន់បន្ទាប់នៃចំណុចប្រទាក់អ្នកប្រើជំនួសឱ្យ Jupyter Notebook ហួសសម័យ ហើយយើងក៏នឹងដំឡើងម៉ូឌុល Python ដូចជា ណាំភី, ផេនដាស, ម៉ាត់ផ្លូលីប, IPyWidgets ដែលនឹងអនុញ្ញាតឱ្យអ្នកធ្វើអ្វីគ្រប់យ៉ាងដែលបានរាយខាងលើ ហើយរក្សាទុកវាទាំងអស់នៅក្នុងឯកសារពិសេសមួយ - កុំព្យូទ័រយួរដៃ IPython ។

នាវាចរណ៍។

• ផែនការចុះចតគន្លង
• ការដំឡើងនិងការកំណត់រចនាសម្ព័ន្ធប្រព័ន្ធមូលដ្ឋាន
• ការដំឡើងកម្មវិធីមូលដ្ឋាន និងដំឡើងប្រព័ន្ធ
• ការដំឡើង និងកំណត់រចនាសម្ព័ន្ធ JupyterLab
• ការចែករំលែកទិន្នន័យជាមួយម៉ាស៊ីន
• សួស្តី​ពិភពលោក!
• ការពង្រីកសមត្ថភាពរបស់ Python
• សាកល្បងម៉ូឌុលនៅក្នុង JupyterLab
• តើ​មាន​អ្វី​ផ្សេង​ទៀត?

ផែនការចុះចតគន្លង ^

សូម​រៀប​រាប់​ផែនការ​សកម្មភាព​ខ្លីៗ ដើម្បី​ធ្វើ​ឱ្យ​វា​កាន់តែ​ងាយស្រួល​សម្រាប់​យើង​ក្នុង​ការ​អនុវត្ត​គម្រោង​ខាងលើ៖

• តោះដំឡើង និងបើកដំណើរការកុងតឺន័រដោយផ្អែកលើឧបករណ៍ចែកចាយ Alpine លីនុច។. យើងនឹងប្រើការចែកចាយនេះ ព្រោះវាមានបំណងតិចតួចបំផុត ហើយនឹងដំឡើងតែកម្មវិធីដែលចាំបាច់បំផុតនៅក្នុងវា គ្មានអ្វីនាំអោយនោះទេ។
• តោះបន្ថែមថាសនិម្មិតបន្ថែមនៅក្នុងកុងតឺន័រ ហើយដាក់ឈ្មោះវា - hostfs ហើយភ្ជាប់វាទៅប្រព័ន្ធឯកសារ root ។ ថាសនេះនឹងធ្វើឱ្យវាអាចប្រើឯកសារនៅលើម៉ាស៊ីនពីថតដែលបានផ្តល់ឱ្យនៅខាងក្នុងកុងតឺន័រ។ ដូច្នេះ ទិន្នន័យរបស់យើងនឹងឯករាជ្យពីកុងតឺន័រ។ ប្រសិនបើកុងតឺន័រត្រូវបានលុប ទិន្នន័យនឹងនៅតែមាននៅលើម៉ាស៊ីន។ ដូចគ្នានេះផងដែរ គ្រោងការណ៍នេះមានប្រយោជន៍សម្រាប់ការចែករំលែកទិន្នន័យដូចគ្នារវាងធុងជាច្រើនដោយមិនប្រើយន្តការបណ្តាញស្តង់ដារនៃការចែកចាយកុងតឺន័រ។
• តោះដំឡើង Bash, sudo, បណ្ណាល័យចាំបាច់ បន្ថែម និងកំណត់រចនាសម្ព័ន្ធអ្នកប្រើប្រាស់ប្រព័ន្ធ
• តោះដំឡើង Python, modules និង compile binary dependencies សម្រាប់ពួកគេ។
• តោះដំឡើង និងបើកដំណើរការ ជូទីតឡាបប្ដូររូបរាងតាមបំណង ដំឡើងផ្នែកបន្ថែមសម្រាប់វា។

នៅក្នុងអត្ថបទនេះយើងនឹងចាប់ផ្តើមជាមួយនឹងការបើកដំណើរការកុងតឺន័រយើងនឹងមិនពិចារណាការដំឡើងនិងកំណត់រចនាសម្ព័ន្ធ LXD ទេអ្នកអាចរកឃើញទាំងអស់នេះនៅក្នុងអត្ថបទមួយផ្សេងទៀត - លក្ខណៈពិសេសជាមូលដ្ឋាននៃ LXD - ប្រព័ន្ធធុងលីនុច.

ការដំឡើងនិងការកំណត់រចនាសម្ព័ន្ធប្រព័ន្ធមូលដ្ឋាន ^

យើងបង្កើតកុងតឺន័រដោយប្រើពាក្យបញ្ជាដែលយើងបញ្ជាក់រូបភាព - 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 ដែលចង្អុលបង្ហាញថា columns បង្ហាញ៖

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

នៅពេលបង្កើតកុងតឺន័រ អាសយដ្ឋាន IP ត្រូវបានជ្រើសរើសដោយចៃដន្យ ដោយសារយើងប្រើទម្រង់កំណត់រចនាសម្ព័ន្ធ default ដែលត្រូវបានកំណត់រចនាសម្ព័ន្ធពីមុននៅក្នុងអត្ថបទ លក្ខណៈពិសេសជាមូលដ្ឋាននៃ LXD - ប្រព័ន្ធធុងលីនុច.

យើងនឹងផ្លាស់ប្តូរអាសយដ្ឋាន 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
ការ​បញ្ចប់​កម្មវិធី​សម្រាប់​សែល bash

sudo
ផ្តល់ឱ្យអ្នកប្រើប្រាស់ជាក់លាក់នូវសមត្ថភាពក្នុងការដំណើរការពាក្យបញ្ជាមួយចំនួនជា root

ស្រមោល
ឈុតឧបករណ៍គ្រប់គ្រងពាក្យសម្ងាត់ និងគណនីដែលមានការគាំទ្រសម្រាប់ឯកសារស្រមោល និង PAM

tzdata
ប្រភពសម្រាប់តំបន់ពេលវេលា និងទិន្នន័យពេលវេលាសន្សំពន្លឺថ្ងៃ

nano
ក្លូនកម្មវិធីនិពន្ធ Pico ជាមួយការកែលម្អ

លើសពីនេះ អ្នកអាចដំឡើងការគាំទ្រនៅក្នុង system 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 - លេខសម្គាល់កុងតឺន័រ
• -- - កូនសោពិសេសដែលបញ្ជាក់មិនឱ្យបកស្រាយសោបន្ថែមជាកូនសោសម្រាប់ lxc ហើយឆ្លងកាត់ខ្សែអក្សរដែលនៅសល់ដូចទៅនឹងកុងតឺន័រ
• apk - កម្មវិធីគ្រប់គ្រងកញ្ចប់ចែកចាយលីនុច Alpine
• 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 សម្រាប់អ្នកប្រើប្រាស់ថ្មីនៅក្នុងកុងតឺន័រនោះ តាមជំហានខាងក្រោម យើងនឹងចម្លងឯកសារ skel ដែលត្រៀមរួចជាស្រេចពីប្រព័ន្ធម៉ាស៊ីនទៅវា។ នេះនឹងអនុញ្ញាតឱ្យអ្នកតុបតែង 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 ដែលមានស្រាប់ សូមចម្លងឯកសារ 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

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 ដូច្នេះដំបូងយើងត្រូវដំឡើងកម្មវិធីបកប្រែនេះ។ ផងដែរ ជូទីតឡាប យើងនឹងដំឡើងដោយប្រើកម្មវិធីគ្រប់គ្រងកញ្ចប់ Python pipមិនមែនប្រព័ន្ធមួយទេ ព្រោះវាប្រហែលជាហួសសម័យនៅក្នុងឃ្លាំងប្រព័ន្ធ ដូច្នេះហើយ យើងត្រូវដោះស្រាយភាពអាស្រ័យសម្រាប់វាដោយដៃដោយដំឡើងកញ្ចប់ខាងក្រោម − python3 python3-dev gcc libc-dev zeromq-dev:

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

តោះធ្វើបច្ចុប្បន្នភាពម៉ូឌុល python និងកម្មវិធីគ្រប់គ្រងកញ្ចប់ 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"

ឥឡូវនេះដំណើរការពាក្យបញ្ជាពីរខាងក្រោមដើម្បីដំណើរការវាជាលើកដំបូង ជូទីតឡាប. វាអាចទៅរួចក្នុងការបើកដំណើរការវាដោយប្រើពាក្យបញ្ជាមួយ ប៉ុន្តែក្នុងករណីនេះ ពាក្យបញ្ជាចាប់ផ្តើមដែលពិបាកចងចាំក្នុងចិត្តរបស់អ្នក នឹងត្រូវបានចងចាំដោយ bash នៅក្នុងកុងតឺន័រ ហើយមិនមែននៅលើម៉ាស៊ីនដែលមានពាក្យបញ្ជាគ្រប់គ្រាន់រួចហើយ ដើម្បីកត់ត្រាពួកគេនៅក្នុងប្រវត្តិសាស្រ្ត :)

ចូលទៅកាន់កុងតឺន័រជាអ្នកប្រើប្រាស់ 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ប៉ុន្តែផែនការរបស់យើងគឺដើម្បីបំបែកទិន្នន័យ (ចែករំលែក) រវាងម៉ាស៊ីន និងកុងតឺន័រ ដូច្នេះត្រឡប់ទៅកុងសូលវិញ ហើយឈប់ ជូទីតឡាប ដោយការប្រតិបត្តិ hotkey - CTRL+C និងឆ្លើយ y តាមការស្នើសុំ។ បន្ទាប់មកបិទវគ្គអន្តរកម្មរបស់អ្នកប្រើ jupyter ការបំពេញ hotkey CTRL+D.

ការចែករំលែកទិន្នន័យជាមួយម៉ាស៊ីន ^

ដើម្បីចែករំលែកទិន្នន័យជាមួយម៉ាស៊ីន អ្នកត្រូវបង្កើតឧបករណ៍នៅក្នុងកុងតឺន័រដែលអនុញ្ញាតឱ្យអ្នកធ្វើដូចនេះ ហើយដើម្បីធ្វើដូច្នេះ សូមដំណើរការពាក្យបញ្ជាខាងក្រោមដែលយើងបញ្ជាក់គន្លឹះខាងក្រោម៖

• lxc config device add - ពាក្យបញ្ជាបន្ថែមការកំណត់រចនាសម្ព័ន្ធឧបករណ៍
• jupyter - លេខសម្គាល់កុងតឺន័រដែលការកំណត់រចនាសម្ព័ន្ធត្រូវបានបន្ថែម
• hostfs - លេខសម្គាល់ឧបករណ៍។ អ្នកអាចកំណត់ឈ្មោះណាមួយ។
• 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 - ប្រព័ន្ធធុងលីនុច.

កំណត់ការអនុញ្ញាតនៅលើម៉ាស៊ីន ដែលម្ចាស់នឹងជាអ្នកប្រើប្រាស់កុងតឺន័រ jupyterនិងអថេរ $USER នឹងបញ្ជាក់អ្នកប្រើប្រាស់ម៉ាស៊ីនរបស់អ្នកជាក្រុម៖

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

សួស្តី​ពិភពលោក! ^

ប្រសិនបើអ្នកនៅតែមានសម័យកុងសូលបើកនៅក្នុងកុងតឺន័រជាមួយ ជូទីតឡាបបន្ទាប់មកចាប់ផ្តើមវាឡើងវិញដោយប្រើសោថ្មី។ --notebook-dir ដោយកំណត់តម្លៃ /mnt/hostfs ជាផ្លូវទៅកាន់ root នៃកុំព្យូទ័រយួរដៃនៅក្នុងកុងតឺន័រសម្រាប់ឧបករណ៍ដែលយើងបានបង្កើតក្នុងជំហានមុន៖

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

បន្ទាប់មកចូលទៅកាន់ទំព័រ http://10.0.5.5:8888 ហើយបង្កើតកុំព្យូទ័រយួរដៃដំបូងរបស់អ្នកដោយចុចប៊ូតុងនៅលើទំព័រដូចបង្ហាញក្នុងរូបភាពខាងក្រោម៖

បន្ទាប់មក នៅក្នុងវាលនៅលើទំព័រ សូមបញ្ចូលកូដ Python ដែលនឹងបង្ហាញអក្សរបុរាណ Hello World!. នៅពេលអ្នកបានបញ្ចប់ការបញ្ចូលសូមចុច CTRL+ENTER ឬប៊ូតុង "លេង" នៅលើរបារឧបករណ៍នៅផ្នែកខាងលើដើម្បីឱ្យ JupyterLab ធ្វើដូចនេះ៖

នៅពេលនេះ អ្វីៗស្ទើរតែរួចរាល់សម្រាប់ការប្រើប្រាស់ ប៉ុន្តែវានឹងមិនគួរឱ្យចាប់អារម្មណ៍ទេ ប្រសិនបើយើងមិនដំឡើងម៉ូឌុល Python បន្ថែម (កម្មវិធីពេញលក្ខណៈ) ដែលអាចពង្រីកសមត្ថភាពស្តង់ដាររបស់ Python យ៉ាងសំខាន់នៅក្នុង ជូទីតឡាបដូច្នេះសូមបន្តទៅមុខទៀត :)

PS អ្វីដែលគួរឱ្យចាប់អារម្មណ៍នោះគឺថាការអនុវត្តចាស់ ជិប នៅក្រោមឈ្មោះកូដ កុំព្យូទ័រយួរដៃ Jupyter មិន​បាន​ទៅ​ឆ្ងាយ​ទេ​ហើយ​វា​មាន​ស្រប​ជាមួយ​នឹង​ ជូទីតឡាប. ដើម្បីប្តូរទៅកំណែចាស់ សូមធ្វើតាមតំណដែលបន្ថែមបច្ច័យនៅក្នុងអាសយដ្ឋាន/treeហើយការផ្លាស់ប្តូរទៅកំណែថ្មីត្រូវបានអនុវត្តជាមួយបច្ច័យ /labប៉ុន្តែវាមិនចាំបាច់បញ្ជាក់ទេ៖

• សៀវភៅកត់ត្រា Jupyter - http://10.0.5.5:8888/tree
• មន្ទីរពិសោធន៍ Jupyter - http://10.0.5.5:8888/lab

ការពង្រីកសមត្ថភាពរបស់ Python ^

នៅក្នុងផ្នែកនេះ យើងនឹងដំឡើងម៉ូឌុលភាសា Python ដែលមានអនុភាពដូចជា ណាំភី, ផេនដាស, ម៉ាត់ផ្លូលីប, IPyWidgets លទ្ធផលត្រូវបានបញ្ចូលទៅក្នុងកុំព្យូទ័រយួរដៃ ជូទីតឡាប.

មុនពេលដំឡើងម៉ូឌុល Python ដែលបានរាយបញ្ជីតាមរយៈកម្មវិធីគ្រប់គ្រងកញ្ចប់ pip ដំបូងយើងត្រូវដោះស្រាយភាពអាស្រ័យនៃប្រព័ន្ធនៅក្នុង Alpine Linux៖

• g++ - ត្រូវការសម្រាប់ការចងក្រងម៉ូឌុល ដោយសារពួកវាខ្លះត្រូវបានអនុវត្តជាភាសា C ++ ហើយភ្ជាប់ទៅ Python នៅពេលដំណើរការជាម៉ូឌុលគោលពីរ
• freetype-dev - ភាពអាស្រ័យសម្រាប់ម៉ូឌុល Python ម៉ាត់ផ្លូលីប

ការដំឡើងភាពអាស្រ័យ៖

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

មានបញ្ហាមួយ៖ នៅក្នុងស្ថានភាពបច្ចុប្បន្ននៃការចែកចាយ Alpine Linux វានឹងមិនអាចចងក្រងកំណែថ្មីរបស់ NumPy បានទេ កំហុសក្នុងការចងក្រងនឹងលេចឡើងដែលខ្ញុំមិនអាចដោះស្រាយបាន៖

កំហុស៖ មិនអាចបង្កើតកង់សម្រាប់ 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 នៅលើទំព័រដែលមានអន្តរកម្មអន្តរកម្មជាមួយកូដប្រភព និងផងដែរ។ ម៉ាត់ផ្លូលីប បង្ហាញលទ្ធផលនៃកូដក្នុងទម្រង់រូបភាពជាក្រាហ្វមុខងារ៖

ឧទាហរណ៍ជាច្រើន។ 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 — កែកំហុសដែលបានរកឃើញនៅក្នុងអត្ថបទ និងបានផ្លាស់ប្តូរបន្តិចបន្តួចសម្រាប់ជំពូក “ការដំឡើងកម្មវិធីមូលដ្ឋាន និងការដំឡើងប្រព័ន្ធ”

ប្រភព: www.habr.com