एलएक्सडी यह अगली पीढ़ी का सिस्टम कंटेनर मैनेजर है, ऐसा यह कहता है स्रोत. यह वर्चुअल मशीनों के समान एक यूजर इंटरफेस प्रदान करता है, लेकिन इसके बजाय लिनक्स कंटेनर का उपयोग करता है।

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

इस लेख में हम LXD की अवधारणाओं पर विस्तार से ध्यान नहीं देंगे, हम दस्तावेज़ीकरण में उल्लिखित सभी उपलब्ध क्षमताओं पर विचार नहीं करेंगे, जिसमें कंटेनरों के समानांतर QEMU वर्चुअल मशीनों के लिए LXD के नवीनतम संस्करणों में समर्थन का हालिया कार्यान्वयन भी शामिल है। इसके बजाय, हम केवल कंटेनर प्रबंधन की मूल बातें सीखेंगे - स्टोरेज पूल स्थापित करना, नेटवर्किंग, कंटेनर चलाना, संसाधन सीमाएं लागू करना और स्नैपशॉट का उपयोग कैसे करें ताकि आप एलएक्सडी की बुनियादी समझ प्राप्त कर सकें और लिनक्स पर कंटेनर का उपयोग कर सकें।

पूरी जानकारी के लिए कृपया आधिकारिक स्रोत देखें:

• डेवलपर की वेबसाइट
• अभिलेख
• मंच

नेविगेशन

• स्थापना एलएक्सडी
  • उबंटू वितरण पर एलएक्सडी स्थापित करना
  • आर्क लिनक्स वितरण पर एलएक्सडी स्थापित करना
• भंडारण एलएक्सडी (भंडारण)
• एलएक्सडी आरंभ किया जा रहा है
  • स्टोरेज पूल के लिए फ़ाइल सिस्टम का चयन करना
  • विज़ार्ड का उपयोग करके नेटवर्क और स्टोरेज पूल को प्रारंभ करना
  • एक अतिरिक्त संग्रहण पूल बनाना
    • भंडारण पूल का आकार बढ़ाना
    • लूपबैक डिवाइस स्लॉट में लूपबैक फ़ाइल का स्वचालित सम्मिलन
  • सुरक्षा। कंटेनर विशेषाधिकार
  • वर्चुअल नेटवर्क स्विच बनाना
  • कॉन्फ़िगरेशन प्रोफ़ाइल
    • अपनी प्रोफ़ाइल संपादित करना
    • नई प्रोफ़ाइलें बनाना
  • छवि भंडार
    • दूरस्थ छवि भंडार
    • स्थानीय छवि भंडार
  • एलएक्सडी कॉन्फ़िगरेशन
• एक कंटेनर बनाना और प्रबंधित करना
  • एक स्थिर आईपी पता सेट करना
  • एक कंटेनर हटाना
  • कंटेनर पहुंच
  • कंटेनर संसाधन प्रबंधन
    • रैम संसाधन सीमा
    • सीपीयू संसाधन सीमा
    • डिस्क स्थान की सीमा
    • संसाधन खपत आँकड़े
  • स्नैपशॉट के साथ कार्य करना

स्थापना एलएक्सडी ^

उबंटू वितरण पर एलएक्सडी स्थापित करना ^

Ubuntu 19.10 वितरण पैकेज में lxd पर प्रसारण है स्नैप पैकेज:

apt search lxd

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

इसका मतलब है कि दो पैकेज एक साथ इंस्टॉल किए जाएंगे, एक सिस्टम पैकेज के रूप में और दूसरा स्नैप पैकेज के रूप में। किसी सिस्टम पर दो पैकेज स्थापित करने से कुछ समस्याएँ पैदा हो सकती हैं जहाँ स्नैप पैकेज प्रबंधक द्वारा स्नैप पैकेज हटा दिए जाने पर सिस्टम पैकेज अनाथ हो सकता है।

पैकेज ढूंढें lxd स्नैप रिपॉजिटरी में आप निम्न कमांड का उपयोग कर सकते हैं:

snap find lxd

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

