એલએક્સડી નેક્સ્ટ જનરેશન સિસ્ટમ કન્ટેનર મેનેજર છે, તેથી તે કહે છે સ્રોત. તે વર્ચ્યુઅલ મશીનો જેવું જ યુઝર ઈન્ટરફેસ આપે છે, પરંતુ તેના બદલે Linux કન્ટેનરનો ઉપયોગ કરે છે.

LXD કોર એ એક વિશેષાધિકૃત ડિમન છે (રુટ અધિકારો સાથે ચાલતી સેવા) કે જે સ્થાનિક યુનિક્સ સોકેટ મારફતે REST API પ્રદાન કરે છે, તેમજ નેટવર્ક મારફતે જો યોગ્ય રૂપરેખાંકન સ્થાપિત થયેલ હોય. LXD સાથે પ્રદાન કરેલ કમાન્ડ લાઇન ટૂલ જેવા ગ્રાહકો, આ REST API દ્વારા વિનંતીઓ કરે છે. આનો અર્થ એ છે કે તમે સ્થાનિક હોસ્ટ અથવા રિમોટ હોસ્ટને ઍક્સેસ કરી રહ્યાં છો, બધું એકસરખું કામ કરે છે.

આ લેખમાં અમે LXD ની વિભાવનાઓ પર વિગતવાર ધ્યાન આપીશું નહીં, અમે કન્ટેનરની સમાંતર QEMU વર્ચ્યુઅલ મશીનો માટે સપોર્ટના LXD ના નવીનતમ સંસ્કરણોમાં તાજેતરમાં અમલીકરણ સહિત દસ્તાવેજીકરણમાં દર્શાવેલ બધી ઉપલબ્ધ ક્ષમતાઓને ધ્યાનમાં લઈશું નહીં. તેના બદલે, અમે કન્ટેનર મેનેજમેન્ટની માત્ર મૂળભૂત બાબતો શીખીશું - સ્ટોરેજ પૂલ સેટ કરવા, નેટવર્કિંગ કરવું, કન્ટેનર ચલાવવું, સંસાધન મર્યાદા લાગુ કરવી અને સ્નેપશોટનો ઉપયોગ કેવી રીતે કરવો જેથી તમે LXD ની મૂળભૂત સમજ મેળવી શકો અને Linux પર કન્ટેનરનો ઉપયોગ કરી શકો.

સંપૂર્ણ માહિતી માટે, કૃપા કરીને સત્તાવાર સ્ત્રોતનો સંદર્ભ લો:

• વિકાસકર્તાની વેબસાઇટ
• Документация
• ફોરમ

નેવિગેશન

• ઇન્સ્ટોલેશન LXD
  • ઉબુન્ટુ વિતરણો પર LXD ઇન્સ્ટોલ કરી રહ્યું છે
  • આર્ક Linux વિતરણો પર LXD ઇન્સ્ટોલ કરી રહ્યું છે
• સ્ટોરેજ LXD (સ્ટોરેજ)
• LXD શરૂ કરી રહ્યાં છીએ
  • સ્ટોરેજ પૂલ માટે ફાઇલ સિસ્ટમ પસંદ કરી રહ્યા છીએ
  • વિઝાર્ડનો ઉપયોગ કરીને નેટવર્ક અને સ્ટોરેજ પૂલ શરૂ કરી રહ્યા છીએ
  • વધારાનો સ્ટોરેજ પૂલ બનાવવો
    • સ્ટોરેજ પૂલનું કદ વધારવું
    • લૂપબેક ઉપકરણ સ્લોટમાં લૂપબેક ફાઇલનું સ્વતઃ નિવેશ
  • સલામતી. કન્ટેનર વિશેષાધિકારો
  • વર્ચ્યુઅલ નેટવર્ક સ્વીચ બનાવી રહ્યા છીએ
  • રૂપરેખાંકન પ્રોફાઇલ
    • તમારી પ્રોફાઇલ સંપાદિત કરી રહ્યું છે
    • નવી પ્રોફાઇલ બનાવી રહ્યા છીએ
  • છબી ભંડાર
    • દૂરસ્થ છબી ભંડાર
    • સ્થાનિક ઇમેજ રિપોઝીટરી
  • LXD રૂપરેખાંકન
