LXD अर्को पुस्ता प्रणाली कन्टेनर प्रबन्धक हो, त्यसैले यो भन्छ स्रोत। यसले भर्चुअल मेसिनहरू जस्तै प्रयोगकर्ता इन्टरफेस प्रदान गर्दछ, तर यसको सट्टा लिनक्स कन्टेनरहरू प्रयोग गर्दछ।

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

यस लेखमा, हामी LXD को अवधारणाहरूमा विस्तृत रूपमा बस्ने छैनौं; हामी कागजातमा उल्लिखित सबै उपलब्ध क्षमताहरूलाई विचार गर्दैनौं, QEMU भर्चुअल मेसिनहरूको लागि कन्टेनरहरूको समानान्तर समर्थनको LXD को नवीनतम संस्करणहरूमा हालको कार्यान्वयन सहित। यसको सट्टामा, हामी कन्टेनर व्यवस्थापनका आधारभूत कुराहरू सिक्नेछौं - भण्डारण पूलहरू सेटअप गर्ने, नेटवर्किङ गर्ने, कन्टेनर चलाउने, स्रोत सीमाहरू लागू गर्ने, र स्न्यापसटहरू कसरी प्रयोग गर्ने ताकि तपाईंले LXD को आधारभूत बुझाइ प्राप्त गर्न सक्नुहुन्छ र लिनक्समा कन्टेनरहरू प्रयोग गर्न सक्नुहुन्छ।

पूर्ण जानकारीको लागि, कृपया आधिकारिक स्रोतलाई सन्दर्भ गर्नुहोस्:

स्थापना LXD
- Ubuntu वितरणमा LXD स्थापना गर्दै
- आर्क लिनक्स वितरणमा LXD स्थापना गर्दै
भण्डारण LXD (भण्डारण)
LXD प्रारम्भ गर्दै
कन्टेनर सिर्जना र व्यवस्थापन

स्थापना LXD ^

Ubuntu वितरणमा 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 तपाईं प्याकेज सुनिश्चित गर्न सक्नुहुन्छ 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 फाइल प्रणाली चयन गरिएको थियो, त्यसपछि सूची प्राप्त गर्नुहोस् भण्डारण भोल्यूम वा subvolume BTRFS व्याख्यामा, तपाईंले यो फाइल प्रणालीको टुलकिट प्रयोग गर्न सक्नुहुन्छ:

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

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

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

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

LXD प्रारम्भ गर्दै ^

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

भण्डारण पूलको लागि फाइल प्रणाली चयन गर्दै ^

प्रारम्भ गर्दा, LXD ले पूर्वनिर्धारितका लागि फाइल प्रणाली प्रकार निर्धारण सहित धेरै प्रश्नहरू सोध्छ भण्डारण पोखरी। पूर्वनिर्धारित रूपमा, BTRFS फाइल प्रणाली यसको लागि चयन गरिएको छ। सिर्जना पछि अर्को FS मा परिवर्तन गर्न असम्भव हुनेछ। FS चयन गर्न यो सुझाव दिइएको छ सुविधा तुलना तालिका:

फिचर
निर्देशिका
btrfs
LVM
ZFS
CEPH

अनुकूलित छवि भण्डारण
no
हो
हो
हो
हो

अनुकूलित उदाहरण निर्माण
no
हो
हो
हो
हो

अनुकूलित स्न्यापसट सिर्जना
no
हो
हो
हो
हो

अनुकूलित छवि स्थानान्तरण
no
हो
no
हो
हो

अनुकूलित उदाहरण स्थानान्तरण
no
हो
no
हो
हो

लेखेर प्रतिलिपि गर्नुहोस्
no
हो
हो
हो
हो

ब्लक आधारित
no
no
हो
no
हो

तत्काल क्लोनिङ
no
हो
हो
हो
हो

भण्डारण चालक कन्टेनर भित्र प्रयोग गर्न योग्य
हो
हो
no
no
no

पुरानो स्न्यापसटहरूबाट पुनर्स्थापना गर्नुहोस् (पछिल्लो होइन)
हो
हो
हो
no
हो

भण्डारण कोटाहरू
हो (*)
हो
हो
हो
no

विजार्ड प्रयोग गरी नेटवर्क र भण्डारण पूल प्रारम्भ गर्दै ^

