LXD ಕಕ್ಷೆಗೆ ಗುರುಗ್ರಹವನ್ನು ಉಡಾವಣೆ ಮಾಡಲಾಗುತ್ತಿದೆ

ನೀವು ಎಂದಾದರೂ ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಕೋಡ್ ಅಥವಾ ಸಿಸ್ಟಮ್ ಉಪಯುಕ್ತತೆಗಳನ್ನು ಪ್ರಯೋಗಿಸಬೇಕಾಗಿರುವುದರಿಂದ ಬೇಸ್ ಸಿಸ್ಟಮ್ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಡಿ ಮತ್ತು ರೂಟ್ ಸವಲತ್ತುಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕಾದ ಕೋಡ್‌ನಲ್ಲಿ ದೋಷದ ಸಂದರ್ಭದಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಹರಿದು ಹಾಕಬೇಡಿ?

ಆದರೆ ನೀವು ಒಂದು ಯಂತ್ರದಲ್ಲಿ ವಿವಿಧ ಮೈಕ್ರೊ ಸರ್ವೀಸ್‌ಗಳ ಸಂಪೂರ್ಣ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಬೇಕು ಅಥವಾ ಚಲಾಯಿಸಬೇಕು ಎಂದು ಹೇಳೋಣ? ನೂರು ಅಥವಾ ಸಾವಿರ?

ಹೈಪರ್ವೈಸರ್ ನಿರ್ವಹಿಸುವ ವರ್ಚುವಲ್ ಯಂತ್ರಗಳೊಂದಿಗೆ, ಅಂತಹ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬಹುದು ಮತ್ತು ಪರಿಹರಿಸಬಹುದು, ಆದರೆ ಯಾವ ವೆಚ್ಚದಲ್ಲಿ? ಉದಾಹರಣೆಗೆ, ಆಲ್ಪೈನ್ ಲಿನಕ್ಸ್ ವಿತರಣೆಯ ಆಧಾರದ ಮೇಲೆ LXD ಯಲ್ಲಿನ ಕಂಟೇನರ್ ಅನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತದೆ 7.60MB RAM, ಮತ್ತು ಪ್ರಾರಂಭದ ನಂತರ ಮೂಲ ವಿಭಾಗವು ಎಲ್ಲಿ ಆಕ್ರಮಿಸುತ್ತದೆ 9.5MB! ನೀವು ಅದನ್ನು ಹೇಗೆ ಇಷ್ಟಪಡುತ್ತೀರಿ, ಎಲೋನ್ ಮಸ್ಕ್? ಪರಿಶೀಲಿಸಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ LXD ಯ ಮೂಲಭೂತ ಸಾಮರ್ಥ್ಯಗಳು - Linux ನಲ್ಲಿ ಕಂಟೇನರ್ ಸಿಸ್ಟಮ್

LXD ಕಂಟೈನರ್‌ಗಳು ಯಾವುವು ಎಂಬುದು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಪಷ್ಟವಾದ ನಂತರ, ನಾವು ಮುಂದೆ ಹೋಗಿ ಯೋಚಿಸೋಣ, ಅಂತಹ ಹಾರ್ವೆಸ್ಟರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಇದ್ದರೆ ನೀವು ಹೋಸ್ಟ್‌ಗಾಗಿ ಕೋಡ್ ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ರನ್ ಮಾಡಬಹುದು, ಗ್ರಾಫ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸಬಹುದು, ಕ್ರಿಯಾತ್ಮಕವಾಗಿ (ಸಂವಾದಾತ್ಮಕವಾಗಿ) ನಿಮ್ಮ ಕೋಡ್‌ನೊಂದಿಗೆ UI- ವಿಜೆಟ್‌ಗಳನ್ನು ಲಿಂಕ್ ಮಾಡಬಹುದು, ಬ್ಲ್ಯಾಕ್‌ಜಾಕ್‌ನೊಂದಿಗೆ ಪಠ್ಯದೊಂದಿಗೆ ಕೋಡ್ ಅನ್ನು ಪೂರಕಗೊಳಿಸಿ... ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದೇ? ಕೆಲವು ರೀತಿಯ ಸಂವಾದಾತ್ಮಕ ಬ್ಲಾಗ್? ವಾವ್... ನನಗೆ ಇದು ಬೇಕು! ಬೇಕು! 🙂