• કન્ટેનર બનાવવું અને તેનું સંચાલન કરવું
  • સ્થિર IP સરનામું સેટ કરી રહ્યું છે
  • એક કન્ટેનર દૂર કરી રહ્યા છીએ
  • કન્ટેનર ઍક્સેસ
  • કન્ટેનર સંસાધન સંચાલન
    • RAM સંસાધન મર્યાદા
    • CPU સંસાધન મર્યાદા
    • ડિસ્ક જગ્યા મર્યાદા
    • સંસાધન વપરાશના આંકડા
  • સ્નેપશોટ સાથે કામ

ઇન્સ્ટોલેશન LXD ^

ઉબુન્ટુ વિતરણો પર LXD ઇન્સ્ટોલ કરી રહ્યું છે ^

ઉબુન્ટુ 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✓  -

આર્ક Linux વિતરણો પર LXD ઇન્સ્ટોલ કરી રહ્યું છે ^

સિસ્ટમ પર 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 અથવા નિયમિત ડિરેક્ટરીઓ. દરેક સંગ્રહ પૂલ વોલ્યુમોમાં વહેંચાયેલું છે (સ્ટોરેજ વોલ્યુમ) જેમાં છબીઓ, કન્ટેનર અથવા અન્ય હેતુઓ માટેનો ડેટા હોય છે.

• છબીઓ - આ લિનક્સ કર્નલ વિના અને બાહ્ય સ્ત્રોતોમાંથી ઉપલબ્ધ વિશેષરૂપે એસેમ્બલ કરેલા વિતરણો છે
• કન્ટેનર - આ ઈમેજોમાંથી ડિપ્લોય કરેલ ડિસ્ટ્રિબ્યુશન છે, ઉપયોગ માટે તૈયાર છે
• સ્નેપશોટ - આ કન્ટેનરની સ્થિતિના સ્નેપશોટ છે કે જેના પર તમે પાછા આવી શકો છો

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 શરૂ કરી રહ્યાં છીએ ^

કન્ટેનર બનાવતા અને ઉપયોગ કરતા પહેલા, તમારે સામાન્ય LXD આરંભ કરવું આવશ્યક છે જે નેટવર્ક અને સ્ટોરેજ બનાવે છે અને ગોઠવે છે. આ આદેશને કૉલ કરીને સૂચિમાં ઉપલબ્ધ પ્રમાણભૂત ક્લાયંટ આદેશોનો ઉપયોગ કરીને જાતે કરી શકાય છે lxc --help અથવા આરંભ વિઝાર્ડનો ઉપયોગ કરીને lxd init થોડા પ્રશ્નોના જવાબ.

સ્ટોરેજ પૂલ માટે ફાઇલ સિસ્ટમ પસંદ કરી રહ્યા છીએ ^

આરંભ દરમિયાન, LXD કેટલાક પ્રશ્નો પૂછે છે, જેમાં ડિફોલ્ટ માટે ફાઇલ સિસ્ટમનો પ્રકાર નક્કી કરવાનો સમાવેશ થાય છે સંગ્રહ પૂલ. મૂળભૂત રીતે, BTRFS ફાઇલ સિસ્ટમ તેના માટે પસંદ થયેલ છે. બનાવટ પછી બીજા FS માં બદલવું અશક્ય હશે. FS પસંદ કરવા માટે તે સૂચવવામાં આવે છે લક્ષણ સરખામણી કોષ્ટક:

લક્ષણ
ડિરેક્ટરી
બીઆરટીએફએસ
LVM
ઝેડએફએસ
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. આ ફાઇલ સિસ્ટમ સરનામું મારા PC માં ભૌતિક SSD ડ્રાઇવને અનુરૂપ છે.

દ્વારા ભજવવામાં આવેલી ભૂમિકાની સમજને વિસ્તૃત કરવા માટે નીચેની ક્રિયાઓ સંગ્રહ પૂલ રીપોઝીટરીમાં, આપણે બીજું બનાવીશું સંગ્રહ પૂલ જે ભૌતિક રીતે અલગ પ્રકારની ડિસ્ક, HDD પર સ્થિત હશે. સમસ્યા એ છે કે 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 લૂપબેક ફાઈલ સમાવેશ થાય છે /mnt/work/lxd/hddpool.img, અને ઉપકરણમાં /dev/loop0 લૂપબેક ફાઈલ સમાવેશ થાય છે /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 પ્રક્રિયા વિશેષાધિકાર પ્રદાન કરે છે, જ્યાં:

• વિશેષાધિકૃત કન્ટેનર - આ એવા કન્ટેનર છે જેમાં UID અને GID સાથેની પ્રક્રિયાઓ યજમાન સિસ્ટમના માલિકને અનુરૂપ હોય છે. ઉદાહરણ તરીકે, 0 ના UID સાથે કન્ટેનરમાં ચાલતી પ્રક્રિયામાં 0 ના UID સાથે હોસ્ટ સિસ્ટમ પરની પ્રક્રિયાની જેમ જ ઍક્સેસ અધિકારો હોય છે. બીજા શબ્દોમાં કહીએ તો, કન્ટેનરમાં રુટ વપરાશકર્તા પાસે માત્ર તમામ અધિકારો નથી. કન્ટેનર, પણ યજમાન સિસ્ટમ પર પણ જો તે કન્ટેનરના અલગ નામ સ્થાનની બહાર જઈ શકે.

• બિનપ્રાપ્ત કન્ટેનર - આ એવા કન્ટેનર છે જેમાં પ્રક્રિયાઓ 0 થી 65535 સુધીની સંખ્યા સાથે UID અને GID ના માલિકની હોય છે, પરંતુ હોસ્ટ સિસ્ટમ માટે માલિક અનુક્રમે ઉમેરાયેલ SubUID અને SubGID બિટ્સનો ઉપયોગ કરીને માસ્ક કરે છે. ઉદાહરણ તરીકે, કન્ટેનરમાં UID=0 ધરાવતો વપરાશકર્તા યજમાન સિસ્ટમ પર તરીકે જોવામાં આવશે SubUID + UID. આ યજમાન સિસ્ટમને સુરક્ષિત કરે છે કારણ કે જો કન્ટેનરમાંની કોઈપણ પ્રક્રિયા તેના અલગ નામની જગ્યામાંથી છટકી જવા માટે સક્ષમ હોય, તો તે માત્ર એક અજાણી, ખૂબ ઊંચી UID/GID સાથેની પ્રક્રિયા તરીકે યજમાન સિસ્ટમ સાથે વાતચીત કરી શકે છે.

ડિફૉલ્ટ રૂપે, નવા બનાવેલા કન્ટેનરમાં બિનઅધિકૃત સ્થિતિ હોય છે અને તેથી આપણે સબયુઆઈડી અને સબજીઆઈડી વ્યાખ્યાયિત કરવી જોઈએ.

ચાલો બે રૂપરેખાંકન ફાઈલો બનાવીએ જેમાં આપણે અનુક્રમે સબયુઆઈડી અને સબજીઆઈડી માટે માસ્ક સેટ કરીશું:

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 માં દરેક કન્ટેનરનું પોતાનું રૂપરેખાંકન હોય છે અને તેને વૈશ્વિક સ્તરે જાહેર કરાયેલા રૂપરેખાંકનો સાથે વિસ્તૃત કરી શકે છે રૂપરેખાંકન પ્રોફાઇલ્સ. કન્ટેનર પર રૂપરેખાંકન રૂપરેખાઓ લાગુ કરવાથી કાસ્કેડ મોડેલ હોય છે, નીચેનું ઉદાહરણ આ દર્શાવે છે:

આ ઉદાહરણમાં, 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

એ નોંધવું અગત્યનું છે કે અમે ઉપકરણને રૂપરેખાંકન પ્રોફાઇલમાં વાસ્તવમાં ઉમેર્યું હોવાથી, જો અમે ઉપકરણમાં સ્થિર IP સરનામું નિર્દિષ્ટ કર્યું છે, તો પછી બધા કન્ટેનર જે આ પ્રોફાઇલનો ઉપયોગ કરશે તે સમાન IP સરનામું શેર કરશે. જો કન્ટેનર માટે ફાળવેલ સ્ટેટિક IP એડ્રેસ સાથે કન્ટેનર બનાવવાની જરૂર હોય, તો તમારે IP એડ્રેસ પેરામીટર સાથે કન્ટેનર લેવલ (સ્થાનિક રૂપરેખાંકન) પર નેટવર્ક ડિવાઇસ કન્ફિગરેશન બનાવવું જોઈએ, પ્રોફાઇલ લેવલ પર નહીં.

ચાલો પ્રોફાઇલ તપાસીએ:

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 એ ત્રણ રિમોટ સ્રોતોમાંથી છબીઓ પ્રાપ્ત કરવા માટે ગોઠવેલ છે:

• ઉબુન્ટુ: (સ્થિર ઉબુન્ટુ ઈમેજો માટે)
• ઉબુન્ટુ-દૈનિક: (દૈનિક ઉબુન્ટુ છબીઓ માટે)
• છબીઓ: (અન્ય ડિસ્ટ્રોસના સમૂહ માટે)

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.

છબીઓની સૂચિ પ્રદર્શિત કરવા માટે ફિલ્ટરિંગ ઉપલબ્ધ છે. નીચેનો આદેશ તમામ ઉપલબ્ધ વિતરણ આર્કિટેક્ચરની યાદી આપશે આલ્પાઇન લિનક્સ:

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 છબી કાઢી
છબીઓ કા Deleteી નાખો

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 જેમાં મૂલ્યો પસાર થાય છે репозиторий:образ અને પછી કન્ટેનર માટે ઇચ્છિત ID. રીપોઝીટરી સ્થાનિક તરીકે સ્પષ્ટ કરી શકાય છે local: તેથી કોઈપણ વૈશ્વિક છે. જો રીપોઝીટરી સ્પષ્ટ કરેલ નથી, તો પછી મૂળભૂત રીતે સ્થાનિક રીપોઝીટરીનો ઉપયોગ ઈમેજ શોધવા માટે થાય છે. જો ઇમેજ વૈશ્વિક રિપોઝીટરીમાંથી નિર્દિષ્ટ કરવામાં આવી હોય, તો ઇમેજ પ્રથમ સ્થાનિક રિપોઝીટરીમાં ડાઉનલોડ કરવામાં આવશે અને પછી કન્ટેનર બનાવવા માટે ઉપયોગમાં લેવામાં આવશે.

ચાલો અમારું પ્રથમ કન્ટેનર બનાવવા માટે નીચેનો આદેશ ચલાવીએ:

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

ચાલો આપણે અહીં ક્રમમાં ઉપયોગ કરીએ છીએ તે આદેશ કી જોઈએ:

• alpine3 — એક ઉપનામ (ઉર્ફે) ઈમેજ માટે સ્પષ્ટ થયેલ છે જે અગાઉ સ્થાનિક રીપોઝીટરીમાં અપલોડ કરવામાં આવી હતી. જો આ છબી માટે ઉપનામ બનાવવામાં આવ્યું ન હતું, તો પછી તમે હંમેશા તેના દ્વારા છબીનો સંદર્ભ લઈ શકો છો ફિંગરપ્રિંટ જે કોષ્ટકમાં દર્શાવેલ છે.
• alp - કન્ટેનર માટે ઓળખકર્તા સુયોજિત કરે છે
• --storage - આ કી સૂચવે છે કે જેમાં સંગ્રહ પૂલ એક કન્ટેનર બનાવવામાં આવશે
• --profile — આ કીઓ કાસ્કેડ કન્ટેનર પર અગાઉ બનાવેલ રૂપરેખાંકન પ્રોફાઇલ્સમાંથી રૂપરેખાંકન લાગુ કરે છે

અમે કન્ટેનર લોંચ કરીએ છીએ, જે વિતરણની ઇનિટ સિસ્ટમ શરૂ કરવાનું શરૂ કરે છે:

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 સરનામું સેટ કરી રહ્યું છે ^

જો આપણે નેટવર્ક ઉપકરણ માટે 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

અમે અલબત્ત માટે સ્થિર IP સરનામું સેટ કરી શકીએ છીએ 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 માં, તમે રૂપરેખાંકનના વિશિષ્ટ સમૂહનો ઉપયોગ કરીને કન્ટેનર સંસાધનોનું સંચાલન કરી શકો છો. કન્ટેનર રૂપરેખાંકન પરિમાણોની સંપૂર્ણ સૂચિ મળી શકે છે દસ્તાવેજીકરણમાં.

RAM સંસાધન મર્યાદા ^

પેરામીટર limits.memory કન્ટેનર માટે ઉપલબ્ધ RAM ની માત્રાને મર્યાદિત કરે છે. મૂલ્ય એક સંખ્યા અને એક છે ઉપલબ્ધ પ્રત્યયો.

ચાલો કન્ટેનરની RAM મર્યાદા 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 સંસાધન મર્યાદા ^

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

સ્નેપશોટ સાથે કામ ^

LXD પાસે સ્નેપશોટ બનાવવાની અને તેમાંથી કન્ટેનરની સ્થિતિ પુનઃસ્થાપિત કરવાની ક્ષમતા છે.

સ્નેપશોટ બનાવવા માટે, નીચેનો આદેશ ચલાવો:

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