എൽഎക്സ്ഡി അടുത്ത തലമുറ സിസ്റ്റം കണ്ടെയ്‌നർ മാനേജരാണ്, അങ്ങനെ പറയുന്നു ഉറവിടംവെർച്വൽ മെഷീനുകൾക്ക് സമാനമായ ഒരു യൂസർ ഇന്റർഫേസ് ഇത് വാഗ്ദാനം ചെയ്യുന്നു, പക്ഷേ പകരം കണ്ടെയ്‌നറുകൾ ഉപയോഗിക്കുന്നു. Linux.

LXD കോർ ഒരു പ്രാദേശിക യുണിക്സ് സോക്കറ്റ് വഴിയും ഉചിതമായ കോൺഫിഗറേഷൻ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ നെറ്റ്‌വർക്ക് വഴിയും ഒരു REST API നൽകുന്ന ഒരു പ്രത്യേക ഡെമൺ (റൂട്ട് അവകാശങ്ങളോടെ പ്രവർത്തിക്കുന്ന ഒരു സേവനം) ആണ്. LXD-യ്‌ക്കൊപ്പം നൽകിയിരിക്കുന്ന കമാൻഡ് ലൈൻ ടൂൾ പോലുള്ള ക്ലയന്റുകൾ ഈ REST API വഴി അഭ്യർത്ഥനകൾ നടത്തുന്നു. ഇതിനർത്ഥം നിങ്ങൾ ആക്സസ് ചെയ്യുന്നത് ഒരു ലോക്കൽ ഹോസ്റ്റോ റിമോട്ട് ഹോസ്റ്റോ ആകട്ടെ, എല്ലാം ഒരേപോലെ പ്രവർത്തിക്കുന്നു.

ഈ ലേഖനത്തിൽ, LXD ആശയങ്ങളെക്കുറിച്ചോ ഡോക്യുമെന്റേഷനിൽ വിവരിച്ചിരിക്കുന്ന ലഭ്യമായ എല്ലാ സവിശേഷതകളെക്കുറിച്ചോ നമ്മൾ വിശദമായി പറയില്ല, LXD യുടെ ഏറ്റവും പുതിയ പതിപ്പുകളിൽ കണ്ടെയ്‌നറുകൾക്കൊപ്പം QEMU വെർച്വൽ മെഷീൻ പിന്തുണയുടെ സമീപകാല നടപ്പാക്കൽ ഉൾപ്പെടെ. പകരം, കണ്ടെയ്‌നർ മാനേജ്‌മെന്റിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ - സ്റ്റോറേജ് പൂളുകളും നെറ്റ്‌വർക്കിംഗും സജ്ജീകരിക്കൽ, ഒരു കണ്ടെയ്‌നർ സമാരംഭിക്കൽ, റിസോഴ്‌സ് പരിധികൾ പ്രയോഗിക്കൽ, സ്‌നാപ്പ്‌ഷോട്ടുകൾ ഉപയോഗിക്കൽ - ഞങ്ങൾ ഉൾപ്പെടുത്തും, അതുവഴി നിങ്ങൾക്ക് LXD യെക്കുറിച്ച് അടിസ്ഥാനപരമായ ധാരണ നേടാനും നിങ്ങളുടെ പരിതസ്ഥിതിയിൽ കണ്ടെയ്‌നറുകൾ ഉപയോഗിക്കാനും കഴിയും. Linux.

പൂർണ്ണമായ വിവരങ്ങൾക്ക്, ദയവായി ഔദ്യോഗിക ഉറവിടം കാണുക:

• ഡെവലപ്പറുടെ വെബ്സൈറ്റ്
• ഡോക്യുമെന്റേഷൻ
• ഫോറം

നാവിഗേഷൻ

• ഇൻസ്റ്റലേഷൻ LXD
  • വിതരണങ്ങളിൽ LXD ഇൻസ്റ്റാൾ ചെയ്യുന്നു Ubuntu
  • ആർച്ച് ഡിസ്ട്രിബ്യൂഷനുകളിൽ LXD ഇൻസ്റ്റാൾ ചെയ്യുന്നു Linux
• സംഭരണം LXD (സംഭരണം)
• LXD ആരംഭിക്കുന്നു
  • സ്റ്റോറേജ് പൂളിനായി ഒരു ഫയൽ സിസ്റ്റം തിരഞ്ഞെടുക്കുന്നു
  • വിസാർഡ് ഉപയോഗിച്ച് നെറ്റ്‌വർക്കും സ്റ്റോറേജ് പൂളും ആരംഭിക്കുന്നു
  • ഒരു അധിക സ്റ്റോറേജ് പൂൾ സൃഷ്ടിക്കുന്നു
    • സ്റ്റോറേജ് പൂൾ വലുപ്പം വർദ്ധിപ്പിക്കുന്നു
    • ഒരു ലൂപ്പ്ബാക്ക് ഉപകരണ സ്ലോട്ടിലേക്ക് ഒരു ലൂപ്പ്ബാക്ക് ഫയൽ സ്വയമേവ ചേർക്കൽ
  • സുരക്ഷ. കണ്ടെയ്നർ പ്രത്യേകാവകാശങ്ങൾ
  • ഒരു വെർച്വൽ നെറ്റ്‌വർക്ക് സ്വിച്ച് സൃഷ്‌ടിക്കുന്നു
  • കോൺഫിഗറേഷൻ പ്രൊഫൈൽ
    • നിങ്ങളുടെ പ്രൊഫൈൽ എഡിറ്റുചെയ്യുന്നു
    • പുതിയ പ്രൊഫൈലുകൾ സൃഷ്ടിക്കുന്നു
  • ചിത്ര ശേഖരം
    • റിമോട്ട് ഇമേജ് റിപ്പോസിറ്ററികൾ
    • പ്രാദേശിക ചിത്ര ശേഖരം
  • LXD കോൺഫിഗറേഷൻ
• ഒരു കണ്ടെയ്നർ സൃഷ്ടിക്കുകയും കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു
  • ഒരു സ്റ്റാറ്റിക് ഐപി വിലാസം സജ്ജീകരിക്കുന്നു
  • ഒരു കണ്ടെയ്നർ നീക്കംചെയ്യുന്നു
  • കണ്ടെയ്നർ ആക്സസ്
  • കണ്ടെയ്നർ റിസോഴ്സ് മാനേജ്മെന്റ്
    • റാം റിസോഴ്സ് പരിമിതി
    • CPU റിസോഴ്സ് പരിധി
    • ഡിസ്ക് സ്ഥല പരിമിതി
    • വിഭവ ഉപഭോഗ സ്ഥിതിവിവരക്കണക്കുകൾ
  • സ്നാപ്പ്ഷോട്ടുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു

ഇൻസ്റ്റലേഷൻ LXD ^

വിതരണങ്ങളിൽ LXD ഇൻസ്റ്റാൾ ചെയ്യുന്നു Ubuntu ^

വിതരണത്തിൽ Ubuntu 19.10 പാക്കേജ് lxd ഒരു പ്രക്ഷേപണം ഉണ്ട് സ്നാപ്പ് പാക്കേജ്:

apt search lxd

lxd/eoan 1:0.7 all
  Transitional package - lxd -> snap (lxd)

ഇതിനർത്ഥം രണ്ട് പാക്കേജുകൾ ഒരേസമയം ഇൻസ്റ്റാൾ ചെയ്യപ്പെടും, ഒന്ന് സിസ്റ്റം പാക്കേജായും മറ്റൊന്ന് സ്നാപ്പ് പാക്കേജായും. സ്‌നാപ്പ് പാക്കേജ് മാനേജർ സ്‌നാപ്പ് പാക്കേജ് നീക്കം ചെയ്‌താൽ, ഒരു സിസ്റ്റത്തിൽ രണ്ട് പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നത് ചില പ്രശ്‌നങ്ങൾ സൃഷ്‌ടിച്ചേക്കാം.

പാക്കേജ് കണ്ടെത്തുക lxd സ്നാപ്പ് റിപ്പോസിറ്ററിയിൽ നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിക്കാം:

snap find lxd

Name             Version        Summary
lxd              3.21           System container manager and API
lxd-demo-server  0+git.6d54658  Online software demo sessions using LXD
nova             ocata          OpenStack Compute Service (nova)
nova-hypervisor  ocata          OpenStack Compute Service - KVM Hypervisor (nova)
distrobuilder    1.0            Image builder for LXC and LXD
fabrica          0.1            Build snaps by simply pointing a web form to...
satellite        0.1.2          Advanced scalable Open source intelligence platform

കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ list നിങ്ങൾക്ക് പാക്കേജ് ഉറപ്പാക്കാൻ കഴിയും lxd ഇതുവരെ ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ല:

snap list

Name  Version    Rev   Tracking  Publisher   Notes
core  16-2.43.3  8689  stable    canonical✓  core

LXD ഒരു സ്നാപ്പ് പാക്കേജ് ആണെങ്കിലും, അത് സിസ്റ്റം പാക്കേജ് വഴി ഇൻസ്റ്റാൾ ചെയ്യണം lxd, ഇത് സിസ്റ്റത്തിൽ അനുബന്ധ ഗ്രൂപ്പ് സൃഷ്ടിക്കും, ആവശ്യമായ യൂട്ടിലിറ്റികൾ /usr/bin അതുപോലെ.

sudo apt update
sudo apt install lxd

പാക്കേജ് ഒരു സ്നാപ്പ് പാക്കേജായി ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കാം:

snap list

Name  Version    Rev    Tracking  Publisher   Notes
core  16-2.43.3  8689   stable    canonical✓  core
lxd   3.21       13474  stable/…  canonical✓  -

ആർച്ച് ഡിസ്ട്രിബ്യൂഷനുകളിൽ LXD ഇൻസ്റ്റാൾ ചെയ്യുന്നു Linux ^

സിസ്റ്റത്തിൽ LXD പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന്, നിങ്ങൾ ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്, ആദ്യത്തേത് റിപ്പോസിറ്ററിയിൽ ലഭ്യമായ സിസ്റ്റത്തിലെ പാക്കേജുകളുടെ ലിസ്റ്റ് അപ്ഡേറ്റ് ചെയ്യും, രണ്ടാമത്തേത് പാക്കേജ് നേരിട്ട് ഇൻസ്റ്റാൾ ചെയ്യും:

sudo pacman -Syyu && sudo pacman -S lxd

പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, ഒരു സാധാരണ ഉപയോക്താവിന് LXD നിയന്ത്രിക്കുന്നതിന്, അത് സിസ്റ്റം ഗ്രൂപ്പിലേക്ക് ചേർക്കേണ്ടതാണ് lxd:

sudo usermod -a -G lxd user1

ഉപയോക്താവിനെ ഉറപ്പാക്കാം user1 ഗ്രൂപ്പിൽ ചേർത്തു lxd:

id -Gn user1

user1 adm dialout cdrom floppy sudo audio dip video plugdev netdev lxd

ഗ്രൂപ്പ് ആണെങ്കിൽ lxd ലിസ്റ്റിൽ ദൃശ്യമല്ല, തുടർന്ന് നിങ്ങൾ ഉപയോക്തൃ സെഷൻ വീണ്ടും സജീവമാക്കേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ലോഗ് ഔട്ട് ചെയ്യുകയും അതേ ഉപയോക്താവിന് കീഴിൽ ലോഗിൻ ചെയ്യുകയും വേണം.