ನಾವು ಕಂಟೇನರ್ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸುವ ಬೆಕ್ಕಿನ ಕೆಳಗೆ ನೋಡಿ ಜುಪಿಟರ್ ಲ್ಯಾಬ್ - ಹಳತಾದ ಜುಪಿಟರ್ ನೋಟ್‌ಬುಕ್ ಬದಲಿಗೆ ಮುಂದಿನ ಪೀಳಿಗೆಯ ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್, ಮತ್ತು ನಾವು ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸಹ ಸ್ಥಾಪಿಸುತ್ತೇವೆ ನಂಬಿ, ಪಾಂಡಾಗಳು, ಮ್ಯಾಟ್ಪ್ಲೋಟ್ಲಿಬ್, IPyWidgets ಇದು ಮೇಲೆ ಪಟ್ಟಿ ಮಾಡಲಾದ ಎಲ್ಲವನ್ನೂ ಮಾಡಲು ಮತ್ತು ವಿಶೇಷ ಫೈಲ್‌ನಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಉಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ - IPython ಲ್ಯಾಪ್‌ಟಾಪ್.

Навигация

• ಕಕ್ಷೆಯ ಟೇಕ್-ಆಫ್ ಯೋಜನೆ
• ಮೂಲ ವ್ಯವಸ್ಥೆಯ ಸ್ಥಾಪನೆ ಮತ್ತು ಸಂರಚನೆ
• ಮೂಲ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮತ್ತು ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೊಂದಿಸುವುದು
• JupyterLab ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು
• ಹೋಸ್ಟ್‌ನೊಂದಿಗೆ ಡೇಟಾವನ್ನು ಹಂಚಿಕೊಳ್ಳಲಾಗುತ್ತಿದೆ
• ಹಲೋ, ವಿಶ್ವ!
• ಪೈಥಾನ್‌ನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ವಿಸ್ತರಿಸುವುದು
• JupyterLab ನಲ್ಲಿ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ
• ಮತ್ತೇನು?

ಕಕ್ಷೆಯ ಟೇಕ್-ಆಫ್ ಯೋಜನೆ ^

ಮೇಲಿನ ಯೋಜನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಮಗೆ ಸುಲಭವಾಗುವಂತೆ ಸಂಕ್ಷಿಪ್ತ ಕ್ರಿಯಾ ಯೋಜನೆಯನ್ನು ರೂಪಿಸೋಣ:

• ವಿತರಣಾ ಕಿಟ್ ಅನ್ನು ಆಧರಿಸಿ ಕಂಟೇನರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಪ್ರಾರಂಭಿಸೋಣ ಆಲ್ಪೈನ್ ಲಿನಕ್ಸ್. ನಾವು ಈ ವಿತರಣೆಯನ್ನು ಬಳಸುತ್ತೇವೆ ಏಕೆಂದರೆ ಇದು ಕನಿಷ್ಠೀಯತಾವಾದವನ್ನು ಗುರಿಯಾಗಿರಿಸಿಕೊಂಡಿದೆ ಮತ್ತು ಅದರಲ್ಲಿ ಅತ್ಯಂತ ಅಗತ್ಯವಾದ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಮಾತ್ರ ಸ್ಥಾಪಿಸುತ್ತದೆ, ಏನೂ ಅತಿರೇಕವಿಲ್ಲ.
• ಕಂಟೇನರ್‌ನಲ್ಲಿ ಹೆಚ್ಚುವರಿ ವರ್ಚುವಲ್ ಡಿಸ್ಕ್ ಅನ್ನು ಸೇರಿಸೋಣ ಮತ್ತು ಅದಕ್ಕೆ ಹೆಸರನ್ನು ನೀಡೋಣ - hostfs ಮತ್ತು ಅದನ್ನು ರೂಟ್ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗೆ ಆರೋಹಿಸಿ. ಈ ಡಿಸ್ಕ್ ಧಾರಕದಲ್ಲಿ ಕೊಟ್ಟಿರುವ ಡೈರೆಕ್ಟರಿಯಿಂದ ಹೋಸ್ಟ್‌ನಲ್ಲಿ ಫೈಲ್‌ಗಳನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ನಮ್ಮ ಡೇಟಾ ಕಂಟೇನರ್‌ನಿಂದ ಸ್ವತಂತ್ರವಾಗಿರುತ್ತದೆ. ಧಾರಕವನ್ನು ಅಳಿಸಿದರೆ, ಡೇಟಾ ಹೋಸ್ಟ್‌ನಲ್ಲಿ ಉಳಿಯುತ್ತದೆ. ಅಲ್ಲದೆ, ಕಂಟೇನರ್ ವಿತರಣೆಯ ಪ್ರಮಾಣಿತ ನೆಟ್‌ವರ್ಕ್ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಬಳಸದೆಯೇ ಅನೇಕ ಕಂಟೇನರ್‌ಗಳ ನಡುವೆ ಒಂದೇ ಡೇಟಾವನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಈ ಯೋಜನೆಯು ಉಪಯುಕ್ತವಾಗಿದೆ.
• Bash, sudo, ಅಗತ್ಯ ಲೈಬ್ರರಿಗಳನ್ನು ಸ್ಥಾಪಿಸೋಣ, ಸಿಸ್ಟಮ್ ಬಳಕೆದಾರರನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡೋಣ
• ಪೈಥಾನ್, ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸೋಣ ಮತ್ತು ಅವುಗಳಿಗೆ ಬೈನರಿ ಅವಲಂಬನೆಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡೋಣ
• ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಪ್ರಾರಂಭಿಸೋಣ ಜುಪಿಟರ್ ಲ್ಯಾಬ್, ನೋಟವನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಿ, ಅದಕ್ಕಾಗಿ ವಿಸ್ತರಣೆಗಳನ್ನು ಸ್ಥಾಪಿಸಿ.

ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, LXD ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದನ್ನು ನಾವು ಪರಿಗಣಿಸುವುದಿಲ್ಲ, ನೀವು ಇನ್ನೊಂದು ಲೇಖನದಲ್ಲಿ ಇದನ್ನು ಕಾಣಬಹುದು - LXD - Linux ಕಂಟೇನರ್ ಸಿಸ್ಟಮ್‌ಗಳ ಮೂಲಭೂತ ಲಕ್ಷಣಗಳು.

