एलएक्सडी पुढील पिढीचे सिस्टम कंटेनर व्यवस्थापक आहे, म्हणून ते म्हणतात स्त्रोत. हे व्हर्च्युअल मशीन प्रमाणेच वापरकर्ता इंटरफेस देते, परंतु त्याऐवजी लिनक्स कंटेनर वापरते.

LXD कोर एक विशेषाधिकार प्राप्त डिमन आहे (रूट अधिकारांसह चालणारी सेवा) जी स्थानिक युनिक्स सॉकेटद्वारे, तसेच योग्य कॉन्फिगरेशन स्थापित असल्यास नेटवर्कद्वारे REST API प्रदान करते. क्लायंट, जसे की LXD सह प्रदान केलेले कमांड लाइन टूल, या REST API द्वारे विनंती करतात. याचा अर्थ असा की तुम्ही स्थानिक होस्ट किंवा रिमोट होस्टमध्ये प्रवेश करत असलात तरीही, सर्वकाही समान कार्य करते.

या लेखात आम्ही LXD च्या संकल्पनांवर तपशीलवार विचार करणार नाही, आम्ही कंटेनरच्या समांतर QEMU व्हर्च्युअल मशीनसाठी समर्थनाच्या LXD च्या नवीनतम आवृत्त्यांमध्ये अलीकडील अंमलबजावणीसह दस्तऐवजीकरणात वर्णन केलेल्या सर्व उपलब्ध क्षमतांचा विचार करणार नाही. त्याऐवजी, आम्ही फक्त कंटेनर व्यवस्थापनाच्या मूलभूत गोष्टी शिकू - स्टोरेज पूल सेट करणे, नेटवर्किंग करणे, कंटेनर चालवणे, संसाधन मर्यादा लागू करणे आणि स्नॅपशॉट कसे वापरायचे जेणेकरुन तुम्हाला LXD ची मूलभूत माहिती मिळेल आणि Linux वर कंटेनर वापरता येतील.

संपूर्ण माहितीसाठी, कृपया अधिकृत स्रोत पहा:

• विकसकाची वेबसाइट
• दस्तऐवजीकरण
• फोरम

नॅव्हिगेशन

• स्थापना LXD
  • उबंटू वितरणांवर LXD स्थापित करणे
  • आर्क लिनक्स वितरणांवर 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✓  -

आर्क लिनक्स वितरणांवर 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 फाइल सिस्टीम निवडली होती, नंतर सूची मिळवा स्टोरेज व्हॉल्यूम किंवा subvolums 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 काही प्रश्नांची उत्तरे.

स्टोरेज पूलसाठी फाइल सिस्टम निवडत आहे ^

इनिशिएलायझेशन दरम्यान, एलएक्सडी डीफॉल्टसाठी फाइल सिस्टम प्रकार निश्चित करण्यासह अनेक प्रश्न विचारते स्टोरेज पूल. डीफॉल्टनुसार, त्यासाठी BTRFS फाइल प्रणाली निवडली जाते. निर्मितीनंतर दुसर्या FS मध्ये बदलणे अशक्य होईल. FS निवडण्यासाठी हे सुचवले आहे वैशिष्ट्य तुलना सारणी:

वैशिष्ट्य
निर्देशिका
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. हा फाइल सिस्टम पत्ता माझ्या 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 असलेली प्रक्रिया म्हणून होस्ट सिस्टमशी संवाद साधू शकते.

डीफॉल्टनुसार, नव्याने तयार केलेल्या कंटेनर्सना अनप्रिव्हिलेज्ड स्टेटस आहे आणि म्हणून आम्ही सबयूआयडी आणि सबजीआयडी परिभाषित करणे आवश्यक आहे.

चला दोन कॉन्फिगरेशन फाईल्स बनवू ज्यामध्ये आपण अनुक्रमे 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       |
+--------+----------+---------+-------------+---------+

लिनक्स वितरणाचे मानक साधन वापरून नेटवर्क डिव्हाइस तयार केले गेले आहे हे देखील तुम्ही सत्यापित करू शकता - 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: []

प्रतिमा भांडार ^

लिनक्स कर्नल नसलेल्या प्रतिमांपासून कंटेनर तयार केले जातात. म्हणून, कंटेनर चालवण्यापूर्वी, ते या प्रतिमेवरून तैनात केले जाणे आवश्यक आहे. प्रतिमांचा स्त्रोत एक स्थानिक भांडार आहे ज्यामध्ये बाह्य भांडारांमधून प्रतिमा डाउनलोड केल्या जातात.

दूरस्थ प्रतिमा भांडार ^

डीफॉल्टनुसार, LXD तीन रिमोट स्त्रोतांकडून प्रतिमा प्राप्त करण्यासाठी कॉन्फिगर केले आहे:

• उबंटू: (स्थिर उबंटू प्रतिमांसाठी)
• 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.

प्रतिमांची सूची प्रदर्शित करण्यासाठी फिल्टरिंग उपलब्ध आहे. खालील आदेश सर्व उपलब्ध वितरण आर्किटेक्चर्सची यादी करेल अल्पाइन लिनक्स:

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 — या की कॅस्केड पूर्वी तयार केलेल्या कॉन्फिगरेशन प्रोफाइलमधून कंटेनरवर कॉन्फिगरेशन लागू करतात

आम्ही कंटेनर लॉन्च करतो, जो वितरणाची इनिट सिस्टम लाँच करण्यास प्रारंभ करतो:

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 मध्ये आणखी एक प्रकारचे स्नॅपशॉट आहेत - स्टेटफुल, जे कंटेनरमधील सर्व प्रक्रियांची सद्य स्थिती वाचवते. स्टेटफुल स्नॅपशॉटशी संबंधित अनेक मनोरंजक आणि उपयुक्त वैशिष्ट्ये आहेत.

अजून काय? ^

• Python विकासकांसाठी एक मॉड्यूल उपलब्ध आहे PyLXD जे LXD ला API प्रदान करते

अपडेट 10.04.2020/15/00 XNUMX:XNUMX: नेव्हिगेशन जोडले

स्त्रोत: www.habr.com