कमांड चलाकर list आप यह सुनिश्चित कर सकते हैं कि package 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 पैकेज को स्थापित करने के लिए, आपको निम्नलिखित कमांड चलाने की आवश्यकता है, पहला रिपॉजिटरी में उपलब्ध सिस्टम पर पैकेजों की सूची को अपडेट करेगा, दूसरा सीधे पैकेज को इंस्टॉल करेगा:

sudo pacman -Syyu && sudo pacman -S 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

भंडारण एलएक्सडी (भंडारण) ^

आरंभीकरण शुरू होने से पहले, हमें यह समझने की आवश्यकता है कि एलएक्सडी में भंडारण तार्किक रूप से कैसे व्यवस्थित है।

भंडारण (भंडारण) इसमें शामिल हैं एक या अधिक से भंडारण पूल जो ZFS, BTRFS, LVM या नियमित निर्देशिकाओं जैसे समर्थित फ़ाइल सिस्टमों में से एक का उपयोग करता है। प्रत्येक भंडारण पूल मात्राओं में विभाजित है (भंडारण की मात्रा) जिसमें अन्य उद्देश्यों के लिए चित्र, कंटेनर या डेटा शामिल हैं।

• कल्पना - ये लिनक्स कर्नेल के बिना विशेष रूप से इकट्ठे वितरण हैं और बाहरी स्रोतों से उपलब्ध हैं
• कंटेनर - ये छवियों से तैनात वितरण हैं, जो उपयोग के लिए तैयार हैं
• स्नैपशॉट्स - ये कंटेनरों की स्थिति के स्नैपशॉट हैं जिन पर आप वापस लौट सकते हैं

LXD में स्टोरेज प्रबंधित करने के लिए, कमांड का उपयोग करें lxc storage एक प्रमाणपत्र जिसके लिए आप कुंजी निर्दिष्ट करके प्राप्त कर सकते हैं - lxc storage --help

निम्न आदेश सभी की एक सूची प्रदर्शित करता है भंडारण पूल एलएक्सडी भंडारण में:

lxc storage list

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

सभी की सूची देखने के लिए भंडारण की मात्रा चयनित में भंडारण पूल टीम की सेवा करता है lxc storage volume list:

lxc storage volume list hddpool

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

lxc storage volume list ssdpool

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

इसके अलावा, अगर के लिए भंडारण पूल बनाते समय, BTRFS फ़ाइल सिस्टम का चयन किया गया था, फिर एक सूची प्राप्त करें भंडारण की मात्रा या सबवॉल्यूम BTRFS व्याख्या में, आप इस फ़ाइल सिस्टम के टूलकिट का उपयोग कर सकते हैं:

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

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

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

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

एलएक्सडी आरंभ किया जा रहा है ^

कंटेनर बनाने और उपयोग करने से पहले, आपको एक सामान्य LXD आरंभीकरण करना होगा जो नेटवर्क और स्टोरेज को बनाता और कॉन्फ़िगर करता है। यह मानक क्लाइंट कमांड का उपयोग करके मैन्युअल रूप से किया जा सकता है जो कमांड को कॉल करके सूची में उपलब्ध हैं lxc --help या आरंभीकरण विज़ार्ड का उपयोग करना lxd init कुछ प्रश्नों का उत्तर दे रहा हूँ।

स्टोरेज पूल के लिए फ़ाइल सिस्टम का चयन करना ^

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

Feature
निर्देशिका
बीटीआरएफएस
एलवीएम
ZFS
सीईपीएच

अनुकूलित छवि भंडारण
नहीं
हाँ
हाँ
हाँ
हाँ

अनुकूलित उदाहरण निर्माण
नहीं
हाँ
हाँ
हाँ
हाँ

अनुकूलित स्नैपशॉट निर्माण
नहीं
हाँ
हाँ
हाँ
हाँ

अनुकूलित छवि स्थानांतरण
नहीं
हाँ
नहीं
हाँ
हाँ

अनुकूलित उदाहरण स्थानांतरण
नहीं
हाँ
नहीं
हाँ
हाँ

