വ്യാഴത്തെ LXD ഭ്രമണപഥത്തിലേക്ക് വിക്ഷേപിക്കുന്നു

നിങ്ങൾ എപ്പോഴെങ്കിലും കോഡ് അല്ലെങ്കിൽ സിസ്റ്റം യൂട്ടിലിറ്റികളിൽ പരീക്ഷിച്ചിട്ടുണ്ടോ? Linux റൂട്ട് പ്രിവിലേജുകൾ ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കേണ്ട കോഡിൽ എന്തെങ്കിലും പിശക് സംഭവിച്ചാൽ, അടിസ്ഥാന സിസ്റ്റത്തെക്കുറിച്ച് വിഷമിക്കേണ്ടതില്ല, എല്ലാം നശിപ്പിക്കേണ്ടതില്ലല്ലോ?

ഒരു മെഷീനിൽ തന്നെ വൈവിധ്യമാർന്ന മൈക്രോസർവീസുകളുടെ ഒരു മുഴുവൻ ക്ലസ്റ്ററും പരീക്ഷിക്കുകയോ പ്രവർത്തിപ്പിക്കുകയോ ചെയ്യേണ്ടി വന്നാൽ എന്തുചെയ്യും? നൂറോ ആയിരമോ പോലും?

ഹൈപ്പർവൈസർ മാനേജ് ചെയ്യുന്ന വെർച്വൽ മെഷീനുകൾക്ക് അത്തരം പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ കഴിഞ്ഞേക്കും, പക്ഷേ എന്ത് വിലകൊടുത്ത്? ഉദാഹരണത്തിന്, ആൽപൈൻ വിതരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു LXD കണ്ടെയ്നർ Linux എല്ലാം വളരെ കുറച്ച് മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ 7.60MB RAM, സ്റ്റാർട്ടപ്പിനുശേഷം റൂട്ട് പാർട്ടീഷൻ എവിടെയാണ് ഉൾക്കൊള്ളുന്നത് 9.5MB! എലോൺ മസ്‌ക്, നിങ്ങൾക്ക് അത് എങ്ങനെ ഇഷ്ടപ്പെട്ടു? ഒന്ന് പരിശോധിക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു. എൽഎക്സ്ഡിയുടെ അടിസ്ഥാന കഴിവുകൾ - ഒരു കണ്ടെയ്നർ സിസ്റ്റം Linux

LXD കണ്ടെയ്‌നറുകൾ എന്താണെന്നതിനെക്കുറിച്ച് ഇപ്പോൾ നമുക്ക് ഒരു പൊതു ധാരണ ലഭിച്ചു, നമുക്ക് മുന്നോട്ട് പോകാം, ചിന്തിക്കാം: ഹോസ്റ്റ് ചെയ്‌ത കോഡ് സുരക്ഷിതമായി പ്രവർത്തിപ്പിക്കാനും, ഗ്രാഫുകൾ സൃഷ്ടിക്കാനും, ഡൈനാമിക് ആയി (ഇന്ററാക്ടീവ് ആയി) നിങ്ങളുടെ കോഡിലേക്ക് UI വിജറ്റുകൾ ലിങ്ക് ചെയ്യാനും, ടെക്സ്റ്റ്, ബ്ലാക്ക്‌ജാക്ക്, ഫോർമാറ്റിംഗ് എന്നിവ ഉപയോഗിച്ച് നിങ്ങളുടെ കോഡ് വർദ്ധിപ്പിക്കാനും കഴിയുന്ന ഒരു പ്ലാറ്റ്‌ഫോം ഉണ്ടായിരുന്നെങ്കിലോ? ഒരു ഇന്ററാക്ടീവ് ബ്ലോഗ് പോലെ എന്തെങ്കിലും ഉണ്ടോ? വൗ... എനിക്ക് അത് വേണം! എനിക്ക് അത് വേണം! 🙂