ಮೂಲ ವ್ಯವಸ್ಥೆಯ ಸ್ಥಾಪನೆ ಮತ್ತು ಸಂರಚನೆ ^

ನಾವು ಚಿತ್ರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಆಜ್ಞೆಯೊಂದಿಗೆ ನಾವು ಕಂಟೇನರ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ - alpine3, ಕಂಟೇನರ್‌ಗಾಗಿ ಗುರುತಿಸುವಿಕೆ - jupyterlab ಮತ್ತು, ಅಗತ್ಯವಿದ್ದರೆ, ಕಾನ್ಫಿಗರೇಶನ್ ಪ್ರೊಫೈಲ್‌ಗಳು:

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

ಇಲ್ಲಿ ನಾನು ಕಾನ್ಫಿಗರೇಶನ್ ಪ್ರೊಫೈಲ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇನೆ hddroot ಇದು ರೂಟ್ ವಿಭಜನೆಯೊಂದಿಗೆ ಧಾರಕವನ್ನು ರಚಿಸಲು ಸೂಚಿಸುತ್ತದೆ ಶೇಖರಣಾ ಪೂಲ್ ಭೌತಿಕ 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

ಇದು ಎಚ್‌ಡಿಡಿ ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಕಂಟೇನರ್‌ಗಳನ್ನು ಪ್ರಯೋಗಿಸಲು ನನಗೆ ಅವಕಾಶವನ್ನು ನೀಡುತ್ತದೆ, ಎಸ್‌ಎಸ್‌ಡಿ ಡಿಸ್ಕ್‌ನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಉಳಿಸುತ್ತದೆ, ಇದು ನನ್ನ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿಯೂ ಲಭ್ಯವಿದೆ 🙂 ಇದಕ್ಕಾಗಿ ನಾನು ಪ್ರತ್ಯೇಕ ಕಾನ್ಫಿಗರೇಶನ್ ಪ್ರೊಫೈಲ್ ಅನ್ನು ರಚಿಸಿದ್ದೇನೆ 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      |
+------------+---------+------------------+--------------+

ಮೂಲ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮತ್ತು ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೊಂದಿಸುವುದು ^

ನಮ್ಮ ಕಂಟೇನರ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು, ನೀವು ಈ ಕೆಳಗಿನ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕು:

ಪ್ಯಾಕೇಜ್
ವಿವರಣೆ

ಬ್ಯಾಷ್
GNU ಬೌರ್ನ್ ಎಗೇನ್ ಶೆಲ್