लिखने पर नकल
नहीं
हाँ
हाँ
हाँ
हाँ

ब्लॉक आधारित
नहीं
नहीं
हाँ
नहीं
हाँ

तत्काल क्लोनिंग
नहीं
हाँ
हाँ
हाँ
हाँ

एक कंटेनर के अंदर प्रयोग करने योग्य स्टोरेज ड्राइवर
हाँ
हाँ
नहीं
नहीं
नहीं

पुराने स्नैपशॉट से पुनर्स्थापित करें (नवीनतम नहीं)
हाँ
हाँ
हाँ
नहीं
हाँ

भंडारण कोटा
हाँ(*)
हाँ
हाँ
हाँ
नहीं

विज़ार्ड का उपयोग करके नेटवर्क और स्टोरेज पूल को प्रारंभ करना ^

अगला कमांड जिस पर हम गौर करेंगे वह इनिशियलाइज़ेशन विज़ार्ड का उपयोग करके सरल प्रश्नों के उत्तर देकर एलएक्सडी के मुख्य घटकों को स्थापित करने का सुझाव देता है।

चलाने के आदेश lxc init और कोलन के बाद प्रश्नों के उत्तर दर्ज करें जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है या अपनी शर्तों के अनुसार उन्हें बदलें:

lxd init

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

एक अतिरिक्त संग्रहण पूल बनाना ^

पिछले चरण में हमने बनाया था भंडारण पूल जिसे नाम दिया गया ssdpool और जिसकी फ़ाइल मेरे सिस्टम पर स्थित है /var/lib/lxd/disks/ssdpool.img. यह फ़ाइल सिस्टम पता मेरे पीसी में भौतिक एसएसडी ड्राइव से मेल खाता है।

निम्नलिखित क्रियाएं, द्वारा निभाई गई भूमिका की समझ का विस्तार करने के लिए भंडारण पूल रिपॉजिटरी में, हम दूसरा बनाएंगे भंडारण पूल जो भौतिक रूप से एक अलग प्रकार की डिस्क, एचडीडी पर स्थित होगा। समस्या यह है कि LXD आपको निर्माण करने की अनुमति नहीं देता है भंडारण पूल पते से बाहर /var/lib/lxd/disks/ और प्रतीकात्मक लिंक भी काम नहीं करेंगे, डेवलपर की प्रतिक्रिया देखें. हम इनिशियलाइज़ेशन/फ़ॉर्मेटिंग के दौरान इस सीमा को बायपास कर सकते हैं भंडारण पूल कुंजी में इसे निर्दिष्ट करके लूपबैक फ़ाइल के पथ के बजाय एक ब्लॉक डिवाइस के रूप में मान निर्दिष्ट करके source.

तो, बनाने से पहले भंडारण पूल आपको अपने फ़ाइल सिस्टम पर एक लूपबैक फ़ाइल या मौजूदा विभाजन को परिभाषित करने की आवश्यकता है जिसका वह उपयोग करेगा। ऐसा करने के लिए, हम एक फ़ाइल बनाएंगे और उसका उपयोग करेंगे जिसका आकार हम 10GB तक सीमित करेंगे:

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

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

आइए लूपबैक फ़ाइल को एक निःशुल्क लूपबैक डिवाइस से कनेक्ट करें:

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

/dev/loop1

कुंजी को धन्यवाद --show कमांड निष्पादित करने से स्क्रीन पर उस डिवाइस का नाम वापस आ जाता है जिसमें हमारी लूपबैक फ़ाइल जुड़ी हुई है। यदि आवश्यक हो, तो हम यह सुनिश्चित करने के लिए कि हमारे कार्य सही हैं, इस प्रकार के सभी व्यस्त उपकरणों की एक सूची प्रदर्शित कर सकते हैं:

losetup -l

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

सूची से आप पा सकते हैं कि डिवाइस में क्या है /dev/loop1 लूपबैक फ़ाइल शामिल है /mnt/work/lxd/hddpool.img, और डिवाइस में /dev/loop0 लूपबैक फ़ाइल शामिल है /var/lib/lxd/disks/ssdpool.img जो डिफ़ॉल्ट से मेल खाता है भंडारण पूल.