ഒരു കണ്ടെയ്നറിൽ ഞങ്ങൾ വിക്ഷേപിക്കുന്ന കട്ടിന് താഴെ നോക്കൂ. ജൂപ്പിറ്റർ ലാബ് — കാലഹരണപ്പെട്ട ജൂപ്പിറ്റർ നോട്ട്ബുക്കിന് പകരമായി വരുന്ന അടുത്ത തലമുറ ഉപയോക്തൃ ഇന്റർഫേസ്, കൂടാതെ പൈത്തൺ മൊഡ്യൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക, ഉദാഹരണത്തിന് നമ്പി, പാണ്ഡകൾ, മാറ്റ്‌പ്ലോട്ട്ലിബ്, IPyWidgets മുകളിൽ ലിസ്റ്റുചെയ്തിരിക്കുന്നതെല്ലാം ചെയ്യാനും അതെല്ലാം ഒരു പ്രത്യേക ഫയലിൽ സേവ് ചെയ്യാനും ഇത് നിങ്ങളെ അനുവദിക്കും - ഒരു IPython ലാപ്‌ടോപ്പ്.

നാവിഗേഷൻ

• ഓർബിറ്റൽ ടേക്ക് ഓഫ് പ്ലാൻ
• അടിസ്ഥാന സിസ്റ്റത്തിന്റെ ഇൻസ്റ്റാളേഷനും കോൺഫിഗറേഷനും
• അടിസ്ഥാന സോഫ്റ്റ്‌വെയർ ഇൻസ്റ്റാൾ ചെയ്യുകയും സിസ്റ്റം കോൺഫിഗർ ചെയ്യുകയും ചെയ്യുന്നു
• ജൂപ്പിറ്റർലാബ് ഇൻസ്റ്റാൾ ചെയ്യുകയും കോൺഫിഗർ ചെയ്യുകയും ചെയ്യുന്നു
• ഹോസ്റ്റുമായി ഡാറ്റ പങ്കിടുന്നു
• ഹലോ വേൾഡ്!
• പൈത്തണിന്റെ കഴിവുകൾ വികസിപ്പിക്കുന്നു
• ജൂപ്പിറ്റർലാബിൽ മൊഡ്യൂളുകൾ പരിശോധിക്കുന്നു
• പിന്നെ എന്തുണ്ട്?

ഓർബിറ്റൽ ടേക്ക് ഓഫ് പ്ലാൻ ^

മുകളിൽ പറഞ്ഞ പദ്ധതി നടപ്പിലാക്കുന്നത് എളുപ്പമാക്കുന്നതിന് ഒരു ചെറിയ പ്രവർത്തന പദ്ധതി നമുക്ക് രൂപപ്പെടുത്താം:

• വിതരണത്തെ അടിസ്ഥാനമാക്കി ഒരു കണ്ടെയ്നർ ഇൻസ്റ്റാൾ ചെയ്ത് പ്രവർത്തിപ്പിക്കാം. ആൽപൈൻ Linuxഈ വിതരണം മിനിമലിസത്തിനായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നതിനാൽ ഞങ്ങൾ ഉപയോഗിക്കും, കൂടാതെ ഏറ്റവും അത്യാവശ്യമായ സോഫ്റ്റ്‌വെയർ മാത്രമേ ഞങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യൂ, അധികമൊന്നും ഉപയോഗിക്കില്ല.
• കണ്ടെയ്‌നറിലേക്ക് ഒരു അധിക വെർച്വൽ ഡിസ്ക് ചേർത്ത് അതിന് ഒരു പേര് നൽകാം - hostfs റൂട്ട് ഫയൽ സിസ്റ്റത്തിലേക്ക് മൗണ്ട് ചെയ്യുക. കണ്ടെയ്‌നറിനുള്ളിലെ ഒരു നിർദ്ദിഷ്ട ഡയറക്‌ടറിയിൽ നിന്ന് ഹോസ്റ്റിലെ ഫയലുകൾ ഉപയോഗിക്കാൻ ഈ ഡിസ്ക് ഞങ്ങളെ അനുവദിക്കും. കണ്ടെയ്‌നറിൽ നിന്ന് ഡാറ്റ സ്വതന്ത്രമാണെന്ന് ഇത് ഉറപ്പാക്കും. കണ്ടെയ്‌നർ ഇല്ലാതാക്കിയാൽ, ഡാറ്റ ഹോസ്റ്റിൽ തന്നെ തുടരും. കണ്ടെയ്‌നർ ഡിസ്ട്രിബ്യൂഷന്റെ നേറ്റീവ് നെറ്റ്‌വർക്കിംഗ് മെക്കാനിസങ്ങൾ ഉപയോഗിക്കാതെ ഒന്നിലധികം കണ്ടെയ്‌നറുകൾക്കിടയിൽ ഒരേ ഡാറ്റ പങ്കിടുന്നതിനും ഈ സ്കീം ഉപയോഗപ്രദമാണ്.
• നമ്മൾ ബാഷ്, സുഡോ, ആവശ്യമായ ലൈബ്രറികൾ എന്നിവ ഇൻസ്റ്റാൾ ചെയ്യുകയും ഒരു സിസ്റ്റം ഉപയോക്താവിനെ ചേർക്കുകയും കോൺഫിഗർ ചെയ്യുകയും ചെയ്യും.
• നമുക്ക് പൈത്തൺ, മൊഡ്യൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്ത് അവയ്ക്കായി ബൈനറി ഡിപൻഡൻസികൾ കംപൈൽ ചെയ്യാം.
• നമുക്ക് ഇൻസ്റ്റാൾ ചെയ്ത് പ്രവർത്തിപ്പിക്കാം ജൂപ്പിറ്റർ ലാബ്, ഞങ്ങൾ രൂപം ഇഷ്ടാനുസൃതമാക്കുകയും അതിനായി വിപുലീകരണങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുകയും ചെയ്യും.