സജീവമാക്കുക systemd സിസ്റ്റം സ്റ്റാർട്ടപ്പിൽ LXD സേവനം ലോഡ് ചെയ്യുന്നു:

sudo systemctl enable lxd

നമുക്ക് സേവനം ആരംഭിക്കാം:

sudo systemctl start lxd

സേവന നില പരിശോധിക്കുന്നു:

sudo systemctl status lxd

സംഭരണം LXD (സംഭരണം) ^

സമാരംഭം ആരംഭിക്കുന്നതിന് മുമ്പ്, LXD-യിലെ സംഭരണം എങ്ങനെയാണ് യുക്തിസഹമായി ക്രമീകരിച്ചിരിക്കുന്നതെന്ന് നമ്മൾ മനസ്സിലാക്കേണ്ടതുണ്ട്.

സംഭരണം (ശേഖരണം) ഉൾക്കൊള്ളുന്നു ഒന്നോ അതിലധികമോ മുതൽ സംഭരണ ​​കുളം ZFS, BTRFS, LVM അല്ലെങ്കിൽ റെഗുലർ ഡയറക്‌ടറികൾ പോലുള്ള പിന്തുണയ്‌ക്കുന്ന ഫയൽ സിസ്റ്റങ്ങളിൽ ഒന്ന് ഉപയോഗിക്കുന്നു. ഓരോ സംഭരണ ​​കുളം വോള്യങ്ങളായി തിരിച്ചിരിക്കുന്നു (സംഭരണ ​​വോളിയം) മറ്റ് ആവശ്യങ്ങൾക്കായി ചിത്രങ്ങൾ, കണ്ടെയ്നറുകൾ അല്ലെങ്കിൽ ഡാറ്റ അടങ്ങിയിരിക്കുന്നു.

• ചിത്രങ്ങൾ — ഇവ കേർണൽ ഇല്ലാതെ പ്രത്യേകം സമാഹരിച്ച വിതരണങ്ങളാണ്. Linux ബാഹ്യ സ്രോതസ്സുകളിൽ നിന്ന് ആക്‌സസ് ചെയ്യാവുന്നതും
• കണ്ടെയ്നറുകൾ - ഇവ ചിത്രങ്ങളിൽ നിന്നുള്ള വിതരണങ്ങളാണ്, ഉപയോഗത്തിന് തയ്യാറാണ്
• സ്നാപ്പ്ഷോട്ടുകൾ - നിങ്ങൾക്ക് മടങ്ങാൻ കഴിയുന്ന കണ്ടെയ്നറുകളുടെ അവസ്ഥയുടെ സ്നാപ്പ്ഷോട്ടുകളാണിത്

LXD-ൽ സംഭരണം നിയന്ത്രിക്കുന്നതിന്, കമാൻഡ് ഉപയോഗിക്കുക lxc storage കീ വ്യക്തമാക്കിയുകൊണ്ട് നിങ്ങൾക്ക് നേടാനാകുന്ന ഒരു സർട്ടിഫിക്കറ്റ് - lxc storage --help

ഇനിപ്പറയുന്ന കമാൻഡ് എല്ലാറ്റിന്റെയും ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുന്നു സംഭരണ ​​കുളം LXD സംഭരണത്തിൽ:

lxc storage list

+---------+-------------+--------+--------------------------------+---------+
|  NAME   | DESCRIPTION | DRIVER |             SOURCE             | USED BY |
+---------+-------------+--------+--------------------------------+---------+
| hddpool |             | btrfs  | /dev/loop1                     | 2       |
+---------+-------------+--------+--------------------------------+---------+
| ssdpool |             | btrfs  | /var/lib/lxd/disks/ssdpool.img | 4       |
+---------+-------------+--------+--------------------------------+---------+

എല്ലാവരുടെയും ഒരു ലിസ്റ്റ് കാണുന്നതിന് സംഭരണ ​​വോളിയം തിരഞ്ഞെടുത്തതിൽ സംഭരണ ​​കുളം ടീമിനെ സേവിക്കുന്നു lxc storage volume list:

lxc storage volume list hddpool

+-------+----------------------------------+-------------+---------+
| TYPE  |          NAME                    | DESCRIPTION | USED BY |
+-------+----------------------------------+-------------+---------+
| image | ebd565585223487526ddb3607f515... |             | 1       |
+-------+----------------------------------+-------------+---------+

lxc storage volume list ssdpool

+-----------+----------------------------------+-------------+---------+
|   TYPE    |            NAME                  | DESCRIPTION | USED BY |
+-----------+----------------------------------+-------------+---------+
| container | alp3                             |             | 1       |
+-----------+----------------------------------+-------------+---------+
| container | jupyter                          |             | 1       |
+-----------+----------------------------------+-------------+---------+
| image     | ebd565585223487526ddb3607f515... |             | 1       |
+-----------+----------------------------------+-------------+---------+

കൂടാതെ, ആണെങ്കിൽ സംഭരണ ​​കുളം സൃഷ്ടിക്കുമ്പോൾ, BTRFS ഫയൽ സിസ്റ്റം തിരഞ്ഞെടുത്തു, തുടർന്ന് ഒരു ലിസ്റ്റ് നേടുക സംഭരണ ​​വോളിയം അഥവാ ഉപവോള്യങ്ങൾ BTRFS വ്യാഖ്യാനത്തിൽ, നിങ്ങൾക്ക് ഈ ഫയൽ സിസ്റ്റത്തിന്റെ ടൂൾകിറ്റ് ഉപയോഗിക്കാം:

sudo btrfs subvolume list -p /var/lib/lxd/storage-pools/hddpool

ID 257 gen 818 parent 5 top level 5 path images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3

sudo btrfs subvolume list -p /var/lib/lxd/storage-pools/ssdpool

ID 257 gen 1820 parent 5 top level 5 path images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
ID 260 gen 1819 parent 5 top level 5 path containers/jupyter
ID 263 gen 1820 parent 5 top level 5 path containers/alp3

LXD ആരംഭിക്കുന്നു ^

കണ്ടെയ്‌നറുകൾ സൃഷ്‌ടിക്കുന്നതിനും ഉപയോഗിക്കുന്നതിനും മുമ്പ്, നെറ്റ്‌വർക്കും സംഭരണവും സൃഷ്‌ടിക്കുകയും കോൺഫിഗർ ചെയ്യുകയും ചെയ്യുന്ന ഒരു പൊതു എൽഎക്‌സ്‌ഡി ഇനിഷ്യലൈസേഷൻ നിങ്ങൾ നടത്തണം. കമാൻഡ് വിളിച്ച് ലിസ്റ്റിൽ ലഭ്യമായ സ്റ്റാൻഡേർഡ് ക്ലയന്റ് കമാൻഡുകൾ ഉപയോഗിച്ച് ഇത് സ്വമേധയാ ചെയ്യാവുന്നതാണ് lxc --help അല്ലെങ്കിൽ ഇനീഷ്യലൈസേഷൻ വിസാർഡ് ഉപയോഗിക്കുന്നു lxd init കുറച്ച് ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുന്നു.

സ്റ്റോറേജ് പൂളിനായി ഒരു ഫയൽ സിസ്റ്റം തിരഞ്ഞെടുക്കുന്നു ^

ഇനീഷ്യലൈസേഷൻ സമയത്ത്, ഡീഫോൾട്ടായി ഫയൽ സിസ്റ്റം തരം നിർണ്ണയിക്കുന്നത് ഉൾപ്പെടെ നിരവധി ചോദ്യങ്ങൾ LXD ചോദിക്കുന്നു സംഭരണ ​​കുളം. സ്വതവേ, അതിനായി BTRFS ഫയൽ സിസ്റ്റം തിരഞ്ഞെടുത്തിരിക്കുന്നു. സൃഷ്‌ടിച്ചതിനുശേഷം മറ്റൊരു എഫ്‌എസിലേക്ക് മാറുന്നത് അസാധ്യമായിരിക്കും. ഒരു എഫ്എസ് തിരഞ്ഞെടുക്കുന്നതിന് ഇത് നിർദ്ദേശിക്കപ്പെടുന്നു ഫീച്ചർ താരതമ്യ പട്ടിക:

സവിശേഷത
ഡയറക്ടറി
Btrfs
എൽവിഎം
ZFS
CEPH

ഒപ്റ്റിമൈസ് ചെയ്ത ഇമേജ് സ്റ്റോറേജ്
ഇല്ല
അതെ
അതെ
അതെ
അതെ

ഒപ്റ്റിമൈസ് ചെയ്ത ഉദാഹരണം സൃഷ്ടിക്കൽ
ഇല്ല
അതെ
അതെ
അതെ
അതെ

ഒപ്റ്റിമൈസ് ചെയ്ത സ്നാപ്പ്ഷോട്ട് സൃഷ്ടിക്കൽ
ഇല്ല
അതെ
അതെ
അതെ
അതെ

ഒപ്റ്റിമൈസ് ചെയ്ത ഇമേജ് ട്രാൻസ്ഫർ
ഇല്ല
അതെ
ഇല്ല
അതെ
അതെ

ഒപ്റ്റിമൈസ് ചെയ്ത ഉദാഹരണ കൈമാറ്റം
ഇല്ല
അതെ
ഇല്ല
അതെ
അതെ

എഴുതുമ്പോൾ പകർത്തുക
ഇല്ല
അതെ
അതെ
അതെ
അതെ

ബ്ലോക്ക് അടിസ്ഥാനമാക്കി
ഇല്ല
ഇല്ല
അതെ
ഇല്ല
അതെ

തൽക്ഷണ ക്ലോണിംഗ്
ഇല്ല
അതെ
അതെ
അതെ
അതെ

ഒരു കണ്ടെയ്‌നറിനുള്ളിൽ ഉപയോഗിക്കാവുന്ന സ്റ്റോറേജ് ഡ്രൈവർ
അതെ
അതെ
ഇല്ല
ഇല്ല
ഇല്ല

പഴയ സ്നാപ്പ്ഷോട്ടുകളിൽ നിന്ന് പുനഃസ്ഥാപിക്കുക (ഏറ്റവും പുതിയതല്ല)
അതെ
അതെ
അതെ
ഇല്ല
അതെ

സംഭരണ ​​ക്വാട്ടകൾ
അതെ (*)
അതെ
അതെ
അതെ
ഇല്ല

വിസാർഡ് ഉപയോഗിച്ച് നെറ്റ്‌വർക്കും സ്റ്റോറേജ് പൂളും ആരംഭിക്കുന്നു ^

ഇനിഷ്യലൈസേഷൻ വിസാർഡ് ഉപയോഗിച്ച് ലളിതമായ ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകി LXD-യുടെ പ്രധാന ഘടകങ്ങൾ സജ്ജീകരിക്കാൻ ഞങ്ങൾ നോക്കുന്ന അടുത്ത കമാൻഡ് നിർദ്ദേശിക്കുന്നു.

കമാൻഡ് പ്രവർത്തിപ്പിക്കുക lxc init ചുവടെയുള്ള ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ കോളണിന് ശേഷമുള്ള ചോദ്യങ്ങൾക്കുള്ള ഉത്തരങ്ങൾ നൽകുക അല്ലെങ്കിൽ നിങ്ങളുടെ വ്യവസ്ഥകൾക്കനുസരിച്ച് അവ മാറ്റുക:

lxd init

Would you like to use LXD clustering? (yes/no) [default=no]: 
Do you want to configure a new storage pool? (yes/no) [default=yes]: 
Name of the new storage pool [default=default]: ssdpool         
Name of the storage backend to use (lvm, btrfs, dir) [default=btrfs]: 
Create a new BTRFS pool? (yes/no) [default=yes]: 
Would you like to use an existing block device? (yes/no) [default=no]: 
Size in GB of the new loop device (1GB minimum) [default=15GB]: 10GB
Would you like to connect to a MAAS server? (yes/no) [default=no]: 
Would you like to create a new local network bridge? (yes/no) [default=yes]: 
What should the new bridge be called? [default=lxdbr0]: 
What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: 10.0.5.1/24
Would you like LXD to NAT IPv4 traffic on your bridge? [default=yes]: 
What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: none
Would you like LXD to be available over the network? (yes/no) [default=no]: 
Would you like stale cached images to be updated automatically? (yes/no) [default=yes] no
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]: 

ഒരു അധിക സ്റ്റോറേജ് പൂൾ സൃഷ്ടിക്കുന്നു ^

മുമ്പത്തെ ഘട്ടത്തിൽ ഞങ്ങൾ സൃഷ്ടിച്ചു സംഭരണ ​​കുളം പേര് നൽകിയത് ssdpool കൂടാതെ എന്റെ സിസ്റ്റത്തിൽ സ്ഥിതി ചെയ്യുന്ന ഫയൽ /var/lib/lxd/disks/ssdpool.img. ഈ ഫയൽ സിസ്റ്റം വിലാസം എന്റെ പിസിയിലെ ഫിസിക്കൽ എസ്എസ്ഡി ഡ്രൈവുമായി യോജിക്കുന്നു.

ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ, വഹിച്ച പങ്കിനെക്കുറിച്ചുള്ള ധാരണ വിപുലീകരിക്കാൻ സംഭരണ ​​കുളം റിപ്പോസിറ്ററിയിൽ, ഞങ്ങൾ രണ്ടാമത്തേത് സൃഷ്ടിക്കും സംഭരണ ​​കുളം അത് വ്യത്യസ്‌ത തരം ഡിസ്‌കിൽ, എച്ച്‌ഡിഡിയിൽ ഭൗതികമായി സ്ഥിതിചെയ്യും. LXD നിങ്ങളെ സൃഷ്ടിക്കാൻ അനുവദിക്കുന്നില്ല എന്നതാണ് പ്രശ്നം സംഭരണ ​​കുളം വിലാസത്തിന് പുറത്താണ് /var/lib/lxd/disks/ പ്രതീകാത്മക ലിങ്കുകൾ പോലും പ്രവർത്തിക്കില്ല, ഡവലപ്പറുടെ പ്രതികരണം കാണുക. ഇനീഷ്യലൈസേഷൻ/ഫോർമാറ്റിംഗ് സമയത്ത് നമുക്ക് ഈ പരിമിതി മറികടക്കാം സംഭരണ ​​കുളം കീയിൽ ഇത് വ്യക്തമാക്കുന്നതിലൂടെ ലൂപ്പ്ബാക്ക് ഫയലിലേക്കുള്ള പാതയ്ക്ക് പകരം ഒരു ബ്ലോക്ക് ഉപകരണമായി മൂല്യം വ്യക്തമാക്കുന്നതിലൂടെ source.

അതിനാൽ, സൃഷ്ടിക്കുന്നതിന് മുമ്പ് സംഭരണ ​​കുളം നിങ്ങളുടെ ഫയൽ സിസ്റ്റത്തിൽ ഉപയോഗിക്കുന്ന ഒരു ലൂപ്പ്ബാക്ക് ഫയൽ അല്ലെങ്കിൽ നിലവിലുള്ള ഒരു പാർട്ടീഷൻ നിങ്ങൾ നിർവചിക്കേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ 10GB വലുപ്പത്തിൽ പരിമിതപ്പെടുത്തുന്ന ഒരു ഫയൽ സൃഷ്ടിക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യും:

dd if=/dev/zero of=/mnt/work/lxd/hddpool.img bs=1MB count=10000

10000+0 records in
10000+0 records out
10000000000 bytes (10 GB, 9,3 GiB) copied, 38,4414 s, 260 MB/s

നമുക്ക് ലൂപ്പ്ബാക്ക് ഫയൽ ഒരു സ്വതന്ത്ര ലൂപ്പ്ബാക്ക് ഉപകരണത്തിലേക്ക് ബന്ധിപ്പിക്കാം:

sudo losetup --find --show /mnt/work/lxd/hddpool.img

/dev/loop1

താക്കോലിനു നന്ദി --show കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നത് നമ്മുടെ ലൂപ്പ്ബാക്ക് ഫയൽ കണക്റ്റുചെയ്തിരിക്കുന്ന ഉപകരണത്തിന്റെ പേര് സ്ക്രീനിലേക്ക് തിരികെ നൽകുന്നു. ആവശ്യമെങ്കിൽ, ഞങ്ങളുടെ പ്രവർത്തനങ്ങൾ ശരിയാണെന്ന് ഉറപ്പാക്കാൻ ഇത്തരത്തിലുള്ള എല്ലാ തിരക്കേറിയ ഉപകരണങ്ങളുടെയും ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കാൻ കഴിയും:

losetup -l

NAME       SIZELIMIT OFFSET AUTOCLEAR RO BACK-FILE                      DIO LOG-SEC
/dev/loop1         0      0         0  0 /mnt/work/lxd/hddpool.img        0     512
/dev/loop0         0      0         1  0 /var/lib/lxd/disks/ssdpool.img   0     512

ലിസ്റ്റിൽ നിന്ന് ഉപകരണം ഉണ്ടെന്ന് നിങ്ങൾക്ക് കണ്ടെത്താനാകും /dev/loop1 loopback ഫയൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട് /mnt/work/lxd/hddpool.img, ഉപകരണത്തിലും /dev/loop0 loopback ഫയൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട് /var/lib/lxd/disks/ssdpool.img സ്ഥിരസ്ഥിതിയുമായി പൊരുത്തപ്പെടുന്നവ സംഭരണ ​​കുളം.

ഇനിപ്പറയുന്ന കമാൻഡ് പുതിയൊരെണ്ണം സൃഷ്ടിക്കുന്നു സംഭരണ ​​കുളം ഞങ്ങൾ ഇപ്പോൾ തയ്യാറാക്കിയ ലൂപ്പ്ബാക്ക് ഫയലിനെ അടിസ്ഥാനമാക്കി LXD-യിൽ. LXD ലൂപ്പ്ബാക്ക് ഫയൽ ഫോർമാറ്റ് ചെയ്യും /mnt/work/lxd/hddpool.img ഉപകരണത്തിൽ /dev/loop1 BTRFS ഫയൽ സിസ്റ്റത്തിനായി:

lxc storage create hddpool btrfs size=10GB source=/dev/loop1

നമുക്ക് എല്ലാം ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കാം സംഭരണ ​​കുളം സ്ക്രീനിലേക്ക്:

lxc storage list

+---------+-------------+--------+--------------------------------+---------+
|  NAME   | DESCRIPTION | DRIVER |             SOURCE             | USED BY |
+---------+-------------+--------+--------------------------------+---------+
| hddpool |             | btrfs  | /dev/loop1                     | 0       |
+---------+-------------+--------+--------------------------------+---------+
| ssdpool |             | btrfs  | /var/lib/lxd/disks/ssdpool.img | 0       |
+---------+-------------+--------+--------------------------------+---------+

സ്റ്റോറേജ് പൂൾ വലുപ്പം വർദ്ധിപ്പിക്കുന്നു ^

സൃഷ്ടിക്ക് ശേഷം സംഭരണ ​​കുളം, ആവശ്യമെങ്കിൽ, അത് വിപുലീകരിക്കാം. വേണ്ടി സംഭരണ ​​കുളം BTRFS ഫയൽ സിസ്റ്റത്തെ അടിസ്ഥാനമാക്കി, ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക:

sudo truncate -s +5G /mnt/work/lxd/hddpool.img
sudo losetup -c /dev/loop1
sudo btrfs filesystem resize max /var/lib/lxd/storage-pools/hddpool

ഒരു ലൂപ്പ്ബാക്ക് ഉപകരണ സ്ലോട്ടിലേക്ക് ഒരു ലൂപ്പ്ബാക്ക് ഫയൽ സ്വയമേവ ചേർക്കൽ ^

ഞങ്ങൾക്ക് ഒരു ചെറിയ പ്രശ്നമുണ്ട്, ഹോസ്റ്റ് സിസ്റ്റം റീബൂട്ട് ചെയ്യുമ്പോൾ ഫയൽ /mnt/work/lxd/hddpool.img ഉപകരണത്തിൽ നിന്ന് "പറക്കും" /dev/loop1 ഈ ഉപകരണത്തിൽ അത് കാണാത്തതിനാൽ ലോഡുചെയ്യുമ്പോൾ LXD സേവനം തകരാറിലാകും. ഈ പ്രശ്നം പരിഹരിക്കാൻ, ഈ ഫയൽ ഉപകരണത്തിലേക്ക് ചേർക്കുന്ന ഒരു സിസ്റ്റം സേവനം നിങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട് /dev/loop1 ഹോസ്റ്റ് സിസ്റ്റം ബൂട്ട് ചെയ്യുമ്പോൾ.

നമുക്ക് സൃഷ്ടിക്കാം യൂണിറ്റ് ഫയൽ തരം സേവനം в /etc/systemd/system/ SystemD ഇനീഷ്യലൈസേഷൻ സിസ്റ്റത്തിനായി:

cat << EOF | sudo tee -a /etc/systemd/system/lxd-hddpool.service
[Unit]
Description=Losetup LXD Storage Pool (hddpool)
After=local-fs.target

[Service]
Type=oneshot
ExecStart=/sbin/losetup /dev/loop1 /mnt/work/lxd/hddpool.img
RemainAfterExit=true

[Install]
WantedBy=local-fs.target
EOF

സേവനം സജീവമാക്കുക:

sudo systemctl enable lxd-hddpool

Created symlink /etc/systemd/system/local-fs.target.wants/lxd-hddpool.service → /etc/systemd/system/lxd-hddpool.service.

ഹോസ്റ്റ് സിസ്റ്റം പുനരാരംഭിച്ച ശേഷം, ഞങ്ങൾ സേവന നില പരിശോധിക്കുന്നു:

systemctl status lxd-hddpool.service 

● lxd-hddpool.service - Losetup LXD Storage Pool (hddpool)
     Loaded: loaded (/etc/systemd/system/lxd-hddpool.service; enabled; vendor preset: disabled)
     Active: active (exited) since Wed 2020-04-08 03:43:53 MSK; 1min 37s ago
    Process: 711 ExecStart=/sbin/losetup /dev/loop1 /mnt/work/lxd/hddpool.img (code=exited, status=0/SUCCESS)
   Main PID: 711 (code=exited, status=0/SUCCESS)