ಬ್ಯಾಷ್-ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ
ಬ್ಯಾಷ್ ಶೆಲ್ಗಾಗಿ ಪ್ರೊಗ್ರಾಮೆಬಲ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ

ಸುಡೊ
ಕೆಲವು ಬಳಕೆದಾರರಿಗೆ ಕೆಲವು ಆಜ್ಞೆಗಳನ್ನು ರೂಟ್ ಆಗಿ ಚಲಾಯಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡಿ

ನೆರಳು
ನೆರಳು ಫೈಲ್‌ಗಳು ಮತ್ತು PAM ಗೆ ಬೆಂಬಲದೊಂದಿಗೆ ಪಾಸ್‌ವರ್ಡ್ ಮತ್ತು ಖಾತೆ ನಿರ್ವಹಣಾ ಸಾಧನ ಸೂಟ್

tzdata
ಸಮಯ ವಲಯ ಮತ್ತು ಹಗಲು ಉಳಿಸುವ ಸಮಯದ ಡೇಟಾದ ಮೂಲಗಳು

ನ್ಯಾನೋ
ವರ್ಧನೆಗಳೊಂದಿಗೆ ಪಿಕೊ ಸಂಪಾದಕ ಕ್ಲೋನ್

ಹೆಚ್ಚುವರಿಯಾಗಿ, ಕೆಳಗಿನ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಸ್ಥಾಪಿಸುವ ಮೂಲಕ ನೀವು ಸಿಸ್ಟಮ್ ಮ್ಯಾನ್-ಪುಟಗಳಲ್ಲಿ ಬೆಂಬಲವನ್ನು ಸ್ಥಾಪಿಸಬಹುದು - 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 - ಆಲ್ಪೈನ್ ಲಿನಕ್ಸ್ ವಿತರಣಾ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್
• 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

ಕಂಟೇನರ್‌ನಲ್ಲಿ ಹೊಸ ಬಳಕೆದಾರರಿಗೆ ಬ್ಯಾಷ್ ಅನ್ನು ಹೊಂದಿಸಲು ಸಾಕಷ್ಟು ಸಮಯವನ್ನು ಕಳೆಯದಿರಲು, ಈ ಕೆಳಗಿನ ಹಂತಗಳಲ್ಲಿ ನಾವು ಹೋಸ್ಟ್ ಸಿಸ್ಟಮ್‌ನಿಂದ ಸಿದ್ಧ ಸ್ಕೆಲ್ ಫೈಲ್‌ಗಳನ್ನು ನಕಲಿಸುತ್ತೇವೆ. ಸಂವಾದಾತ್ಮಕವಾಗಿ ಕಂಟೇನರ್‌ನಲ್ಲಿ ಬ್ಯಾಷ್ ಅನ್ನು ಸುಂದರಗೊಳಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ನನ್ನ ಹೋಸ್ಟ್ ಸಿಸ್ಟಮ್ ಮಂಜಾರೊ ಲಿನಕ್ಸ್ ಮತ್ತು ಫೈಲ್‌ಗಳನ್ನು ನಕಲಿಸಲಾಗುತ್ತಿದೆ /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors ತಾತ್ವಿಕವಾಗಿ ಅವು ಆಲ್ಪೈನ್ ಲಿನಕ್ಸ್‌ಗೆ ಸೂಕ್ತವಾಗಿವೆ ಮತ್ತು ನಿರ್ಣಾಯಕ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡುವುದಿಲ್ಲ, ಆದರೆ ನೀವು ವಿಭಿನ್ನ ವಿತರಣೆಯನ್ನು ಹೊಂದಿರಬಹುದು ಮತ್ತು ಕಂಟೇನರ್‌ನಲ್ಲಿ ಬ್ಯಾಷ್ ಅನ್ನು ಚಲಾಯಿಸುವಾಗ ದೋಷವಿದೆಯೇ ಎಂದು ನೀವು ಸ್ವತಂತ್ರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

ಸ್ಕೆಲ್ ಫೈಲ್‌ಗಳನ್ನು ಕಂಟೇನರ್‌ಗೆ ನಕಲಿಸಿ. ಕೀ --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

ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ರೂಟ್ ಬಳಕೆದಾರರಿಗಾಗಿ, ಕಂಟೇನರ್‌ಗೆ ನಕಲಿಸಲಾದ ಸ್ಕೆಲ್ ಫೈಲ್‌ಗಳನ್ನು ಹೋಮ್ ಡೈರೆಕ್ಟರಿಗೆ ನಕಲಿಸಿ:

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