ഈ ലേഖനത്തിൽ, നമ്മൾ ഒരു കണ്ടെയ്നർ സമാരംഭിച്ചുകൊണ്ട് തുടങ്ങും. 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

ഇത് എനിക്ക് HDD ഡിസ്കിലെ കണ്ടെയ്നറുകളിൽ പരീക്ഷണം നടത്താനും SSD ഡിസ്കിലെ റിസോഴ്‌സുകൾ സംരക്ഷിക്കാനും അവസരം നൽകുന്നു, അതും എന്റെ സിസ്റ്റത്തിലുണ്ട് :) ഇതിനായി ഞാൻ ഒരു പ്രത്യേക കോൺഫിഗറേഷൻ പ്രൊഫൈൽ സൃഷ്ടിച്ചിട്ടുണ്ട്. ssdroot.

ഒരു കണ്ടെയ്നർ സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, അത് അവസ്ഥയിലാണ് STOPPED, അതിനാൽ നമ്മൾ അതിൽ init സിസ്റ്റം പ്രവർത്തിപ്പിച്ച് അത് ആരംഭിക്കേണ്ടതുണ്ട്:

lxc start jupyterlab

കീ ഉപയോഗിച്ച് LXD-യിലെ കണ്ടെയ്‌നറുകൾ ലിസ്റ്റ് ചെയ്യാം. -c ഏത് സൂചിപ്പിക്കുന്നു cസ്ക്രീനിൽ olumns പ്രദർശിപ്പിക്കും:

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

കണ്ടെയ്നർ സൃഷ്ടിക്കുമ്പോൾ, ഞങ്ങൾ ഒരു കോൺഫിഗറേഷൻ പ്രൊഫൈൽ ഉപയോഗിച്ചതിനാൽ ഐപി വിലാസം ക്രമരഹിതമായി തിരഞ്ഞെടുത്തു. default ഇത് മുമ്പ് ലേഖനത്തിൽ ക്രമീകരിച്ചിരുന്നു ഒരു കണ്ടെയ്നർ സിസ്റ്റമായ എൽഎക്സ്ഡിയുടെ അടിസ്ഥാന കഴിവുകൾ Linux.

നിലവിലെ കോൺഫിഗറേഷനിൽ നിലവിലുള്ളതുപോലെ കോൺഫിഗറേഷൻ പ്രൊഫൈൽ തലത്തിലല്ല, മറിച്ച് കണ്ടെയ്‌നർ തലത്തിൽ നെറ്റ്‌വർക്ക് ഇന്റർഫേസ് സൃഷ്ടിച്ചുകൊണ്ട് ഈ ഐപി വിലാസം കൂടുതൽ അവിസ്മരണീയമായ ഒന്നാക്കി മാറ്റും. ഇത് ആവശ്യമില്ല; നിങ്ങൾക്ക് ഇത് ഒഴിവാക്കാം.