апр 08 03:43:52 manjaro systemd[1]: Starting Losetup LXD Storage Pool (hddpool)...
апр 08 03:43:53 manjaro systemd[1]: Finished Losetup LXD Storage Pool (hddpool).

ഔട്ട്‌പുട്ടിൽ നിന്ന് നമുക്ക് സേവന നിലയാണെന്ന് പരിശോധിക്കാൻ കഴിയും സജീവമായ, ഒരു കമാൻഡിൽ നിന്ന് ഞങ്ങളുടെ സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ പൂർത്തിയായിട്ടും, ഓപ്ഷൻ ഞങ്ങളെ ഇത് ചെയ്യാൻ അനുവദിച്ചു RemainAfterExit=true.

സുരക്ഷ. കണ്ടെയ്നർ പ്രത്യേകാവകാശങ്ങൾ ^

എല്ലാ കണ്ടെയ്‌നർ പ്രോസസ്സുകളും യഥാർത്ഥത്തിൽ ഹോസ്റ്റ് സിസ്റ്റത്തിൽ അതിന്റെ കേർണൽ ഉപയോഗിച്ച് ഒറ്റപ്പെട്ട നിലയിലാണ് പ്രവർത്തിക്കുന്നത് എന്നതിനാൽ, ഹോസ്റ്റ് സിസ്റ്റത്തിലേക്കുള്ള കണ്ടെയ്‌നർ പ്രോസസ്സുകളുടെ ആക്‌സസ് കൂടുതൽ പരിരക്ഷിക്കുന്നതിന്, LXD പ്രോസസ് പ്രിവിലേജ് വാഗ്ദാനം ചെയ്യുന്നു, ഇവിടെ:

• പ്രിവിലേജ്ഡ് കണ്ടെയ്നറുകൾ - ഇവ യുഐഡിയും ജിഐഡിയും ഉള്ള പ്രക്രിയകൾ ഹോസ്റ്റ് സിസ്റ്റത്തിലെ അതേ ഉടമയുമായി പൊരുത്തപ്പെടുന്ന കണ്ടെയ്‌നറുകളാണ്. ഉദാഹരണത്തിന്, 0-ന്റെ UID ഉള്ള ഒരു കണ്ടെയ്‌നറിൽ പ്രവർത്തിക്കുന്ന ഒരു പ്രോസസ്സിന്, 0-ന്റെ UID ഉള്ള ഹോസ്റ്റ് സിസ്റ്റത്തിലെ ഒരു പ്രോസസ്സിന് സമാനമായ എല്ലാ ആക്‌സസ് അവകാശങ്ങളും ഉണ്ട്. മറ്റൊരു രീതിയിൽ പറഞ്ഞാൽ, കണ്ടെയ്‌നറിലെ റൂട്ട് ഉപയോക്താവിന് എല്ലാ അവകാശങ്ങളും ഉണ്ട്. കണ്ടെയ്‌നർ മാത്രമല്ല, കണ്ടെയ്‌നറിന്റെ ഒറ്റപ്പെട്ട നെയിംസ്‌പെയ്‌സിന് പുറത്ത് പോകാൻ കഴിയുമെങ്കിൽ ഹോസ്റ്റ് സിസ്റ്റത്തിലും.

• പ്രത്യേകാവകാശമില്ലാത്ത കണ്ടെയ്നറുകൾ - ഇവ 0 മുതൽ 65535 വരെയുള്ള സംഖ്യകളുള്ള UID, GID എന്നിവയുടെ ഉടമയുടേതായ പ്രക്രിയകളുള്ള കണ്ടെയ്‌നറുകളാണ്, എന്നാൽ ഹോസ്റ്റ് സിസ്റ്റത്തിനായി യഥാക്രമം ചേർത്ത SubUID, SubGID ബിറ്റുകൾ ഉപയോഗിച്ച് ഉടമയെ മറയ്ക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു കണ്ടെയ്‌നറിൽ UID=0 ഉള്ള ഒരു ഉപയോക്താവിനെ ഹോസ്റ്റ് സിസ്റ്റത്തിൽ ഇങ്ങനെ കാണും SubUID + UID. ഇത് ഹോസ്റ്റ് സിസ്റ്റത്തെ സംരക്ഷിക്കുന്നു, കാരണം കണ്ടെയ്‌നറിലെ ഏതെങ്കിലും പ്രോസസ്സിന് അതിന്റെ ഒറ്റപ്പെട്ട നെയിംസ്‌പെയ്‌സിൽ നിന്ന് രക്ഷപ്പെടാൻ കഴിയുമെങ്കിൽ, അത് അജ്ഞാതവും വളരെ ഉയർന്നതുമായ UID/GID ഉള്ള ഒരു പ്രക്രിയയായി മാത്രമേ ഹോസ്റ്റ് സിസ്റ്റവുമായി ആശയവിനിമയം നടത്താൻ കഴിയൂ.

ഡിഫോൾട്ടായി, പുതുതായി സൃഷ്‌ടിച്ച കണ്ടെയ്‌നറുകൾക്ക് പ്രത്യേകാവകാശമില്ലാത്ത നിലയുണ്ട്, അതിനാൽ ഞങ്ങൾ ഒരു സബ്‌യുഐഡിയും സബ്‌ജിഐഡിയും നിർവ്വചിക്കേണ്ടതുണ്ട്.

നമുക്ക് രണ്ട് കോൺഫിഗറേഷൻ ഫയലുകൾ സൃഷ്ടിക്കാം, അതിൽ യഥാക്രമം SubUID, SubGID എന്നിവയ്ക്കായി മാസ്ക് സജ്ജീകരിക്കും:

sudo touch /etc{/subuid,/subgid}
sudo usermod --add-subuids 1000000-1065535 root 
sudo usermod --add-subgids 1000000-1065535 root

മാറ്റങ്ങൾ പ്രയോഗിക്കുന്നതിന്, LXD സേവനം പുനരാരംഭിക്കേണ്ടതുണ്ട്:

sudo systemctl restart lxd

ഒരു വെർച്വൽ നെറ്റ്‌വർക്ക് സ്വിച്ച് സൃഷ്‌ടിക്കുന്നു ^

ഇനീഷ്യലൈസേഷൻ വിസാർഡ് ഉപയോഗിച്ച് ഞങ്ങൾ മുമ്പ് നെറ്റ്‌വർക്ക് ആരംഭിച്ചതിനാൽ lxd init ഒരു നെറ്റ്‌വർക്ക് ഉപകരണം സൃഷ്ടിച്ചു lxdbr0, തുടർന്ന് ഈ വിഭാഗത്തിൽ നമുക്ക് LXD-യിലെ നെറ്റ്‌വർക്കിംഗും ക്ലയന്റ് കമാൻഡ് ഉപയോഗിച്ച് ഒരു വെർച്വൽ സ്വിച്ച് (ബ്രിഡ്ജ്) എങ്ങനെ സൃഷ്ടിക്കാമെന്നും പരിചയപ്പെടാം.

ഒരു സ്വിച്ച് (പാലം) ഹോസ്റ്റിനെയും കണ്ടെയ്‌നറുകളേയും ഒരു നെറ്റ്‌വർക്കിലേക്ക് എങ്ങനെ ബന്ധിപ്പിക്കുന്നുവെന്ന് ഇനിപ്പറയുന്ന ഡയഗ്രം കാണിക്കുന്നു:

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

ഇനിപ്പറയുന്ന കമാൻഡ് ഒരു സബ്നെറ്റിനൊപ്പം ഒരു സ്വിച്ച് സൃഷ്ടിക്കുന്നു 10.0.5.0/24 കൂടാതെ IPv4 വിലാസവും 10.0.5.1/24, കൂടാതെ ഉൾപ്പെടുന്നു ipv4.nat NAT സേവനം ഉപയോഗിച്ച് ഹോസ്റ്റ് വഴി കണ്ടെയ്നറുകൾക്ക് ഇന്റർനെറ്റ് ആക്സസ് ചെയ്യാൻ കഴിയും:

lxc network create lxdbr0 ipv4.address=10.0.5.1/24 ipv4.nat=true ipv6.address=none

LXD-യിൽ ലഭ്യമായ നെറ്റ്‌വർക്ക് ഉപകരണങ്ങളുടെ ലിസ്റ്റ് പരിശോധിക്കുന്നു:

lxc network list

+--------+----------+---------+-------------+---------+
|  NAME  |   TYPE   | MANAGED | DESCRIPTION | USED BY |
+--------+----------+---------+-------------+---------+
| eno1   | physical | NO      |             | 0       |
+--------+----------+---------+-------------+---------+
| lxdbr0 | bridge   | YES     |             | 0       |
+--------+----------+---------+-------------+---------+

സ്റ്റാൻഡേർഡ് ടൂൾ ഉപയോഗിച്ച് നെറ്റ്‌വർക്ക് ഉപകരണം സൃഷ്ടിച്ചിട്ടുണ്ടോ എന്ന് നിങ്ങൾക്ക് പരിശോധിക്കാനും കഴിയും. Linux-വിതരണം — ip link അഥവാ ip addr:

ip addr

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: eno1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether bc:ee:7b:5a:6b:44 brd ff:ff:ff:ff:ff:ff
    altname enp0s25
    inet6 fe80::9571:11f3:6e0c:c07b/64 scope link noprefixroute 
       valid_lft forever preferred_lft forever
3: lxdbr0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
    link/ether c2:38:90:df:cb:59 brd ff:ff:ff:ff:ff:ff
    inet 10.0.5.1/24 scope global lxdbr0
       valid_lft forever preferred_lft forever
    inet6 fe80::c038:90ff:fedf:cb59/64 scope link 
       valid_lft forever preferred_lft forever
5: veth3ddab174@if4: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master lxdbr0 state UP group default qlen 1000
    link/ether ca:c3:5c:1d:22:26 brd ff:ff:ff:ff:ff:ff link-netnsid 0

കോൺഫിഗറേഷൻ പ്രൊഫൈൽ ^

എൽഎക്‌സ്‌ഡിയിലെ ഓരോ കണ്ടെയ്‌നറിനും അതിന്റേതായ കോൺഫിഗറേഷനുണ്ട്, ആഗോളതലത്തിൽ പ്രഖ്യാപിച്ച കോൺഫിഗറേഷനുകൾ ഉപയോഗിച്ച് ഇത് വിപുലീകരിക്കാൻ കഴിയും കോൺഫിഗറേഷൻ പ്രൊഫൈലുകൾ. ഒരു കണ്ടെയ്നറിലേക്ക് കോൺഫിഗറേഷൻ പ്രൊഫൈലുകൾ പ്രയോഗിക്കുന്നതിന് ഒരു കാസ്കേഡ് മോഡൽ ഉണ്ട്, ഇനിപ്പറയുന്ന ഉദാഹരണം ഇത് തെളിയിക്കുന്നു:

ഈ ഉദാഹരണത്തിൽ, LXD സിസ്റ്റത്തിൽ മൂന്ന് പ്രൊഫൈലുകൾ സൃഷ്ടിച്ചു: default, hddpool и hostfs. മൂന്ന് പ്രൊഫൈലുകളും ലോക്കൽ കോൺഫിഗറേഷൻ ഉള്ള ഒരു കണ്ടെയ്‌നറിലേക്ക് പ്രയോഗിക്കുന്നു (ഗ്രേ ഏരിയ). പ്രൊഫൈൽ default ഒരു ഉപകരണമുണ്ട് root പരാമീറ്റർ ഉള്ളത് pool എന്നതിന് തുല്യമാണ് ssdpool, എന്നാൽ കാസ്കേഡ് കോൺഫിഗറേഷൻ ആപ്ലിക്കേഷൻ മോഡലിന് നന്ദി, നമുക്ക് കണ്ടെയ്നറിലേക്ക് ഒരു പ്രൊഫൈൽ പ്രയോഗിക്കാൻ കഴിയും hddpool പരാമീറ്റർ ഉള്ളത് pool പ്രൊഫൈലിൽ നിന്ന് അതേ പാരാമീറ്റർ അസാധുവാക്കും default കണ്ടെയ്നറിന് ഉപകരണ കോൺഫിഗറേഷൻ ലഭിക്കും root പരാമീറ്റർ ഉപയോഗിച്ച് pool തുല്യമായ hddpool, പ്രൊഫൈലും hostfs കണ്ടെയ്‌നറിലേക്ക് ഒരു പുതിയ ഉപകരണം ചേർക്കുന്നു.

ലഭ്യമായ കോൺഫിഗറേഷൻ പ്രൊഫൈലുകളുടെ ലിസ്റ്റ് കാണുന്നതിന്, ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിക്കുക:

lxc profile list

+---------+---------+
|  NAME   | USED BY |
+---------+---------+
| default | 1       |
+---------+---------+
| hddroot | 0       |
+---------+---------+
| ssdroot | 1       |
+---------+---------+

ഒരു പ്രൊഫൈലിനൊപ്പം പ്രവർത്തിക്കാൻ ലഭ്യമായ കമാൻഡുകളുടെ പൂർണ്ണമായ ലിസ്റ്റ് കീ ചേർക്കുന്നതിലൂടെ ലഭിക്കും --help:

lxc profile --help

Description:
  Manage profiles

Usage:
  lxc profile [command]

Available Commands:
  add         Add profiles to instances
  assign      Assign sets of profiles to instances
  copy        Copy profiles
  create      Create profiles
  delete      Delete profiles
  device      Manage instance devices
  edit        Edit profile configurations as YAML
  get         Get values for profile configuration keys
  list        List profiles
  remove      Remove profiles from instances
  rename      Rename profiles
  set         Set profile configuration keys
  show        Show profile configurations
  unset       Unset profile configuration keys

നിങ്ങളുടെ പ്രൊഫൈൽ എഡിറ്റുചെയ്യുന്നു ^

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

ഇനിപ്പറയുന്ന കമാൻഡ് ഉപകരണത്തെ കോൺഫിഗറേഷൻ പ്രൊഫൈലിലേക്ക് ചേർക്കും eth0 ടൈപ്പ് ചെയ്യുക nic നെറ്റ്‌വർക്കിലേക്ക് ബന്ധിപ്പിച്ചിരിക്കുന്നു lxdbr0:

lxc profile device add default eth0 nic network=lxdbr0 name=eth0

ഞങ്ങൾ യഥാർത്ഥത്തിൽ കോൺഫിഗറേഷൻ പ്രൊഫൈലിലേക്ക് ഉപകരണം ചേർത്തതിനാൽ, ഉപകരണത്തിൽ ഒരു സ്റ്റാറ്റിക് ഐപി വിലാസം ഞങ്ങൾ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ഈ പ്രൊഫൈൽ ഉപയോഗിക്കുന്ന എല്ലാ കണ്ടെയ്‌നറുകളും ഒരേ ഐപി വിലാസം പങ്കിടുമെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. കണ്ടെയ്‌നറിനായി നീക്കിവച്ചിരിക്കുന്ന ഒരു സ്റ്റാറ്റിക് ഐപി വിലാസമുള്ള ഒരു കണ്ടെയ്‌നർ സൃഷ്‌ടിക്കേണ്ട ആവശ്യമുണ്ടെങ്കിൽ, പ്രൊഫൈൽ തലത്തിലല്ല, ഐപി വിലാസ പാരാമീറ്റർ ഉപയോഗിച്ച് കണ്ടെയ്‌നർ തലത്തിൽ (ലോക്കൽ കോൺഫിഗറേഷൻ) ഒരു നെറ്റ്‌വർക്ക് ഉപകരണ കോൺഫിഗറേഷൻ സൃഷ്‌ടിക്കണം.

നമുക്ക് പ്രൊഫൈൽ പരിശോധിക്കാം:

lxc profile show default

config: {}
description: Default LXD profile
devices:
  eth0:
    name: eth0
    network: lxdbr0
    type: nic
  root:
    path: /
    pool: ssdpool
    type: disk
name: default
used_by: []

പുതുതായി സൃഷ്‌ടിച്ച എല്ലാ കണ്ടെയ്‌നറുകൾക്കും രണ്ട് ഉപകരണങ്ങൾ സൃഷ്‌ടിക്കപ്പെടുമെന്ന് ഈ പ്രൊഫൈലിൽ നമുക്ക് കാണാൻ കഴിയും:

• eth0 - ഉപകരണ തരം nic ഒരു സ്വിച്ച് (നെറ്റ്‌വർക്ക് ബ്രിഡ്ജ്) lxdbr0
• root - ഉപകരണ തരം disk ഇത് ഒരു സ്റ്റോറേജ് പൂൾ ഉപയോഗിക്കുന്നു ssdpool

പുതിയ പ്രൊഫൈലുകൾ സൃഷ്ടിക്കുന്നു ^

മുമ്പ് സൃഷ്ടിച്ചത് ഉപയോഗിക്കാൻ സംഭരണ ​​കുളം കണ്ടെയ്നറുകൾ, ഒരു കോൺഫിഗറേഷൻ പ്രൊഫൈൽ സൃഷ്ടിക്കുക ssdroot അതിൽ ഞങ്ങൾ ഒരു ഉപകരണം ചേർക്കും disk മൗണ്ട് പോയിന്റ് ഉപയോഗിച്ച് / (റൂട്ട്) മുമ്പ് സൃഷ്ടിച്ചത് ഉപയോഗിച്ച് സംഭരണ ​​കുളം - ssdpool:

lxc profile create ssdroot
lxc profile device add ssdroot root disk path=/ pool=ssdpool

അതുപോലെ, ഞങ്ങൾ ഒരു ഉപകരണം സൃഷ്ടിക്കുന്നു disk, എന്നാൽ ഈ സാഹചര്യത്തിൽ ഉപയോഗിക്കുന്നത് സംഭരണ ​​കുളം - hddpool:

lxc profile create hddroot
lxc profile device add hddroot root disk path=/ pool=hddpool

കോൺഫിഗറേഷൻ പ്രൊഫൈലുകൾ പരിശോധിക്കുന്നു:

lxc profile show ssdroot

config: {}
description: ""
devices:
  root:
    path: /
    pool: ssdpool
    type: disk
name: ssdroot
used_by: []

lxc profile show hddroot

config: {}
description: ""
devices:
  root:
    path: /
    pool: hddpool
    type: disk
name: hddroot
used_by: []

ചിത്ര ശേഖരം ^

കേർണൽ ഇല്ലാത്ത പ്രത്യേകം സമാഹരിച്ച വിതരണങ്ങളായ ഇമേജുകളിൽ നിന്നാണ് കണ്ടെയ്നറുകൾ സൃഷ്ടിക്കുന്നത്. Linuxഅതിനാൽ, ഒരു കണ്ടെയ്നർ സമാരംഭിക്കുന്നതിന് മുമ്പ്, അത് ഈ ചിത്രത്തിൽ നിന്ന് വിന്യസിക്കണം. ഇമേജ് ഉറവിടം ഒരു ലോക്കൽ റിപ്പോസിറ്ററിയാണ്, അതിലേക്ക് ബാഹ്യ റിപ്പോസിറ്ററികളിൽ നിന്ന് ചിത്രങ്ങൾ ഡൗൺലോഡ് ചെയ്യുന്നു.

റിമോട്ട് ഇമേജ് റിപ്പോസിറ്ററികൾ ^

സ്ഥിരസ്ഥിതിയായി, മൂന്ന് വിദൂര ഉറവിടങ്ങളിൽ നിന്ന് ചിത്രങ്ങൾ സ്വീകരിക്കുന്നതിന് LXD ക്രമീകരിച്ചിരിക്കുന്നു:

• ubuntu: (സ്ഥിരതയ്ക്ക് Ubuntu ചിത്രങ്ങൾ)
• ubuntu- ദിവസേന: (ദിവസേന Ubuntu ചിത്രങ്ങൾ)
• ചിത്രങ്ങൾ: (ഒരു കൂട്ടം മറ്റ് ഡിസ്ട്രോകൾക്ക്)

lxc remote list

+-----------------+------------------------------------------+--------+--------+
|      NAME       |                   URL                    | PUBLIC | STATIC |
+-----------------+------------------------------------------+--------+--------+
| images          | https://images.linuxcontainers.org       | YES    | NO     |
+-----------------+------------------------------------------+--------+--------+
| local (default) | unix://                                  | NO     | YES    |
+-----------------+------------------------------------------+--------+--------+
| ubuntu          | https://cloud-images.ubuntu.com/releases | YES    | YES    |
+-----------------+------------------------------------------+--------+--------+
| ubuntu-daily    | https://cloud-images.ubuntu.com/daily    | YES    | YES    |
+-----------------+------------------------------------------+--------+--------+

ഉദാഹരണത്തിന്, ശേഖരം ubuntu: ഇനിപ്പറയുന്ന ചിത്രങ്ങൾ ഉണ്ട്:

lxc image -c dasut list ubuntu: | head -n 11

+----------------------------------------------+--------------+----------+------------+
|                   DESCRIPTION                | ARCHITECTURE |   SIZE   |   TYPE     |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150728)  | x86_64       | 153.72MB | CONTAINER  |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150819)  | x86_64       | 152.91MB | CONTAINER  |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150906)  | x86_64       | 154.69MB | CONTAINER  |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150930)  | x86_64       | 153.86MB | CONTAINER  |
+----------------------------------------------+--------------+----------+------------+

പരിമിതമായ എണ്ണം നിരകൾ പ്രദർശിപ്പിക്കുന്നതിന് ഞങ്ങൾ ഓപ്ഷൻ ഉപയോഗിച്ചു -c പരാമീറ്ററുകൾക്കൊപ്പം dasut, കൂടാതെ കമാൻഡ് ഉപയോഗിച്ച് ലിസ്റ്റിന്റെ ദൈർഘ്യം പരിമിതപ്പെടുത്തുകയും ചെയ്തു head.

ചിത്രങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കാൻ ഫിൽട്ടറിംഗ് ലഭ്യമാണ്. ലഭ്യമായ എല്ലാ ഡിസ്ട്രിബ്യൂഷൻ ആർക്കിടെക്ചറുകളും താഴെ പറയുന്ന കമാൻഡ് ലിസ്റ്റ് ചെയ്യും ആൽപൈൻLinux:

lxc image -c ldast list images:alpine/3.11