अर्को आदेश हामीले हेर्नेछौं कि प्रारम्भिक विजार्ड प्रयोग गरेर साधारण प्रश्नहरूको जवाफ दिएर 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 सँग प्रक्रियाहरू होस्ट प्रणालीमा जस्तै मालिकसँग मेल खान्छ। उदाहरणका लागि, ० को UID भएको कन्टेनरमा चलिरहेको प्रक्रियामा होस्ट प्रणालीमा ० को UID भएको प्रक्रिया जस्तै सबै समान पहुँच अधिकारहरू हुन्छन्। अर्को शब्दमा, कन्टेनरमा रूट प्रयोगकर्तासँग मात्र होइन सबै अधिकारहरू हुन्छन्। कन्टेनर, तर होस्ट प्रणालीमा पनि यदि उसले कन्टेनरको पृथक नेमस्पेस बाहिर जान सक्छ।
असुविधाजनक कन्टेनरहरू - यी कन्टेनरहरू हुन् जसमा प्रक्रियाहरू 0 देखि 65535 सम्मको संख्याको साथ UID र GID को मालिकसँग सम्बन्धित छन्, तर होस्ट प्रणालीको लागि मालिकलाई क्रमशः थपिएको SubUID र SubGID बिटहरू प्रयोग गरेर मास्क गरिएको छ। उदाहरणका लागि, कन्टेनरमा UID=0 भएको प्रयोगकर्तालाई होस्ट प्रणालीमा यस रूपमा देखिनेछ SubUID + UID। यसले होस्ट प्रणालीलाई सुरक्षित गर्दछ किनभने यदि कन्टेनरमा कुनै पनि प्रक्रियाले यसको पृथक नेमस्पेसबाट बच्न सक्षम छ भने, यसले होस्ट प्रणालीसँग अज्ञात, धेरै उच्च UID/GID सँग प्रक्रियाको रूपमा मात्र सञ्चार गर्न सक्छ।

पूर्वनिर्धारित रूपमा, भर्खरै सिर्जना गरिएका कन्टेनरहरूको विशेषाधिकाररहित स्थिति हुन्छ र त्यसैले हामीले 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, त्यसपछि यस खण्डमा हामी 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: (स्थिर Ubuntu छविहरूको लागि)
ubuntu-दैनिक: (दैनिक Ubuntu छविहरूको लागि)
छविहरू: (अन्य distros को एक गुच्छा को लागी)

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 ठेगाना सेट गर्ने प्रयास गर्छौं eth0 टोली lxc config device set alp कन्टेनर कन्फिगरेसनको लागि अभिप्रेरित, त्यसपछि हामीले एउटा त्रुटि प्राप्त गर्नेछौं जसले रिपोर्ट गर्नेछ कि यन्त्र अवस्थित छैन किनभने यन्त्र eth0 जुन कन्टेनर द्वारा प्रयोग गरिन्छ प्रोफाइल मा पर्छ default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

हामी निश्चित रूपमा एक स्थिर आईपी ठेगाना सेट गर्न सक्छौं eth0 प्रोफाइलमा यन्त्रहरू, तर यो प्रोफाइल प्रयोग गर्ने सबै कन्टेनरहरूको लागि समान हुनेछ। त्यसकारण, कन्टेनरमा समर्पित उपकरण थपौं:

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

त्यसपछि तपाईंले कन्टेनर पुन: सुरु गर्न आवश्यक छ:

lxc restart alp

यदि हामी अहिले कन्टेनर कन्फिगरेसन हेर्छौं भने, हामीले विकल्प प्रयोग गर्न आवश्यक छैन --expanded नेटवर्क उपकरण हेर्न eth0, किनकि हामीले यसलाई कन्टेनर स्तरमा सिर्जना गर्यौं र प्रोफाइलबाट उही यन्त्रमा क्यास्केड गरियो default:

lxc config show alp

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

कन्टेनर हटाउँदै ^

कन्टेनर हटाउन, आदेश प्रयोग गर्नुहोस् lxc delete, तर कन्टेनर हटाउनु अघि, यो आदेश प्रयोग गरेर रोक्नु पर्छ lxc stop:

lxc stop alp

lxc list

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

हामीले पुष्टि गरेपछि कन्टेनरको अवस्था बनेको छ रोकियोबाट हटाउन सकिन्छ भण्डारण पोखरी:

lxc delete alp

कन्टेनर पहुँच ^

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

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

आदेशले विशेष एस्केप क्यारेक्टर प्रयोग गर्यो विशेष चरित्र को लागी $ ताकि चर $HOME होस्ट मेसिनमा व्याख्या गरिएको थिएन, तर कन्टेनर भित्र मात्र व्याख्या गरिएको थियो।

यो अन्तरक्रियात्मक शेल मोड सुरु गर्न पनि सम्भव छ, र त्यसपछि हटकुञ्जी कार्यान्वयन गरेर सत्र समाप्त गर्नुहोस् CTRL+D:

lxc exec alp -- /bin/sh

कन्टेनर स्रोत व्यवस्थापन ^