ഒരു നെറ്റ്‌വർക്ക് ഇന്റർഫേസ് സൃഷ്ടിക്കുന്നു 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      |
+------------+---------+------------------+--------------+

അടിസ്ഥാന സോഫ്റ്റ്‌വെയർ ഇൻസ്റ്റാൾ ചെയ്യുകയും സിസ്റ്റം കോൺഫിഗർ ചെയ്യുകയും ചെയ്യുന്നു ^

ഞങ്ങളുടെ കണ്ടെയ്നർ കൈകാര്യം ചെയ്യുന്നതിന്, നിങ്ങൾ ഇനിപ്പറയുന്ന സോഫ്റ്റ്‌വെയർ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്:

പാക്കേജ്
വിവരണം

ബാഷ്
ഗ്നു ബോൺ എഗെയ്ൻ ഷെൽ

ബാഷ്-പൂർത്തിയാക്കൽ
ബാഷ് ഷെല്ലിനുള്ള പ്രോഗ്രാം ചെയ്യാവുന്ന പൂർത്തീകരണം

സുഡോ
ചില ഉപയോക്താക്കൾക്ക് റൂട്ട് ആയി ചില കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാനുള്ള കഴിവ് നൽകുക.

നിഴൽ
ഷാഡോ ഫയലുകൾക്കും PAM-നും പിന്തുണയുള്ള പാസ്‌വേഡ്, അക്കൗണ്ട് മാനേജ്‌മെന്റ് ടൂൾ സ്യൂട്ട്.

ടിഎസ്ഡാറ്റ
സമയ മേഖല, പകൽ വെളിച്ച സംരക്ഷണ സമയ ഡാറ്റ എന്നിവയുടെ ഉറവിടങ്ങൾ

നാനോ
മെച്ചപ്പെടുത്തലുകളുള്ള പിക്കോ എഡിറ്റർ ക്ലോൺ

കൂടാതെ, താഴെ പറയുന്ന പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്തുകൊണ്ട് നിങ്ങൾക്ക് മാൻ-പേജുകൾ സിസ്റ്റത്തിൽ പിന്തുണ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും: 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 — ആൽപൈൻ ഡിസ്ട്രിബ്യൂഷൻ പാക്കേജ് മാനേജർ 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

കണ്ടെയ്‌നറിൽ പുതിയ ഉപയോക്താക്കൾക്കായി ബാഷ് സജ്ജീകരിക്കുന്നതിനുള്ള സമയം ലാഭിക്കുന്നതിന്, ഹോസ്റ്റ് സിസ്റ്റത്തിൽ നിന്ന് റെഡിമെയ്ഡ് സ്കെൽ ഫയലുകൾ ഞങ്ങൾ അതിലേക്ക് പകർത്തും. ഇത് കണ്ടെയ്‌നറിൽ ഇന്ററാക്ടീവ് മോഡിൽ ബാഷ് ഇഷ്ടാനുസൃതമാക്കാൻ ഞങ്ങളെ അനുവദിക്കും. എന്റെ ഹോസ്റ്റ് സിസ്റ്റം മഞ്ചാരോ ആണ്. Linux ഫയലുകൾ പകർത്തി /etc/skel/.bash_profile, /etc/skel/.bashrc, /etc/skel/.dir_colors തത്വത്തിൽ, അവ ആൽപൈനിന് അനുയോജ്യമാണ് Linux ഗുരുതരമായ പ്രശ്നങ്ങൾ ഉണ്ടാക്കുന്നില്ല, പക്ഷേ നിങ്ങൾക്ക് വ്യത്യസ്തമായ ഒരു വിതരണം ഉണ്ടായിരിക്കാം, കണ്ടെയ്നറിൽ ബാഷ് പ്രവർത്തിപ്പിക്കുന്നതിൽ ഒരു പിശക് ഉണ്ടെങ്കിൽ നിങ്ങൾ സ്വയം കണ്ടെത്തേണ്ടതുണ്ട്.