ಆಲ್ಪೈನ್ ಲಿನಕ್ಸ್ ಬಳಕೆದಾರರಿಗಾಗಿ ಸಿಸ್ಟಮ್ ಶೆಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ /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 ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ^

ಜುಪಿಟರ್ ಲ್ಯಾಬ್ ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಮೊದಲು ಈ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕು. ಅಲ್ಲದೆ, ಜುಪಿಟರ್ ಲ್ಯಾಬ್ ನಾವು ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಥಾಪಿಸುತ್ತೇವೆ 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

ರಲ್ಲಿ ವಿಸ್ತರಣೆಗಳಿಂದ ಜುಪಿಟರ್ ಲ್ಯಾಬ್ ಪ್ರಾಯೋಗಿಕವಾಗಿರುತ್ತವೆ ಮತ್ತು ಅಧಿಕೃತವಾಗಿ ಜುಪಿಟರ್‌ಲ್ಯಾಬ್ ಪ್ಯಾಕೇಜ್‌ನೊಂದಿಗೆ ರವಾನೆಯಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಸ್ಥಾಪಿಸಬೇಕು ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕು.

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 ಪ್ರಸ್ತುತ ಯುಐಡಿಯನ್ನು ಹೊಂದಿರುವ ಕಂಟೈನರ್ ಬಳಕೆದಾರರಿಗೆ ಅನುಮತಿಯನ್ನು ಹೊಂದಿಸಬೇಕು 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 ಇದನ್ನು ಮಾಡಲು ಮೇಲ್ಭಾಗದಲ್ಲಿರುವ ಟೂಲ್‌ಬಾರ್‌ನಲ್ಲಿರುವ "ಪ್ಲೇ" ಬಟನ್:

ಈ ಹಂತದಲ್ಲಿ, ಬಹುತೇಕ ಎಲ್ಲವೂ ಬಳಕೆಗೆ ಸಿದ್ಧವಾಗಿದೆ, ಆದರೆ ಪೈಥಾನ್‌ನ ಪ್ರಮಾಣಿತ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಗಮನಾರ್ಹವಾಗಿ ವಿಸ್ತರಿಸಬಹುದಾದ ಹೆಚ್ಚುವರಿ ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು (ಪೂರ್ಣ-ಪ್ರಮಾಣದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು) ನಾವು ಸ್ಥಾಪಿಸದಿದ್ದರೆ ಅದು ಆಸಕ್ತಿರಹಿತವಾಗಿರುತ್ತದೆ. ಜುಪಿಟರ್ ಲ್ಯಾಬ್, ಆದ್ದರಿಂದ, ನಾವು ಮುಂದುವರಿಯೋಣ :)

ಪಿಎಸ್ ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವೆಂದರೆ ಹಳೆಯ ಅನುಷ್ಠಾನ ಜುಪಿಟರ್ ಕೋಡ್ ಹೆಸರಿನಲ್ಲಿ ಜುಪಿಟರ್ ನೋಟ್ಬುಕ್ ದೂರ ಹೋಗಿಲ್ಲ ಮತ್ತು ಇದು ಸಮಾನಾಂತರವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಜುಪಿಟರ್ ಲ್ಯಾಬ್. ಹಳೆಯ ಆವೃತ್ತಿಗೆ ಬದಲಾಯಿಸಲು, ವಿಳಾಸದಲ್ಲಿ ಪ್ರತ್ಯಯವನ್ನು ಸೇರಿಸುವ ಲಿಂಕ್ ಅನ್ನು ಅನುಸರಿಸಿ/tree, ಮತ್ತು ಹೊಸ ಆವೃತ್ತಿಗೆ ಪರಿವರ್ತನೆಯನ್ನು ಪ್ರತ್ಯಯದೊಂದಿಗೆ ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ /lab, ಆದರೆ ಇದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗಿಲ್ಲ:

• ಜುಪಿಟರ್ ನೋಟ್‌ಬುಕ್ - http://10.0.5.5:8888/tree
• ಜುಪಿಟರ್ ಲ್ಯಾಬ್ - http://10.0.5.5:8888/lab

ಪೈಥಾನ್‌ನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ವಿಸ್ತರಿಸುವುದು ^