निम्न आदेश एक नया बनाता है भंडारण पूल एलएक्सडी में लूपबैक फ़ाइल के आधार पर जिसे हमने अभी तैयार किया है। एलएक्सडी लूपबैक फ़ाइल को प्रारूपित करेगा /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.

सुरक्षा। कंटेनर विशेषाधिकार ^

चूंकि सभी कंटेनर प्रक्रियाएं वास्तव में अपने कर्नेल का उपयोग करके होस्ट सिस्टम पर अलगाव में चलती हैं, होस्ट सिस्टम में कंटेनर प्रक्रियाओं की पहुंच को और अधिक सुरक्षित रखने के लिए, एलएक्सडी प्रक्रिया विशेषाधिकार प्रदान करता है, जहां:

• विशेषाधिकार प्राप्त कंटेनर - ये ऐसे कंटेनर हैं जिनमें यूआईडी और जीआईडी ​​वाली प्रक्रियाएं होस्ट सिस्टम के समान मालिक से मेल खाती हैं। उदाहरण के लिए, 0 के यूआईडी के साथ एक कंटेनर में चलने वाली प्रक्रिया के पास 0 के यूआईडी के साथ होस्ट सिस्टम पर एक प्रक्रिया के समान सभी एक्सेस अधिकार होते हैं। दूसरे शब्दों में, कंटेनर में रूट उपयोगकर्ता के पास न केवल सभी अधिकार होते हैं कंटेनर, लेकिन होस्ट सिस्टम पर भी यदि वह कंटेनर के पृथक नेमस्पेस से बाहर जा सकता है।

• विशेषाधिकार रहित कंटेनर - ये ऐसे कंटेनर हैं जिनमें प्रक्रियाएं 0 से 65535 तक की संख्या के साथ यूआईडी और जीआईडी ​​के मालिक की होती हैं, लेकिन होस्ट सिस्टम के लिए मालिक को क्रमशः अतिरिक्त सबयूआईडी और सबजीआईडी ​​बिट्स का उपयोग करके मास्क किया जाता है। उदाहरण के लिए, एक कंटेनर में UID=0 वाला उपयोगकर्ता होस्ट सिस्टम पर इस रूप में देखा जाएगा SubUID + UID. यह होस्ट सिस्टम की सुरक्षा करता है क्योंकि यदि कंटेनर में कोई भी प्रक्रिया अपने पृथक नामस्थान से बचने में सक्षम है, तो यह केवल अज्ञात, बहुत उच्च यूआईडी/जीआईडी ​​​​के साथ एक प्रक्रिया के रूप में होस्ट सिस्टम के साथ संचार कर सकती है।

डिफ़ॉल्ट रूप से, नव निर्मित कंटेनरों की एक विशेषाधिकार रहित स्थिति होती है और इसलिए हमें एक SubUID और SubGID को परिभाषित करना होगा।

आइए दो कॉन्फ़िगरेशन फ़ाइलें बनाएं जिनमें हम क्रमशः 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, फिर इस खंड में हम एलएक्सडी में नेटवर्किंग से परिचित होंगे और क्लाइंट कमांड का उपयोग करके वर्चुअल स्विच (ब्रिज) कैसे बनाएं।

निम्नलिखित चित्र दर्शाता है कि एक स्विच (पुल) होस्ट और कंटेनरों को एक नेटवर्क में कैसे जोड़ता है:

कंटेनर एक नेटवर्क के माध्यम से अन्य कंटेनरों या उस होस्ट के साथ संचार कर सकते हैं जिस पर ये कंटेनर परोसे जाते हैं। ऐसा करने के लिए, आपको कंटेनरों के वर्चुअल नेटवर्क कार्ड को वर्चुअल स्विच से लिंक करना होगा। हम पहले एक स्विच बनाएंगे, और कंटेनर के निर्माण के बाद कंटेनर के नेटवर्क इंटरफेस को बाद के अध्यायों में जोड़ा जाएगा।