സ്കെൽ ഫയലുകൾ കണ്ടെയ്നറിലേക്ക് പകർത്തുക. കീ --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

ആൽപൈനിൽ Linux ഉപയോക്താക്കൾക്കായി ഒരു സിസ്റ്റം ഷെൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്. /bin/sh, ഞങ്ങൾ അത് മാറ്റിസ്ഥാപിക്കും root ബാഷ് ഉപയോക്താവ്:

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"

ജൂപ്പിറ്റർലാബ് ഇൻസ്റ്റാൾ ചെയ്യുകയും കോൺഫിഗർ ചെയ്യുകയും ചെയ്യുന്നു ^

ജൂപ്പിറ്റർ ലാബ് — ഇതൊരു പൈത്തൺ ആപ്ലിക്കേഷനാണ്, അതിനാൽ നമ്മൾ ആദ്യം ഈ ഇന്റർപ്രെറ്റർ ഇൻസ്റ്റാൾ ചെയ്യണം. കൂടാതെ, ജൂപ്പിറ്റർ ലാബ് പൈത്തൺ പാക്കേജ് മാനേജർ ഉപയോഗിച്ചാണ് നമ്മൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നത്. 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 തുറക്കുന്ന പേജിൽ, നൽകുക ടോക്കൺ കൺസോളിൽ നിങ്ങൾ കാണുന്ന ആക്‌സസ്. അത് പകർത്തി പേജിൽ ഒട്ടിക്കുക, തുടർന്ന് ക്ലിക്കുചെയ്യുക ലോഗിൻലോഗിൻ ചെയ്തതിനുശേഷം, താഴെയുള്ള ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ഇടതുവശത്തുള്ള എക്സ്റ്റൻഷൻ മെനുവിലേക്ക് പോകുക, എക്സ്റ്റൻഷൻ മാനേജർ സജീവമാക്കുമ്പോൾ മൂന്നാം കക്ഷി എക്സ്റ്റൻഷനുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന്റെ സുരക്ഷാ അപകടസാധ്യതകൾ അംഗീകരിക്കാൻ നിങ്ങളോട് ആവശ്യപ്പെടും, അതിനായി കമാൻഡ് ജൂപ്പിറ്റർലാബ് വികസനം ബാധ്യതയുള്ളതല്ല:

എന്നിരുന്നാലും, ഈ ഉദ്ദേശ്യത്തിനായി ഞങ്ങൾ മുഴുവൻ കാര്യവും ഒറ്റപ്പെടുത്തുകയാണ്. ജൂപ്പിറ്റർ ലാബ് NodeJS ആവശ്യപ്പെടുന്നതും ഉപയോഗിക്കുന്നതുമായ മൂന്നാം കക്ഷി എക്സ്റ്റെൻഷനുകൾ ഡിസ്കിലെ ഡാറ്റ മോഷ്ടിക്കുന്നത് തടയാൻ, കുറഞ്ഞത്, കണ്ടെയ്നറിനുള്ളിൽ തുറക്കുന്നവ ഒഴികെ, ഒരു കണ്ടെയ്നറിൽ വയ്ക്കുക. ഹോസ്റ്റിലെ നിങ്ങളുടെ സ്വകാര്യ പ്രമാണങ്ങൾ ആക്സസ് ചെയ്യുന്നു. /home കണ്ടെയ്‌നറിൽ നിന്നുള്ള പ്രോസസ്സുകൾക്ക് ഇത് ചെയ്യാൻ കഴിയില്ല, അങ്ങനെ ചെയ്താൽ പോലും, ഹോസ്റ്റ് സിസ്റ്റത്തിലെ ഫയലുകളിൽ നിങ്ങൾക്ക് പ്രത്യേകാവകാശങ്ങൾ ഉണ്ടായിരിക്കേണ്ടതുണ്ട്, കാരണം ഞങ്ങൾ കണ്ടെയ്‌നർ പ്രവർത്തിപ്പിക്കുന്നത് അൺപ്രിവിലേജ്ഡ് മോഡ്ഈ വിവരങ്ങളുടെ അടിസ്ഥാനത്തിൽ, എക്സ്റ്റൻഷനുകൾ ഉൾപ്പെടുത്തുന്നതിന്റെ അപകടസാധ്യത നിങ്ങൾക്ക് വിലയിരുത്താൻ കഴിയും ജൂപ്പിറ്റർ ലാബ്.