ಈ ವಿಭಾಗದಲ್ಲಿ, ನಾವು ಅಂತಹ ಪ್ರಬಲ ಪೈಥಾನ್ ಭಾಷಾ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ ನಂಬಿ, ಪಾಂಡಾಗಳು, ಮ್ಯಾಟ್ಪ್ಲೋಟ್ಲಿಬ್, IPyWidgets ಇದರ ಫಲಿತಾಂಶಗಳನ್ನು ಲ್ಯಾಪ್‌ಟಾಪ್‌ಗಳಲ್ಲಿ ಸಂಯೋಜಿಸಲಾಗಿದೆ ಜುಪಿಟರ್ ಲ್ಯಾಬ್.

ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಮೂಲಕ ಪಟ್ಟಿ ಮಾಡಲಾದ ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸುವ ಮೊದಲು pip ನಾವು ಮೊದಲು ಆಲ್ಪೈನ್ ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಸಿಸ್ಟಮ್ ಅವಲಂಬನೆಗಳನ್ನು ಪರಿಹರಿಸಬೇಕು:

• g++ — ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಅಗತ್ಯವಿದೆ, ಏಕೆಂದರೆ ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಭಾಷೆಯಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ ಸಿ ++ ಮತ್ತು ಬೈನರಿ ಮಾಡ್ಯೂಲ್‌ಗಳಂತೆ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಪೈಥಾನ್‌ಗೆ ಸಂಪರ್ಕಪಡಿಸಿ
• freetype-dev - ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್‌ಗೆ ಅವಲಂಬನೆ ಮ್ಯಾಟ್ಪ್ಲೋಟ್ಲಿಬ್

ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸುವುದು:

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

ಒಂದು ಸಮಸ್ಯೆ ಇದೆ: ಆಲ್ಪೈನ್ ಲಿನಕ್ಸ್ ವಿತರಣೆಯ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯಲ್ಲಿ, NumPy ನ ಹೊಸ ಆವೃತ್ತಿಯನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ; ನಾನು ಪರಿಹರಿಸಲು ಸಾಧ್ಯವಾಗದ ಸಂಕಲನ ದೋಷ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ:

ದೋಷ: PEP 517 ಅನ್ನು ಬಳಸುವ ಮತ್ತು ನೇರವಾಗಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಲಾಗದ ನಂಬಿಗಾಗಿ ಚಕ್ರಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

ಆದ್ದರಿಂದ, ನಾವು ಈ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಈಗಾಗಲೇ ಕಂಪೈಲ್ ಮಾಡಿದ ಆವೃತ್ತಿಯನ್ನು ವಿತರಿಸುವ ಸಿಸ್ಟಮ್ ಪ್ಯಾಕೇಜ್ ಆಗಿ ಸ್ಥಾಪಿಸುತ್ತೇವೆ, ಆದರೆ ಸೈಟ್‌ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಲಭ್ಯವಿರುವುದಕ್ಕಿಂತ ಸ್ವಲ್ಪ ಹಳೆಯದು:

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

ಮುಂದೆ, ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಮೂಲಕ ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಿ 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 ನೀವು ಅದನ್ನು ಟ್ಯುಟೋರಿಯಲ್‌ಗಳಲ್ಲಿ ಕಾಣಬಹುದು ಇಲ್ಲಿ

ಮತ್ತೇನು? ^

ನೀವು ಉಳಿದುಕೊಂಡು ಲೇಖನದ ಅಂತ್ಯವನ್ನು ತಲುಪಿದರೆ ಒಳ್ಳೆಯದು. ನಾನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಸ್ಥಾಪಿಸುವ ಲೇಖನದ ಕೊನೆಯಲ್ಲಿ ಸಿದ್ಧವಾದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪೋಸ್ಟ್ ಮಾಡಲಿಲ್ಲ ಜುಪಿಟರ್ ಲ್ಯಾಬ್ ಕಾರ್ಮಿಕರನ್ನು ಉತ್ತೇಜಿಸಲು "ಒಂದು ಕ್ಲಿಕ್" ನಲ್ಲಿ :) ಆದರೆ ನೀವು ಅದನ್ನು ನೀವೇ ಮಾಡಬಹುದು, ಏಕೆಂದರೆ ನೀವು ಈಗಾಗಲೇ ಹೇಗೆ ತಿಳಿದಿರುವಿರಿ, ಒಂದೇ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ :)

ನೀವು ಮಾಡಬಹುದು:

• ಕಂಟೇನರ್ ಅನ್ನು ಸರಳವಾಗಿ ಬರೆಯುವ ಮೂಲಕ 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