LXD मा, तपाइँ कन्फिगरेसनको विशेष सेट प्रयोग गरेर कन्टेनर स्रोतहरू व्यवस्थापन गर्न सक्नुहुन्छ। कन्टेनर कन्फिगरेसन प्यारामिटरहरूको पूर्ण सूची फेला पार्न सकिन्छ कागजातमा.

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 यो प्रतिबन्ध देख्ने छैन। यो गर्नको लागि, हामी एउटा सानो परीक्षण सञ्चालन गर्नेछौं र यसले कसरी काम गर्छ भनेर पत्ता लगाउँदछ।

त्यसैमा २ नयाँ समान कन्टेनरहरू सिर्जना गरौं भण्डारण पोखरी (hddpool):

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

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

एउटा कन्टेनरमा 1GB फाइल सिर्जना गरौं:

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

फाइल सिर्जना गरिएको छ भनेर निश्चित गरौं:

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

यदि हामीले दोस्रो कन्टेनरमा हेर्छौं भने, उही स्थानमा फाइलको अस्तित्वको लागि जाँच गर्नुहोस्, त्यसपछि यो फाइल त्यहाँ हुनेछैन, जुन अपेक्षा गरिएको छ, किनकि कन्टेनरहरू आफ्नै रूपमा सिर्जना गरिएका छन्। भण्डारण भोल्यूम उही मा भण्डारण पोखरी:

lxc exec alp2 -- ls -lh
total 0

तर यसले उत्पादन गर्ने मानहरू तुलना गरौं df एक र अर्को कन्टेनरमा:

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

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

उपकरण /dev/loop1 मूल विभाजन जस्तै माउन्ट गरिएको छ भण्डारण पोखरी जुन यी कन्टेनरहरूले प्रयोग गर्छन्, त्यसैले तिनीहरूले यसको भोल्युम दुई बीच साझा गर्छन्।

स्रोत उपभोग तथ्याङ्क ^

तपाईंले आदेश प्रयोग गरेर कन्टेनरको लागि स्रोत खपत तथ्याङ्कहरू हेर्न सक्नुहुन्छ:

lxc info alp

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

स्न्यापशटहरूसँग काम गर्दै ^

LXD सँग स्न्यापसटहरू सिर्जना गर्ने र तिनीहरूबाट कन्टेनर अवस्था पुनर्स्थापना गर्ने क्षमता छ।

स्न्यापसट सिर्जना गर्न, निम्न आदेश चलाउनुहोस्:

lxc snapshot alp snapshot1

समूह lxc snapshot कुञ्जी उपलब्ध छैन list, त्यसैले, स्न्यापशटहरूको सूची हेर्नको लागि तपाईंले कन्टेनरको बारेमा सामान्य जानकारी देखाउने आदेश प्रयोग गर्न आवश्यक छ:

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

तपाईंले आदेश प्रयोग गरेर स्न्यापसटबाट कन्टेनर पुनर्स्थापित गर्न सक्नुहुन्छ lxc restore कन्टेनर निर्दिष्ट गर्दै जसको लागि पुनर्स्थापना गरिनेछ र स्न्यापसट उपनाम:

lxc restore alp snapshot1

निम्न आदेश स्न्यापसट मेटाउन प्रयोग गरिन्छ। कृपया ध्यान दिनुहोस् कि आदेश सिन्ट्याक्स अरू सबैसँग मिल्दोजुल्दो छैन; यहाँ तपाईंले कन्टेनर नाम पछि फर्वार्ड स्ल्याश निर्दिष्ट गर्न आवश्यक छ। यदि स्ल्याश हटाइयो भने, त्यसपछि स्न्यापसट मेटाउने आदेशलाई कन्टेनर मेटाउन आदेशको रूपमा व्याख्या गरिन्छ!

lxc delete alp/snapshot1

माथिको उदाहरणमा, हामीले तथाकथित राज्यविहीन स्न्यापशटहरू हेर्यौं। LXD सँग अर्को प्रकारको स्न्यापसटहरू छन् - स्टेटफुल, जसले कन्टेनरमा भएका सबै प्रक्रियाहरूको हालको अवस्था बचत गर्छ। स्टेटफुल स्न्यापशटहरू धेरै रोचक र उपयोगी सुविधाहरूको साथ आउँछन्।

अरू के? ^

पाइथन विकासकर्ताहरूको लागि मोड्युल उपलब्ध छ PyLXD जसले LXD लाई API प्रदान गर्दछ

अपडेट 10.04.2020/15/00 XNUMX:XNUMX: नेभिगेसन थपियो

स्रोत: www.habr.com

LXD को आधारभूत सुविधाहरू - लिनक्स कन्टेनर प्रणाली

Навигация