IPython നോട്ട്ബുക്കുകൾ സൃഷ്ടിച്ചു (പേജുകൾ ജൂപ്പിറ്റർ ലാബ്) ഇപ്പോൾ ഉപയോക്താവിന്റെ ഹോം ഡയറക്ടറിയിൽ സൃഷ്ടിക്കപ്പെടും - /home/jupyter, പക്ഷേ ഹോസ്റ്റിനും കണ്ടെയ്‌നറിനും ഇടയിൽ ഡാറ്റ (പങ്കിടൽ) വിഭജിക്കാൻ ഞങ്ങൾ പദ്ധതിയിടുന്നു, അതിനാൽ കൺസോളിലേക്ക് തിരികെ പോയി നിർത്തുക ജൂപ്പിറ്റർ ലാബ് ഹോട്ട്കീ എക്സിക്യൂട്ട് ചെയ്യുന്നതിലൂടെ — CTRL+C ഉത്തരം നൽകി y അഭ്യർത്ഥനയിലേക്ക്. തുടർന്ന് ഉപയോക്താവിന്റെ സംവേദനാത്മക സെഷൻ അവസാനിപ്പിക്കുക. jupyter ഒരു ഹോട്ട്കീ പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ 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, അധ്യായം കാണുക സുരക്ഷ. കണ്ടെയ്നർ പ്രിവിലേജുകൾ ലേഖനത്തിൽ ഒരു കണ്ടെയ്നർ സിസ്റ്റമായ എൽഎക്സ്ഡിയുടെ അടിസ്ഥാന കഴിവുകൾ 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 അല്ലെങ്കിൽ മുകളിലുള്ള ടൂൾബാറിലെ "പ്ലേ" ബട്ടൺ അമർത്തി ജൂപ്പിറ്റർലാബിനെ ഇത് ചെയ്യാൻ അനുവദിക്കുക:

ഈ ഘട്ടത്തിൽ, മിക്കവാറും എല്ലാം ഉപയോഗത്തിന് തയ്യാറാണ്, പക്ഷേ പൈത്തണിന്റെ സ്റ്റാൻഡേർഡ് കഴിവുകൾ ഗണ്യമായി വികസിപ്പിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്ന അധിക പൈത്തൺ മൊഡ്യൂളുകൾ (പൂർണ്ണ ആപ്ലിക്കേഷനുകൾ) ഇൻസ്റ്റാൾ ചെയ്തില്ലെങ്കിൽ അത് താൽപ്പര്യമുള്ളതല്ല. ജൂപ്പിറ്റർ ലാബ്, അതുകൊണ്ട് നമുക്ക് മുന്നോട്ട് പോകാം 🙂

പി.എസ്. രസകരമായ കാര്യം, പഴയ നടപ്പിലാക്കൽ വ്യാഴം ഒരു കോഡ് നാമത്തിൽ ജൂപ്പിറ്റർ നോട്ട്ബുക്ക് എവിടെയും പോയിട്ടില്ല, അത് സമാന്തരമായി നിലനിൽക്കുന്നു ജൂപ്പിറ്റർ ലാബ്പഴയ പതിപ്പിലേക്ക് മാറാൻ, വിലാസത്തിൽ പ്രത്യയം ചേർത്ത് ലിങ്ക് പിന്തുടരുക./tree, പുതിയ പതിപ്പിലേക്കുള്ള മാറ്റം പ്രത്യയം ഉപയോഗിച്ചാണ് നടത്തുന്നത് /lab, പക്ഷേ അത് വ്യക്തമാക്കേണ്ടതില്ല:

• ജൂപ്പിറ്റർ നോട്ട്ബുക്ക് — http://10.0.5.5:8888/tree
• ജൂപ്പിറ്റർ ലാബ് — http://10.0.5.5:8888/lab

പൈത്തണിന്റെ കഴിവുകൾ വികസിപ്പിക്കുന്നു ^