निम्न आदेश सबनेट के साथ एक स्विच बनाता है 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 सिस्टम में तीन प्रोफ़ाइल बनाई गई हैं: default, hddpool и hostfs. सभी तीन प्रोफाइल एक कंटेनर पर लागू होते हैं जिसमें स्थानीय कॉन्फ़िगरेशन (ग्रे क्षेत्र) होता है। प्रोफ़ाइल default एक उपकरण है root जिसका एक पैरामीटर है pool के बराबर है ssdpool, लेकिन कैस्केड कॉन्फ़िगरेशन एप्लिकेशन मॉडल के लिए धन्यवाद, हम कंटेनर में एक प्रोफ़ाइल लागू कर सकते हैं hddpool जिसका एक पैरामीटर है pool प्रोफ़ाइल से समान पैरामीटर को ओवरराइड कर देगा default और कंटेनर को डिवाइस कॉन्फ़िगरेशन प्राप्त होगा root पैरामीटर के साथ pool बराबरी का hddpool, और प्रोफ़ाइल hostfs बस कंटेनर में एक नया उपकरण जोड़ता है।

उपलब्ध कॉन्फ़िगरेशन प्रोफ़ाइल की सूची देखने के लिए, निम्न आदेश का उपयोग करें:

lxc profile list

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

किसी प्रोफ़ाइल के साथ काम करने के लिए उपलब्ध आदेशों की पूरी सूची कुंजी जोड़कर प्राप्त की जा सकती है --help:

lxc profile --help

Description:
  Manage profiles

Usage:
  lxc profile [command]

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

अपनी प्रोफ़ाइल संपादित करना ^

डिफ़ॉल्ट कॉन्फ़िगरेशन प्रोफ़ाइल default कंटेनर के लिए नेटवर्क कार्ड कॉन्फ़िगरेशन नहीं है और सभी नए बनाए गए कंटेनरों में नेटवर्क नहीं है, उनके लिए एक अलग कमांड के साथ स्थानीय (समर्पित) नेटवर्क डिवाइस बनाना आवश्यक है, लेकिन हम कॉन्फ़िगरेशन में एक वैश्विक नेटवर्क डिवाइस बना सकते हैं प्रोफ़ाइल जो इस प्रोफ़ाइल का उपयोग करने वाले सभी कंटेनरों के बीच साझा की जाएगी। इस तरह, एक नया कंटेनर बनाने के आदेश के तुरंत बाद, उनके पास नेटवर्क एक्सेस वाला एक नेटवर्क होगा। साथ ही, कोई प्रतिबंध नहीं है; यदि आवश्यक हो तो हम बाद में हमेशा एक स्थानीय नेटवर्क डिवाइस बना सकते हैं।

निम्न आदेश डिवाइस को कॉन्फ़िगरेशन प्रोफ़ाइल में जोड़ देगा eth0 टाइप nic नेटवर्क से जुड़ा है lxdbr0:

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

यह ध्यान रखना महत्वपूर्ण है कि चूंकि हमने वास्तव में डिवाइस को कॉन्फ़िगरेशन प्रोफ़ाइल में जोड़ा है, यदि हमने डिवाइस में एक स्थिर आईपी पता निर्दिष्ट किया है, तो इस प्रोफ़ाइल का उपयोग करने वाले सभी कंटेनर समान आईपी पता साझा करेंगे। यदि कंटेनर के लिए आवंटित स्थिर आईपी पते के साथ एक कंटेनर बनाने की आवश्यकता है, तो आपको आईपी एड्रेस पैरामीटर के साथ कंटेनर स्तर (स्थानीय कॉन्फ़िगरेशन) पर एक नेटवर्क डिवाइस कॉन्फ़िगरेशन बनाना चाहिए, न कि प्रोफ़ाइल स्तर पर।

आइए प्रोफ़ाइल जांचें:

lxc profile show default

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

इस प्रोफ़ाइल में हम देख सकते हैं कि सभी नए बनाए गए कंटेनरों के लिए दो डिवाइस बनाए जाएंगे:

• eth0 - उपकरण का प्रकार nic एक स्विच (नेटवर्क ब्रिज) से जुड़ा हुआ lxdbr0
• root - उपकरण का प्रकार disk जो एक स्टोरेज पूल का उपयोग करता है ssdpool

नई प्रोफ़ाइलें बनाना ^

पहले निर्मित का उपयोग करने के लिए भंडारण पूल कंटेनर, एक कॉन्फ़िगरेशन प्रोफ़ाइल बनाएं ssdroot जिसमें हम एक डिवाइस जोड़ देंगे जैसे disk आरोह बिंदु के साथ / (रूट) पहले बनाए गए का उपयोग कर भंडारण पूल - ssdpool:

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

इसी तरह, हम एक डिवाइस बनाते हैं जैसे disk, लेकिन इस मामले में उपयोग कर रहे हैं भंडारण पूल - hddpool:

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

कॉन्फ़िगरेशन प्रोफ़ाइल की जाँच करना:

lxc profile show ssdroot

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

lxc profile show hddroot

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

छवि भंडार ^

कंटेनर उन छवियों से बनाए जाते हैं जो विशेष रूप से इकट्ठे किए गए वितरण होते हैं जिनमें लिनक्स कर्नेल नहीं होता है। इसलिए, कंटेनर चलाने से पहले, इसे इस छवि से तैनात किया जाना चाहिए। छवियों का स्रोत एक स्थानीय रिपॉजिटरी है जिसमें छवियां बाहरी रिपॉजिटरी से डाउनलोड की जाती हैं।

दूरस्थ छवि भंडार ^

डिफ़ॉल्ट रूप से, 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 |
+-------+-------------+--------+-------------+--------------+------+------+

रिपॉजिटरी में छवियाँ निम्नलिखित विधियों का उपयोग करके प्रबंधित की जाती हैं:

टीम
विवरण

एलएक्ससी छवि उर्फ
छवि उपनाम प्रबंधित करें

एलएक्ससी छवि प्रतिलिपि
सर्वरों के बीच छवियों की प्रतिलिपि बनाएँ

एलएक्ससी छवि हटाना
छवियाँ हटाएँ

एलएक्ससी छवि संपादित
छवि गुण संपादित करें

एलएक्ससी छवि निर्यात
छवियाँ निर्यात और डाउनलोड करें

एलएक्ससी छवि आयात
छवि संग्रह में छवियाँ आयात करें

एलएक्ससी छवि पता
छवियों के बारे में उपयोगी जानकारी दिखाएं

एलएक्ससी छवि सूची
छवियों की सूची बनाएं

एलएक्ससी छवि ताज़ा करना
छवियाँ ताज़ा करें

एलएक्ससी छवि दिखाना
छवि गुण दिखाएँ

छवि को वैश्विक रिपॉजिटरी से स्थानीय रिपॉजिटरी में कॉपी करें 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       |
+---------+--------------+------------------------------------+--------------+

एलएक्सडी कॉन्फ़िगरेशन ^

इंटरैक्टिव मोड के अलावा, एलएक्सडी एक गैर-इंटरैक्टिव कॉन्फ़िगरेशन इंस्टॉलेशन मोड का भी समर्थन करता है, ऐसा तब होता है जब कॉन्फ़िगरेशन को 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: ""

एक स्थिर आईपी पता सेट करना ^

यदि हम किसी नेटवर्क डिवाइस के लिए आईपी एड्रेस सेट करने का प्रयास करते हैं eth0 टीम lxc config device set alp कंटेनर कॉन्फ़िगरेशन के लिए अभिप्रेत है, तो हमें एक त्रुटि प्राप्त होगी जो रिपोर्ट करेगी कि डिवाइस मौजूद नहीं है क्योंकि डिवाइस eth0 जो कंटेनर द्वारा उपयोग किया जाता है वह प्रोफ़ाइल से संबंधित है default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