+------------------------------+--------------------------------------+--------------+
|            ALIAS             |             DESCRIPTION              | ARCHITECTURE |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11 (3 more)         | Alpine 3.11 amd64 (20200220_13:00)   | x86_64       |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/arm64 (1 more)   | Alpine 3.11 arm64 (20200220_13:00)   | aarch64      |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/armhf (1 more)   | Alpine 3.11 armhf (20200220_13:00)   | armv7l       |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/i386 (1 more)    | Alpine 3.11 i386 (20200220_13:01)    | i686         |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/ppc64el (1 more) | Alpine 3.11 ppc64el (20200220_13:00) | ppc64le      |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/s390x (1 more)   | Alpine 3.11 s390x (20200220_13:00)   | s390x        |
+------------------------------+--------------------------------------+--------------+

പ്രാദേശിക ചിത്ര ശേഖരം ^

കണ്ടെയ്‌നർ ഉപയോഗിക്കാൻ തുടങ്ങുന്നതിന്, നിങ്ങൾ ആഗോള ശേഖരത്തിൽ നിന്ന് ലോക്കലിലേക്ക് ഒരു ചിത്രം ചേർക്കേണ്ടതുണ്ട് local:. ഇപ്പോൾ ലോക്കൽ റിപ്പോസിറ്ററി ശൂന്യമാണ്, കമാൻഡ് ഇത് ഉറപ്പാക്കും lxc image list. രീതി എങ്കിൽ list ഒരു ശേഖരം വ്യക്തമാക്കരുത്, തുടർന്ന് പ്രാദേശിക ശേഖരം സ്ഥിരസ്ഥിതിയായി ഉപയോഗിക്കും - local:

lxc image list local:

+-------+-------------+--------+-------------+--------------+------+------+
| ALIAS | FINGERPRINT | PUBLIC | DESCRIPTION | ARCHITECTURE | TYPE | SIZE |
+-------+-------------+--------+-------------+--------------+------+------+

റിപ്പോസിറ്ററിയിലെ ചിത്രങ്ങൾ ഇനിപ്പറയുന്ന രീതികൾ ഉപയോഗിച്ച് കൈകാര്യം ചെയ്യുന്നു:

ടീം
വിവരണം

lxc ചിത്രം അപരാഭിധാനം
ഇമേജ് അപരനാമങ്ങൾ കൈകാര്യം ചെയ്യുക

lxc ചിത്രം പകർത്തുക
സെർവറുകൾക്കിടയിൽ ചിത്രങ്ങൾ പകർത്തുക

lxc ചിത്രം ഇല്ലാതാക്കുക
ഇമേജുകൾ ഇല്ലാതാക്കുക

lxc ചിത്രം തിരുത്തുക
ഇമേജ് പ്രോപ്പർട്ടികൾ എഡിറ്റ് ചെയ്യുക

lxc ചിത്രം കയറ്റുമതി ചെയ്യുക
ചിത്രങ്ങൾ കയറ്റുമതി ചെയ്യുക, ഡൗൺലോഡ് ചെയ്യുക

lxc ചിത്രം ഇറക്കുമതി
ഇമേജ് സ്റ്റോറിലേക്ക് ചിത്രങ്ങൾ ഇറക്കുമതി ചെയ്യുക

lxc ചിത്രം വിവരം
ചിത്രങ്ങളെക്കുറിച്ചുള്ള ഉപയോഗപ്രദമായ വിവരങ്ങൾ കാണിക്കുക

lxc ചിത്രം പട്ടിക
ചിത്രങ്ങൾ ലിസ്റ്റ് ചെയ്യുക

lxc ചിത്രം പുതുക്കുക
ചിത്രങ്ങൾ പുതുക്കുക

lxc ചിത്രം കാണിക്കുക
ഇമേജ് പ്രോപ്പർട്ടികൾ കാണിക്കുക

ഗ്ലോബൽ റിപോസിറ്ററിയിൽ നിന്ന് ചിത്രം പകർത്തുക images::

lxc image copy images:alpine/3.11/amd64 local: --alias=alpine3

Image copied successfully!

ലോക്കൽ റിപ്പോസിറ്ററിയിൽ നിലവിൽ ലഭ്യമായ എല്ലാ ചിത്രങ്ങളുടെയും ഒരു ലിസ്റ്റ് നമുക്ക് പ്രദർശിപ്പിക്കാം local::

lxc image -c lfdatsu list local:

+---------+--------------+------------------------------------+--------------+
|  ALIAS  | FINGERPRINT  |            DESCRIPTION             | ARCHITECTURE |
+---------+--------------+------------------------------------+--------------+
| alpine3 | 73a3093d4a5c | Alpine 3.11 amd64 (20200220_13:00) | x86_64       |
+---------+--------------+------------------------------------+--------------+

LXD കോൺഫിഗറേഷൻ ^

ഇന്ററാക്ടീവ് മോഡ് കൂടാതെ, LXD ഒരു നോൺ-ഇന്ററാക്ടീവ് കോൺഫിഗറേഷൻ ഇൻസ്റ്റാളേഷൻ മോഡും പിന്തുണയ്ക്കുന്നു, ഇത് ഒരു YAML ഫയലിന്റെ രൂപത്തിൽ കോൺഫിഗറേഷൻ വ്യക്തമാക്കുമ്പോൾ, എക്സിക്യൂഷൻ മറികടന്ന് മുഴുവൻ കോൺഫിഗറേഷനും ഒരേസമയം ഇൻസ്റ്റാൾ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പ്രത്യേക ഫോർമാറ്റാണിത്. നെറ്റ്‌വർക്ക് കോൺഫിഗറേഷൻ, കോൺഫിഗറേഷൻ പ്രൊഫൈലുകളുടെ സൃഷ്ടി മുതലായവ ഉൾപ്പെടെ, ഈ ലേഖനത്തിൽ മുകളിൽ ചർച്ച ചെയ്ത നിരവധി ഇന്ററാക്ടീവ് കമാൻഡുകൾ. ഞങ്ങൾ ഈ പ്രദേശം ഇവിടെ ഉൾപ്പെടുത്തില്ല, നിങ്ങൾക്കത് സ്വയം പരിശോധിക്കാം. ഡോക്യുമെന്റേഷനിൽ.

അടുത്ത സംവേദനാത്മക കമാൻഡ് lxc config ഞങ്ങൾ നോക്കുന്നത് കോൺഫിഗറേഷൻ സജ്ജമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, ലോക്കൽ റിപ്പോസിറ്ററിയിലേക്ക് ഡൗൺലോഡ് ചെയ്‌ത ചിത്രങ്ങൾ ആഗോള ശേഖരണങ്ങളിൽ നിന്ന് സ്വയമേവ അപ്‌ഡേറ്റ് ചെയ്യുന്നില്ലെന്ന് ഉറപ്പാക്കാൻ, ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് നമുക്ക് ഈ സ്വഭാവം പ്രവർത്തനക്ഷമമാക്കാം:

lxc config set images.auto_update_cached=false

ഒരു കണ്ടെയ്നർ സൃഷ്ടിക്കുകയും കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു ^

ഒരു കണ്ടെയ്നർ സൃഷ്ടിക്കാൻ കമാൻഡ് ഉപയോഗിക്കുക lxc init മൂല്യങ്ങൾ കൈമാറുന്നത് репозиторий:образ തുടർന്ന് കണ്ടെയ്‌നറിന് ആവശ്യമായ ഐഡി. റിപ്പോസിറ്ററി ലോക്കൽ എന്ന് വ്യക്തമാക്കാം local: അതുപോലെ ഏതൊരു ആഗോളവും. റിപ്പോസിറ്ററി വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, സ്ഥിരസ്ഥിതിയായി ഇമേജിനായി തിരയാൻ പ്രാദേശിക ശേഖരം ഉപയോഗിക്കുന്നു. ഗ്ലോബൽ റിപ്പോസിറ്ററിയിൽ നിന്നാണ് ചിത്രം വ്യക്തമാക്കിയതെങ്കിൽ, ചിത്രം ആദ്യം ലോക്കൽ റിപ്പോസിറ്ററിയിലേക്ക് ഡൗൺലോഡ് ചെയ്യുകയും തുടർന്ന് കണ്ടെയ്നർ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുകയും ചെയ്യും.

നമ്മുടെ ആദ്യത്തെ കണ്ടെയ്‌നർ സൃഷ്‌ടിക്കാൻ ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കാം:

lxc init alpine3 alp --storage=hddpool --profile=default --profile=hddroot

ഇവിടെ നമ്മൾ ഉപയോഗിക്കുന്ന കമാൻഡ് കീകൾ ക്രമത്തിൽ നോക്കാം:

• alpine3 - ലോക്കൽ റിപ്പോസിറ്ററിയിൽ മുമ്പ് അപ്‌ലോഡ് ചെയ്ത ചിത്രത്തിന് ഒരു അപരനാമം (അപരനാമം) വ്യക്തമാക്കിയിട്ടുണ്ട്. ഈ ചിത്രത്തിനായി അപരനാമം സൃഷ്‌ടിച്ചിട്ടില്ലെങ്കിൽ, നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ചിത്രത്തെ അതിന്റെ മുഖേന പരാമർശിക്കാം ഫിംഗർപ്രിന്റ് പട്ടികയിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നത്.
• alp - കണ്ടെയ്നറിനായി ഐഡന്റിഫയർ സജ്ജമാക്കുന്നു
• --storage - ഈ കീ ഇതിൽ സൂചിപ്പിക്കുന്നു സംഭരണ ​​കുളം ഒരു കണ്ടെയ്നർ സൃഷ്ടിക്കും
• --profile - ഈ കീകൾ കാസ്കേഡ് മുമ്പ് സൃഷ്ടിച്ച കോൺഫിഗറേഷൻ പ്രൊഫൈലുകളിൽ നിന്ന് കണ്ടെയ്നറിലേക്ക് കോൺഫിഗറേഷൻ പ്രയോഗിക്കുന്നു

ഞങ്ങൾ കണ്ടെയ്നർ സമാരംഭിക്കുന്നു, അത് വിതരണത്തിന്റെ init സിസ്റ്റം സമാരംഭിക്കാൻ തുടങ്ങുന്നു:

lxc start alp

നിങ്ങൾക്ക് കമാൻഡും ഉപയോഗിക്കാം lxc launch ഇത് ടീമുകളെ സംയോജിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു lxc init и lxc start ഒരു ഓപ്പറേഷനിൽ.

കണ്ടെയ്നറിന്റെ അവസ്ഥ പരിശോധിക്കുന്നു:

lxc list -c ns46tb
+------+---------+------------------+------+-----------+--------------+
| NAME |  STATE  |       IPV4       | IPV6 |   TYPE    | STORAGE POOL |
+------+---------+------------------+------+-----------+--------------+
| alp  | RUNNING | 10.0.5.46 (eth0) |      | CONTAINER | hddpool      |
+------+---------+------------------+------+-----------+--------------+

കണ്ടെയ്നർ കോൺഫിഗറേഷൻ പരിശോധിക്കുന്നു:

lxc config show alp

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200326_13:39)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200326_13:39"
  image.type: squashfs
  volatile.base_image: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
  volatile.eth0.host_name: vethb1fe71d8
  volatile.eth0.hwaddr: 00:16:3e:5f:73:3e
  volatile.idmap.base: "0"
  volatile.idmap.current: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.idmap.next: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.power: RUNNING
devices:
  root:
    path: /
    pool: hddpool
    type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""