ഈ വിഭാഗത്തിൽ, നമ്മൾ ശക്തമായ പൈത്തൺ മൊഡ്യൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്യും, ഉദാഹരണത്തിന് നമ്പി, പാണ്ഡകൾ, മാറ്റ്‌പ്ലോട്ട്ലിബ്, IPyWidgets ആരുടെ ജോലിയുടെ ഫലങ്ങൾ ലാപ്‌ടോപ്പുകളിൽ സംയോജിപ്പിച്ചിരിക്കുന്നു ജൂപ്പിറ്റർ ലാബ്.

ഒരു പാക്കേജ് മാനേജർ വഴി ലിസ്റ്റുചെയ്തിരിക്കുന്ന പൈത്തൺ മൊഡ്യൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന് മുമ്പ് pip നമ്മൾ ആദ്യം ആൽപൈനിലെ സിസ്റ്റം ഡിപൻഡൻസികൾ പരിഹരിക്കണം. Linux:

• g++ — മൊഡ്യൂളുകളിൽ ചിലത് ഭാഷയിൽ നടപ്പിലാക്കിയിരിക്കുന്നതിനാൽ, അവ കംപൈൽ ചെയ്യേണ്ടത് ആവശ്യമാണ്. സി ++ കൂടാതെ റൺടൈമിൽ പൈത്തണുമായി ബൈനറി മൊഡ്യൂളുകളായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.
• freetype-dev — പൈത്തൺ മൊഡ്യൂളിനുള്ള ആശ്രിതത്വം മാറ്റ്‌പ്ലോട്ട്ലിബ്

ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു:

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

ആൽപൈൻ വിതരണത്തിന്റെ നിലവിലെ അവസ്ഥയിൽ ഒരു പ്രശ്നമുണ്ട്. Linux എനിക്ക് 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/*

ജൂപ്പിറ്റർലാബിൽ മൊഡ്യൂളുകൾ പരിശോധിക്കുന്നു ^

നിങ്ങൾ അത് പ്രവർത്തിപ്പിച്ചാൽ ജൂപ്പിറ്റർ ലാബ്, പുതുതായി ഇൻസ്റ്റാൾ ചെയ്ത മൊഡ്യൂളുകൾ സജീവമാകുന്നതിനായി അത് പുനരാരംഭിക്കുക. ഇത് ചെയ്യുന്നതിന്, കൺസോൾ സെഷനിൽ, അമർത്തുക 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 ഡെവലപ്പർ വെബ്സൈറ്റിൽ കൂടുതൽ വിവരങ്ങൾ നേടുക.
• ഡിസൈൻ തീം മാറ്റുക:

നിങ്ങൾക്ക് ഇനിയും ഒരുപാട് കാര്യങ്ങൾ ചെയ്യാനുണ്ട്! ഇപ്പോൾ അത്രയേയുള്ളൂ. നിങ്ങൾക്ക് വിജയം ആശംസിക്കുന്നു!

അപ്ഡേറ്റ്: 04/15/2020 6:30 PM — "ഹലോ, വേൾഡ്!" എന്ന അധ്യായത്തിലെ പിശകുകൾ പരിഹരിച്ചു.
അപ്ഡേറ്റ്: ഏപ്രിൽ 16, 2020, 10:00 AM — എക്സ്റ്റൻഷൻ മാനേജർ ആക്ടിവേഷൻ വിവരണത്തിൽ വാചകം തിരുത്തി ചേർത്തു. ജൂപ്പിറ്റർ ലാബ്
അപ്‌ഡേറ്റ്: ഏപ്രിൽ 16, 2020, 10:40 AM — വാചകത്തിൽ കണ്ടെത്തിയ പിശകുകൾ തിരുത്തി, "അടിസ്ഥാന സോഫ്റ്റ്‌വെയർ ഇൻസ്റ്റാൾ ചെയ്യുകയും സിസ്റ്റം കോൺഫിഗർ ചെയ്യുകയും ചെയ്യുന്നു" എന്ന അധ്യായം ചെറുതായി മെച്ചപ്പെടുത്തി.

അവലംബം: www.habr.com