हम निश्चित रूप से इसके लिए एक स्थिर आईपी पता सेट कर सकते हैं eth0 प्रोफ़ाइल में डिवाइस, लेकिन यह उन सभी कंटेनरों के लिए समान होगा जो इस प्रोफ़ाइल का उपयोग करेंगे। इसलिए, आइए कंटेनर को समर्पित एक उपकरण जोड़ें:

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

फिर आपको कंटेनर को पुनरारंभ करना होगा:

lxc restart alp

यदि हम अब कंटेनर कॉन्फ़िगरेशन को देखें, तो हमें विकल्प का उपयोग करने की आवश्यकता नहीं है --expanded नेटवर्क डिवाइस देखने के लिए eth0, चूंकि हमने इसे कंटेनर स्तर पर बनाया है और यह प्रोफ़ाइल से उसी डिवाइस पर कैस्केड हो गया है default:

lxc config show alp

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

एक कंटेनर हटाना ^

किसी कंटेनर को हटाने के लिए, कमांड का उपयोग करें lxc delete, लेकिन कंटेनर को हटाने से पहले, इसे कमांड का उपयोग करके बंद कर देना चाहिए lxc stop:

lxc stop alp

lxc list

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

हमारे द्वारा सत्यापित करने के बाद कि कंटेनर की स्थिति क्या हो गई है रोका हुआ, इसे हटाया जा सकता है भंडारण पूल:

lxc delete alp

कंटेनर पहुंच ^

किसी कंटेनर में कमांड को सीधे निष्पादित करने के लिए, नेटवर्क कनेक्शन को दरकिनार करते हुए, कमांड का उपयोग करें lxc exec जो सिस्टम शेल लॉन्च किए बिना कंटेनर में कमांड निष्पादित करता है। यदि आपको शेल पैटर्न जैसे वेरिएबल्स, फ़ाइल रीडायरेक्शन (पाइप), आदि का उपयोग करके शेल में एक कमांड निष्पादित करने की आवश्यकता है, तो आपको शेल को स्पष्ट रूप से लॉन्च करने और कमांड को एक कुंजी के रूप में पास करने की आवश्यकता है, उदाहरण के लिए:

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

कमांड ने एक विशेष एस्केप कैरेक्टर का उपयोग किया विशेष पात्र के लिए $ ताकि वेरिएबल $HOME मेजबान मशीन पर व्याख्या नहीं की गई थी, बल्कि केवल कंटेनर के अंदर व्याख्या की गई थी।

इंटरएक्टिव शेल मोड शुरू करना और फिर हॉटकी निष्पादित करके सत्र समाप्त करना भी संभव है CTRL+D:

lxc exec alp -- /bin/sh

कंटेनर संसाधन प्रबंधन ^

एलएक्सडी में, आप कॉन्फ़िगरेशन के एक विशेष सेट का उपयोग करके कंटेनर संसाधनों का प्रबंधन कर सकते हैं। कंटेनर कॉन्फ़िगरेशन पैरामीटर की पूरी सूची पाई जा सकती है दस्तावेज़ीकरण में.

रैम संसाधन सीमा ^

प्राचल limits.memory कंटेनर में उपलब्ध RAM की मात्रा को सीमित करता है। मान एक संख्या और एक है उपलब्ध प्रत्यय.

आइए कंटेनर की रैम सीमा 256 एमबी पर सेट करें:

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: ""

सीपीयू संसाधन सीमा ^

सीपीयू संसाधनों को सीमित करने के कई तरीके हैं। प्रतिबंधों के प्रकार:

• limit.cpu - एक कंटेनर को एक या अधिक सीपीयू कोर से बांधता है
• limits.cpu.allowance - समय सीमा बीत जाने पर या तो सीएफएस अनुसूचक कोटा प्रबंधित करता है, या प्रतिशत बीत जाने पर सार्वभौमिक सीपीयू संसाधन साझाकरण तंत्र का प्रबंधन करता है
• 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 नए समान कंटेनर बनाएं भंडारण पूल (एचडीपूल):

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 को एक एपीआई प्रदान करता है

अद्यतन 10.04.2020/15/00 XNUMX:XNUMX: जोड़ा गया नेविगेशन

स्रोत: www.habr.com