വിഭാഗത്തിൽ profiles ഈ കണ്ടെയ്‌നർ രണ്ട് കോൺഫിഗറേഷൻ പ്രൊഫൈലുകൾ ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഞങ്ങൾക്ക് ഉറപ്പാക്കാൻ കഴിയും - default и hddroot. വിഭാഗത്തിൽ devices നെറ്റ്‌വർക്ക് ഉപകരണം പ്രൊഫൈൽ തലത്തിൽ സൃഷ്‌ടിച്ചതിനാൽ ഞങ്ങൾക്ക് ഒരു ഉപകരണം മാത്രമേ കണ്ടെത്താൻ കഴിയൂ default. കണ്ടെയ്നർ ഉപയോഗിക്കുന്ന എല്ലാ ഉപകരണങ്ങളും കാണുന്നതിന് നിങ്ങൾ ഒരു കീ ചേർക്കേണ്ടതുണ്ട് --expanded:

lxc config show alp --expanded

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200326_13:39)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200326_13:39"
  image.type: squashfs
  volatile.base_image: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
  volatile.eth0.host_name: vethb1fe71d8
  volatile.eth0.hwaddr: 00:16:3e:5f:73:3e
  volatile.idmap.base: "0"
  volatile.idmap.current: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.idmap.next: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.power: RUNNING
devices:
  eth0:
    name: eth0
    network: lxdbr0
    type: nic
  root:
    path: /
    pool: hddpool
    type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""

ഒരു സ്റ്റാറ്റിക് ഐപി വിലാസം സജ്ജീകരിക്കുന്നു ^

ഒരു നെറ്റ്‌വർക്ക് ഉപകരണത്തിനായി ഞങ്ങൾ ഒരു IP വിലാസം സജ്ജമാക്കാൻ ശ്രമിക്കുകയാണെങ്കിൽ eth0 ടീം lxc config device set alp കണ്ടെയ്‌നർ കോൺഫിഗറേഷനായി ഉദ്ദേശിച്ചിട്ടുള്ളതാണ്, തുടർന്ന് ഉപകരണം നിലവിലില്ലെന്ന് റിപ്പോർട്ടുചെയ്യുന്ന ഒരു പിശക് ഞങ്ങൾക്ക് ലഭിക്കും. eth0 കണ്ടെയ്നർ ഉപയോഗിക്കുന്നത് പ്രൊഫൈലിന്റേതാണ് default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

നമുക്ക് തീർച്ചയായും ഒരു സ്റ്റാറ്റിക് ഐപി വിലാസം സജ്ജമാക്കാൻ കഴിയും eth0 പ്രൊഫൈലിലെ ഉപകരണങ്ങൾ, എന്നാൽ ഈ പ്രൊഫൈൽ ഉപയോഗിക്കുന്ന എല്ലാ കണ്ടെയ്‌നറുകൾക്കും ഇത് സമാനമായിരിക്കും. അതിനാൽ, കണ്ടെയ്നറിന് സമർപ്പിച്ചിരിക്കുന്ന ഒരു ഉപകരണം നമുക്ക് ചേർക്കാം:

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

അപ്പോൾ നിങ്ങൾ കണ്ടെയ്നർ പുനരാരംഭിക്കേണ്ടതുണ്ട്:

lxc restart alp

നമ്മൾ ഇപ്പോൾ കണ്ടെയ്നർ കോൺഫിഗറേഷൻ നോക്കുകയാണെങ്കിൽ, നമുക്ക് ഓപ്ഷൻ ഉപയോഗിക്കേണ്ടതില്ല --expanded നെറ്റ്‌വർക്ക് ഉപകരണം കാണുന്നതിന് eth0, ഞങ്ങൾ ഇത് കണ്ടെയ്‌നർ തലത്തിൽ സൃഷ്‌ടിച്ചതിനാൽ പ്രൊഫൈലിൽ നിന്ന് അതേ ഉപകരണത്തിൽ കാസ്‌കേഡ് ചെയ്‌തു default:

lxc config show alp

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200326_13:39)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200326_13:39"
  image.type: squashfs
  volatile.base_image: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
  volatile.eth0.host_name: veth2a1dc59d
  volatile.eth0.hwaddr: 00:16:3e:0e:e2:71
  volatile.idmap.base: "0"
  volatile.idmap.current: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.idmap.next: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.last_state.power: RUNNING
devices:
  eth0:
    ipv4.address: 10.0.5.5
    name: eth0
    nictype: bridged
    parent: lxdbr0
    type: nic
  root:
    path: /
    pool: hddpool
    type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""

ഒരു കണ്ടെയ്നർ നീക്കംചെയ്യുന്നു ^

ഒരു കണ്ടെയ്നർ നീക്കം ചെയ്യാൻ, കമാൻഡ് ഉപയോഗിക്കുക lxc delete, എന്നാൽ കണ്ടെയ്നർ നീക്കം ചെയ്യുന്നതിനുമുമ്പ്, അത് കമാൻഡ് ഉപയോഗിച്ച് നിർത്തണം lxc stop:

lxc stop alp

lxc list

+------+---------+-------------------+------+-----------+-----------+
| NAME |  STATE  |       IPV4        | IPV6 |   TYPE    | SNAPSHOTS |
+------+---------+-------------------+------+-----------+-----------+
| alp  | STOPPED | 10.0.5.10 (eth0)  |      | CONTAINER | 0         |
+------+---------+-------------------+------+-----------+-----------+

കണ്ടെയ്നറിന്റെ അവസ്ഥ മാറിയെന്ന് ഞങ്ങൾ പരിശോധിച്ച ശേഷം നിർത്തി, അതിൽ നിന്ന് നീക്കം ചെയ്യാവുന്നതാണ് സംഭരണ ​​കുളം:

lxc delete alp

കണ്ടെയ്നർ ആക്സസ് ^

നെറ്റ്‌വർക്ക് കണക്ഷനുകൾ മറികടന്ന് ഒരു കണ്ടെയ്‌നറിൽ നേരിട്ട് കമാൻഡുകൾ എക്‌സിക്യൂട്ട് ചെയ്യുന്നതിന്, കമാൻഡ് ഉപയോഗിക്കുക lxc exec സിസ്റ്റം ഷെൽ സമാരംഭിക്കാതെ തന്നെ കണ്ടെയ്‌നറിൽ കമാൻഡുകൾ നടപ്പിലാക്കുന്നു. വേരിയബിളുകൾ, ഫയൽ റീഡയറക്‌ടുകൾ (പൈപ്പ്) മുതലായ ഷെൽ പാറ്റേണുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ഷെല്ലിൽ ഒരു കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യണമെങ്കിൽ, നിങ്ങൾ വ്യക്തമായി ഷെൽ സമാരംഭിക്കുകയും കമാൻഡ് ഒരു കീ ആയി കൈമാറുകയും ചെയ്യേണ്ടതുണ്ട്, ഉദാഹരണത്തിന്:

lxc exec alp -- /bin/sh -c "echo $HOME"

കമാൻഡ് ഒരു പ്രത്യേക രക്ഷപ്പെടൽ പ്രതീകം ഉപയോഗിച്ചു പ്രത്യേക സ്വഭാവത്തിന് $ അങ്ങനെ വേരിയബിൾ $HOME ഹോസ്റ്റ് മെഷീനിൽ വ്യാഖ്യാനിച്ചില്ല, പക്ഷേ കണ്ടെയ്നറിനുള്ളിൽ മാത്രമാണ് വ്യാഖ്യാനിച്ചത്.

ഇന്ററാക്ടീവ് ഷെൽ മോഡ് ആരംഭിക്കാനും തുടർന്ന് ഹോട്ട്കീ എക്സിക്യൂട്ട് ചെയ്യുന്നതിലൂടെ സെഷൻ അവസാനിപ്പിക്കാനും സാധിക്കും CTRL+D:

lxc exec alp -- /bin/sh

കണ്ടെയ്നർ റിസോഴ്സ് മാനേജ്മെന്റ് ^

LXD-യിൽ, ഒരു പ്രത്യേക കോൺഫിഗറേഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് കണ്ടെയ്‌നർ ഉറവിടങ്ങൾ നിയന്ത്രിക്കാനാകും. കണ്ടെയ്നർ കോൺഫിഗറേഷൻ പാരാമീറ്ററുകളുടെ പൂർണ്ണമായ ലിസ്റ്റ് കാണാം ഡോക്യുമെന്റേഷനിൽ.

റാം റിസോഴ്സ് പരിമിതി ^

പാരാമീറ്റർ limits.memory കണ്ടെയ്നറിന് ലഭ്യമായ റാമിന്റെ അളവ് പരിമിതപ്പെടുത്തുന്നു. മൂല്യം ഒരു സംഖ്യയും ഒന്നുമാണ് ലഭ്യമായ പ്രത്യയങ്ങൾ.

നമുക്ക് കണ്ടെയ്നറിന്റെ റാം പരിധി 256 MB ആയി സജ്ജീകരിക്കാം:

lxc config set alp limits.memory 256MB

കൂടാതെ, മെമ്മറി പരിമിതപ്പെടുത്തുന്നതിന് മറ്റ് പാരാമീറ്ററുകൾ ഉണ്ട്:

• limits.memory.enforce
• limits.memory.hugepages
• limits.memory.swap
• limits.memory.swap.priority

ടീം lxc config show സജ്ജീകരിച്ച പ്രയോഗിച്ച വിഭവ പരിധി ഉൾപ്പെടെ മുഴുവൻ കണ്ടെയ്നർ കോൺഫിഗറേഷനും പ്രദർശിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു:

lxc config show alp

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200220_13:00)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200220_13:00"
  image.type: squashfs
  limits.memory: 256MB
  volatile.base_image: 73a3093d4a5ce0148fd84b95369b3fbecd19a537ddfd2e2d20caa2eef0e8fd60
  volatile.eth0.host_name: veth75b6df07
  volatile.eth0.hwaddr: 00:16:3e:a1:e7:46
  volatile.idmap.base: "0"
  volatile.idmap.current: '[]'
  volatile.idmap.next: '[]'
  volatile.last_state.idmap: '[]'
  volatile.last_state.power: RUNNING
devices: {}
ephemeral: false
profiles:
- default
stateful: false
description: ""

CPU റിസോഴ്സ് പരിധി ^

സിപിയു ഉറവിടങ്ങൾ പരിമിതപ്പെടുത്താൻ നിരവധി മാർഗങ്ങളുണ്ട്. നിയന്ത്രണങ്ങളുടെ തരങ്ങൾ:

• limit.cpu - ഒന്നോ അതിലധികമോ CPU കോറുകളിലേക്ക് ഒരു കണ്ടെയ്നർ ബന്ധിപ്പിക്കുന്നു
• limits.cpu.allowance - സമയപരിധി കടന്നുപോകുമ്പോൾ CFS ഷെഡ്യൂളർ ക്വാട്ടകൾ അല്ലെങ്കിൽ ശതമാനം കടന്നുപോകുമ്പോൾ സാർവത്രിക CPU റിസോഴ്സ് പങ്കിടൽ സംവിധാനം നിയന്ത്രിക്കുന്നു
• limits.cpu.priority - ഒരു കൂട്ടം പ്രോസസ്സറുകൾ പങ്കിടുന്ന ഒന്നിലധികം സംഭവങ്ങൾക്ക് ഒരേ ശതമാനം പ്രൊസസറുകൾ നൽകുമ്പോൾ ഷെഡ്യൂളർ മുൻഗണന

lxc config set alp limits.cpu.allowance 40%

lxc config show alp

architecture: x86_64
config:
  image.architecture: amd64
  image.description: Alpine 3.11 amd64 (20200220_13:00)
  image.os: Alpine
  image.release: "3.11"
  image.serial: "20200220_13:00"
  image.type: squashfs
  limits.cpu.allowance: 40%
  limits.memory: 256MB
  volatile.base_image: 73a3093d4a5ce0148fd84b95369b3fbecd19a537ddfd2e2d20caa2eef0e8fd60
  volatile.eth0.host_name: veth75b6df07
  volatile.eth0.hwaddr: 00:16:3e:a1:e7:46
  volatile.idmap.base: "0"
  volatile.idmap.current: '[]'
  volatile.idmap.next: '[]'
  volatile.last_state.idmap: '[]'
  volatile.last_state.power: RUNNING
devices: {}
ephemeral: false
profiles:
- default
stateful: false
description: ""

ഡിസ്ക് സ്ഥല പരിമിതി ^

അത്തരം നിയന്ത്രണങ്ങൾക്ക് പുറമേ limits.read, limits.write കണ്ടെയ്നർ ഉപയോഗിക്കുന്ന ഡിസ്ക് സ്ഥലത്തിന്റെ അളവും നമുക്ക് പരിമിതപ്പെടുത്താം (ZFS അല്ലെങ്കിൽ BTRFS-ൽ മാത്രം പ്രവർത്തിക്കുന്നു):

lxc config device set alp root size=2GB

ഇൻസ്റ്റാളേഷന് ശേഷം, പരാമീറ്ററിൽ devices.root.size നമുക്ക് സെറ്റ് പരിധി പരിശോധിക്കാം:

lxc config show alp
...
devices:
  root:
    path: /
    pool: hddpool
    size: 2GB
    type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""

ഉപയോഗിച്ച ഡിസ്ക് ക്വാട്ടകൾ കാണുന്നതിന് നമുക്ക് കമാൻഡിൽ നിന്ന് ലഭിക്കും lxc info:

lxc info alp
...
Resources:
  Processes: 5
  Disk usage:
    root: 1.05GB
  CPU usage:
    CPU usage (in seconds): 1
  Memory usage:
    Memory (current): 5.46MB
  Network usage:
    eth0:
      Bytes received: 802B
      Bytes sent: 1.59kB
      Packets received: 4
      Packets sent: 14
    lo:
      Bytes received: 0B
      Bytes sent: 0B
      Packets received: 0
      Packets sent: 0

കണ്ടെയ്‌നറിന്റെ റൂട്ട് ഉപകരണത്തിന്റെ പരിധി ഞങ്ങൾ 2GB ആയി സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിലും, സിസ്റ്റം യൂട്ടിലിറ്റികൾ df ഈ നിയന്ത്രണം കാണില്ല. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ ഒരു ചെറിയ പരിശോധന നടത്തുകയും അത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കണ്ടെത്തുകയും ചെയ്യും.

നമുക്ക് സമാനമായ 2 പുതിയ കണ്ടെയ്‌നറുകൾ സൃഷ്ടിക്കാം സംഭരണ ​​കുളം (hddpool):

lxc init alpine3 alp1 --storage=hddpool --profile=default --profile=hddroot
lxc init alpine3 alp2 --storage=hddpool --profile=default --profile=hddroot

lxc list
+------+---------+------------------+------+-----------+-----------+
| NAME |  STATE  |       IPV4       | IPV6 |   TYPE    | SNAPSHOTS |
+------+---------+------------------+------+-----------+-----------+
| alp1 | RUNNING | 10.0.5.46 (eth0) |      | CONTAINER | 0         |
+------+---------+------------------+------+-----------+-----------+
| alp2 | RUNNING | 10.0.5.30 (eth0) |      | CONTAINER | 0         |
+------+---------+------------------+------+-----------+-----------+

കണ്ടെയ്‌നറുകളിലൊന്നിൽ നമുക്ക് 1GB ഫയൽ സൃഷ്‌ടിക്കാം:

lxc exec alp1 -- dd if=/dev/urandom of=file.img bs=1M count=1000

ഫയൽ സൃഷ്ടിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കാം:

lxc exec alp1 -- ls -lh
total 1000M  
-rw-r--r--    1 root     root     1000.0M Mar 27 10:16 file.img

ഞങ്ങൾ രണ്ടാമത്തെ കണ്ടെയ്‌നറിൽ നോക്കിയാൽ, അതേ സ്ഥലത്ത് ഒരു ഫയലിന്റെ നിലനിൽപ്പിനായി പരിശോധിക്കുക, അപ്പോൾ ഈ ഫയൽ അവിടെ ഉണ്ടാകില്ല, കണ്ടെയ്‌നറുകൾ സ്വന്തമായി സൃഷ്‌ടിച്ചതിനാൽ അത് പ്രതീക്ഷിക്കുന്നു. സംഭരണ ​​വോളിയം ഒരേ പോലെ സംഭരണ ​​കുളം:

lxc exec alp2 -- ls -lh
total 0

എന്നാൽ അത് ഉത്പാദിപ്പിക്കുന്ന മൂല്യങ്ങൾ താരതമ്യം ചെയ്യാം df ഒന്നിലും മറ്റൊന്നിലും:

lxc exec alp1 -- df -hT
Filesystem           Type            Size      Used Available Use% Mounted on
/dev/loop1           btrfs           9.3G   1016.4M      7.8G  11% /
...

lxc exec alp2 -- df -hT
Filesystem           Type            Size      Used Available Use% Mounted on
/dev/loop1           btrfs           9.3G   1016.4M      7.8G  11% /
...

ഉപകരണം /dev/loop1 റൂട്ട് പാർട്ടീഷൻ പോലെ മൌണ്ട് ചെയ്തിരിക്കുന്നു സംഭരണ ​​കുളം ഈ കണ്ടെയ്‌നറുകൾ ഉപയോഗിക്കുന്നതിനാൽ അവ അതിന്റെ വോളിയം രണ്ടായി പങ്കിടുന്നു.

വിഭവ ഉപഭോഗ സ്ഥിതിവിവരക്കണക്കുകൾ ^

കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു കണ്ടെയ്‌നറിനായുള്ള ഉറവിട ഉപഭോഗ സ്ഥിതിവിവരക്കണക്കുകൾ കാണാൻ കഴിയും:

lxc info alp

Name: alp
Location: none
Remote: unix://
Architecture: x86_64
Created: 2020/04/08 18:05 UTC
Status: Running
Type: container
Profiles: default, hddroot
Pid: 19219
Ips:
  eth0: inet    10.0.5.5        veth2a1dc59d
  eth0: inet6   fe80::216:3eff:fe0e:e271        veth2a1dc59d
  lo:   inet    127.0.0.1
  lo:   inet6   ::1
Resources:
  Processes: 5
  Disk usage:
    root: 495.62kB
  CPU usage:
    CPU usage (in seconds): 1
  Memory usage:
    Memory (current): 4.79MB
  Network usage:
    eth0:
      Bytes received: 730B
      Bytes sent: 1.59kB
      Packets received: 3
      Packets sent: 14
    lo:
      Bytes received: 0B
      Bytes sent: 0B
      Packets received: 0
      Packets sent: 0

സ്നാപ്പ്ഷോട്ടുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു ^

സ്‌നാപ്പ്‌ഷോട്ടുകൾ സൃഷ്‌ടിക്കാനും അവയിൽ നിന്ന് കണ്ടെയ്‌നർ നില പുനഃസ്ഥാപിക്കാനും എൽഎക്‌സ്‌ഡിക്ക് കഴിവുണ്ട്.

ഒരു സ്നാപ്പ്ഷോട്ട് സൃഷ്ടിക്കാൻ, ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

lxc snapshot alp snapshot1

സംഘം lxc snapshot താക്കോലൊന്നും ലഭ്യമല്ല list, അതിനാൽ, സ്നാപ്പ്ഷോട്ടുകളുടെ ലിസ്റ്റ് കാണുന്നതിന്, കണ്ടെയ്നറിനെക്കുറിച്ചുള്ള പൊതുവായ വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്ന കമാൻഡ് നിങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട്:

lxc info alp
...
...
Snapshots:
  snapshot1 (taken at 2020/04/08 18:18 UTC) (stateless)

കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു സ്നാപ്പ്ഷോട്ടിൽ നിന്ന് ഒരു കണ്ടെയ്നർ പുനഃസ്ഥാപിക്കാം lxc restore പുനഃസ്ഥാപിക്കൽ നടത്തേണ്ട കണ്ടെയ്നറും സ്നാപ്പ്ഷോട്ട് അപരനാമവും വ്യക്തമാക്കുന്നു:

lxc restore alp snapshot1

ഒരു സ്നാപ്പ്ഷോട്ട് ഇല്ലാതാക്കാൻ താഴെ പറയുന്ന കമാൻഡ് ഉപയോഗിക്കുന്നു. കമാൻഡ് സിന്റാക്സ് മറ്റെല്ലാത്തിനും സമാനമല്ല എന്നത് ശ്രദ്ധിക്കുക; ഇവിടെ നിങ്ങൾ കണ്ടെയ്‌നറിന്റെ പേരിന് ശേഷം ഒരു ഫോർവേഡ് സ്ലാഷ് വ്യക്തമാക്കേണ്ടതുണ്ട്. സ്ലാഷ് ഒഴിവാക്കിയാൽ, ഒരു സ്നാപ്പ്ഷോട്ട് ഇല്ലാതാക്കാനുള്ള കമാൻഡ് ഒരു കണ്ടെയ്നർ ഇല്ലാതാക്കാനുള്ള കമാൻഡായി വ്യാഖ്യാനിക്കപ്പെടുന്നു!

lxc delete alp/snapshot1

മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഞങ്ങൾ സ്‌റ്റേറ്റ്‌ലെസ് സ്‌നാപ്പ്‌ഷോട്ടുകൾ എന്ന് വിളിക്കുന്നത് നോക്കി. LXD- ന് മറ്റൊരു തരം സ്നാപ്പ്ഷോട്ടുകൾ ഉണ്ട് - സ്റ്റേറ്റ്ഫുൾ, ഇത് കണ്ടെയ്നറിലെ എല്ലാ പ്രക്രിയകളുടെയും നിലവിലെ അവസ്ഥ സംരക്ഷിക്കുന്നു. സ്‌റ്റേറ്റ്‌ഫുൾ സ്‌നാപ്പ്‌ഷോട്ടുകളുമായി ബന്ധപ്പെട്ട രസകരവും ഉപയോഗപ്രദവുമായ നിരവധി സവിശേഷതകൾ ഉണ്ട്.

പിന്നെ എന്തുണ്ട്? ^

• പൈത്തൺ ഡെവലപ്പർമാർക്കായി ഒരു മൊഡ്യൂൾ ലഭ്യമാണ് PyLXD ഇത് LXD-ലേക്ക് ഒരു API നൽകുന്നു

അപ്ഡേറ്റ് 10.04.2020/15/00 XNUMX:XNUMX: നാവിഗേഷൻ ചേർത്തു

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