LXD არის შემდეგი თაობის სისტემის კონტეინერის მენეჯერი, ასე წერია წყარო. ის გთავაზობთ მომხმარებლის ინტერფეისს ვირტუალური მანქანების მსგავსი, მაგრამ ნაცვლად იყენებს Linux კონტეინერებს.

LXD ბირთვი არის პრივილეგირებული დემონი (სერვისი, რომელიც მუშაობს root უფლებებით), რომელიც უზრუნველყოფს REST API-ს ადგილობრივი unix სოკეტის მეშვეობით, ასევე ქსელის მეშვეობით, თუ დაინსტალირებულია შესაბამისი კონფიგურაცია. კლიენტები, როგორიცაა ბრძანების ხაზის ხელსაწყო, რომელიც მოწოდებულია LXD-ით, აკეთებენ მოთხოვნებს ამ REST API-ით. ეს ნიშნავს, რომ წვდომა გაქვთ ადგილობრივ ჰოსტზე თუ დისტანციურ ჰოსტზე, ყველაფერი ერთნაირად მუშაობს.

ამ სტატიაში ჩვენ დეტალურად არ ვისაუბრებთ LXD-ის ცნებებზე, არ განვიხილავთ დოკუმენტაციაში ასახულ ყველა შესაძლო შესაძლებლობას, მათ შორის ბოლოდროინდელ განხორციელებას QEMU ვირტუალური მანქანების მხარდაჭერის LXD-ის უახლეს ვერსიებში კონტეინერების პარალელურად. ამის ნაცვლად, ჩვენ ვისწავლით მხოლოდ კონტეინერების მართვის საფუძვლებს - შენახვის აუზების დაყენებას, ქსელის შექმნას, კონტეინერის გაშვებას, რესურსების ლიმიტების გამოყენებას და სნეპშოტების გამოყენებას, რათა შეძლოთ LXD-ის ძირითადი გაგება და კონტეინერების გამოყენება Linux-ზე.

სრული ინფორმაციისთვის მიმართეთ ოფიციალურ წყაროს:

ნავიგაცია

მონტაჟი LXD
- LXD-ის ინსტალაცია Ubuntu დისტრიბუციებზე
- LXD-ის ინსტალაცია Arch Linux დისტრიბუციებზე
შენახვის LXD (შენახვა)
LXD-ის ინიცირება
კონტეინერის შექმნა და მართვა

მონტაჟი LXD ^

LXD-ის ინსტალაცია Ubuntu დისტრიბუციებზე ^

Ubuntu 19.10 განაწილების პაკეტში lxd აქვს მაუწყებლობა ვადამდელი პაკეტი:

apt search lxd

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

ეს ნიშნავს, რომ ერთდროულად დაინსტალირდება ორი პაკეტი, ერთი სისტემური პაკეტის სახით და მეორე როგორც snap პაკეტი. სისტემაზე ორი პაკეტის ინსტალაციამ შეიძლება შექმნას გარკვეული პრობლემა, როდესაც სისტემის პაკეტი შეიძლება ობოლი გახდეს, თუ snap პაკეტი წაიშლება snap პაკეტის მენეჯერის მიერ.

იპოვნეთ პაკეტი lxd snap საცავში შეგიძლიათ გამოიყენოთ შემდეგი ბრძანება:

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 არის snap პაკეტი, ის უნდა იყოს დაინსტალირებული სისტემის პაკეტის მეშვეობით lxd, რომელიც შექმნის სისტემაში შესაბამის ჯგუფს, საჭირო უტილიტებს /usr/bin ა.შ.

sudo apt update
sudo apt install lxd

მოდით დავრწმუნდეთ, რომ პაკეტი დაინსტალირებულია როგორც snap პაკეტი:

snap list

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

LXD-ის ინსტალაცია Arch Linux დისტრიბუციებზე ^

სისტემაზე LXD პაკეტის დასაინსტალირებლად, თქვენ უნდა შეასრულოთ შემდეგი ბრძანებები, პირველი განაახლებს სისტემის პაკეტების სიას, რომელიც ხელმისაწვდომია საცავში, მეორე კი პირდაპირ დააინსტალირებს პაკეტს:

sudo pacman -Syyu && sudo pacman -S lxd

პაკეტის დაყენების შემდეგ, რეგულარული მომხმარებლის მიერ LXD-ის სამართავად, ის უნდა დაემატოს სისტემურ ჯგუფს lxd:

sudo usermod -a -G lxd user1

დავრწმუნდეთ მომხმარებელი user1 დაემატა ჯგუფს lxd:

id -Gn user1

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

თუ ჯგუფი lxd სიაში არ ჩანს, შემდეგ კვლავ უნდა გაააქტიუროთ მომხმარებლის სესია. ამისათვის თქვენ უნდა გამოხვიდეთ და შეხვიდეთ იმავე მომხმარებლის ქვეშ.

გააქტიურეთ systemd LXD სერვისის ჩატვირთვა სისტემის გაშვებისას:

sudo systemctl enable lxd

დავიწყოთ სერვისი:

sudo systemctl start lxd

სერვისის სტატუსის შემოწმება:

sudo systemctl status lxd

შენახვის LXD (შენახვა) ^

სანამ ინიციალიზაცია დაიწყება, ჩვენ უნდა გავიგოთ, როგორ არის ლოგიკურად მოწყობილი მეხსიერება LXD-ში.

შენახვა (შენახვის სივრცე) შედგება ერთი ან რამდენიმედან საცავის აუზი რომელიც იყენებს ერთ-ერთ მხარდაჭერილ ფაილურ სისტემას, როგორიცაა ZFS, BTRFS, LVM ან რეგულარული დირექტორიები. ყოველი საცავის აუზი დაყოფილია ტომებად (შენახვის მოცულობა) რომელიც შეიცავს სურათებს, კონტეინერებს ან მონაცემებს სხვა მიზნებისთვის.

სურათები - ეს არის სპეციალურად აწყობილი დისტრიბუციები Linux-ის ბირთვის გარეშე და ხელმისაწვდომია გარე წყაროებიდან
კონტეინერები - ეს არის განლაგებული დისტრიბუციები სურათებიდან, მზად გამოსაყენებლად
კადრები - ეს არის კონტეინერების მდგომარეობის კადრები, რომლებშიც შეგიძლიათ დაბრუნდეთ

LXD-ში შენახვის სამართავად გამოიყენეთ ბრძანება lxc storage სერთიფიკატი, რომლის მიღებაც შეგიძლიათ გასაღების მითითებით - lxc storage --help

შემდეგი ბრძანება აჩვენებს ყველა ჩამონათვალს საცავის აუზი LXD საცავში:

lxc storage list

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

ყველა სიის სანახავად შენახვის მოცულობა არჩეულში საცავის აუზი ემსახურება გუნდს lxc storage volume list:

lxc storage volume list hddpool

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

lxc storage volume list ssdpool

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

ასევე, თუ ამისთვის საცავის აუზი შექმნისას შეირჩა BTRFS ფაილური სისტემა, შემდეგ მიიღეთ სია შენახვის მოცულობა ან ქვევოლომები BTRFS ინტერპრეტაციაში შეგიძლიათ გამოიყენოთ ამ ფაილური სისტემის ხელსაწყოთა ნაკრები:

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

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

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

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

LXD-ის ინიცირება ^

კონტეინერების შექმნამდე და გამოყენებამდე, თქვენ უნდა შეასრულოთ ზოგადი LXD ინიციალიზაცია, რომელიც ქმნის და აკონფიგურირებს ქსელს და საცავს. ეს შეიძლება გაკეთდეს ხელით კლიენტის სტანდარტული ბრძანებების გამოყენებით, რომლებიც ხელმისაწვდომია სიაში ბრძანების გამოძახებით lxc --help ან ინიციალიზაციის ოსტატის გამოყენებით lxd init რამდენიმე კითხვაზე პასუხის გაცემა.

ფაილური სისტემის შერჩევა Storage Pool-ისთვის ^

ინიციალიზაციის დროს LXD სვამს რამდენიმე კითხვას, მათ შორის ნაგულისხმევად ფაილური სისტემის ტიპის განსაზღვრას საცავის აუზი. ნაგულისხმევად, მისთვის არჩეულია BTRFS ფაილური სისტემა. შექმნის შემდეგ შეუძლებელი იქნება სხვა FS-ზე გადასვლა. FS-ის ასარჩევად რეკომენდებულია მახასიათებლების შედარების ცხრილი:

მხატვრული
დირექტორია
Btrfs
LVM
ZFS
CEPH

გამოსახულების ოპტიმიზებული შენახვა
არა
დიახ
დიახ
დიახ
დიახ

ოპტიმიზებული ინსტანციის შექმნა
არა
დიახ
დიახ
დიახ
დიახ

ოპტიმიზებული სნეპშოტის შექმნა
არა
დიახ
დიახ
დიახ
დიახ

სურათის ოპტიმიზებული გადაცემა
არა
დიახ
არა
დიახ
დიახ

ოპტიმიზებული ინსტანციის გადაცემა
არა
დიახ
არა
დიახ
დიახ

დააკოპირეთ ჩაწერაზე
არა
დიახ
დიახ
დიახ
დიახ

ბლოკზე დაფუძნებული
არა
არა
დიახ
არა
დიახ

მყისიერი კლონირება
არა
დიახ
დიახ
დიახ
დიახ

შენახვის დრაივერი გამოსაყენებელია კონტეინერში
დიახ
დიახ
არა
არა
არა

აღდგენა ძველი კადრებიდან (არა უახლესი)
დიახ
დიახ
დიახ
არა
დიახ

შენახვის კვოტები
დიახ (*)
დიახ
დიახ
დიახ
არა

ქსელის და Storage Pool-ის ინიცირება ოსტატის გამოყენებით ^

შემდეგი ბრძანება, რომელსაც ჩვენ განვიხილავთ, გვთავაზობს 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. ეს ფაილური სისტემის მისამართი შეესაბამება ჩემს კომპიუტერში არსებულ ფიზიკურ SSD დისკს.

შემდეგი ქმედებები, რათა გააფართოვოთ გაგება შესრულებული როლის შესახებ საცავის აუზი საცავში ჩვენ შევქმნით მეორეს საცავის აუზი რომელიც ფიზიკურად განთავსდება სხვა ტიპის დისკზე, HDD-ზე. პრობლემა ის არის, რომ LXD არ გაძლევთ საშუალებას შექმნათ საცავის აუზი მისამართის გარეთ /var/lib/lxd/disks/ და სიმბოლური ბმულებიც კი არ იმუშავებს, იხილეთ დეველოპერის პასუხი. ჩვენ შეგვიძლია ამ შეზღუდვის გვერდის ავლით ინიციალიზაციის/ფორმატირების დროს საცავის აუზი მნიშვნელობის მითითებით, როგორც ბლოკის მოწყობილობა, მარყუჟის ფაილის გზის ნაცვლად, კლავიშში ამის მითითებით source.

ასე რომ, შექმნამდე საცავის აუზი თქვენ უნდა განსაზღვროთ loopback ფაილი ან არსებული დანაყოფი თქვენს ფაილურ სისტემაში, რომელსაც ის გამოიყენებს. ამისათვის ჩვენ შევქმნით და გამოვიყენებთ ფაილს, რომლის ზომითაც შევზღუდავთ 10 გბ-ს:

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

მოდით დავუკავშიროთ loopback ფაილი უფასო loopback მოწყობილობას:

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

/dev/loop1

გასაღების წყალობით --show ბრძანების შესრულება ეკრანზე უბრუნდება მოწყობილობის სახელს, რომელშიც არის დაკავშირებული ჩვენი loopback ფაილი. საჭიროების შემთხვევაში, ჩვენ შეგვიძლია გამოვაჩინოთ ამ ტიპის ყველა დაკავებული მოწყობილობის სია, რათა დავრწმუნდეთ, რომ ჩვენი ქმედებები სწორია:

losetup -l

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

სიიდან შეგიძლიათ გაიგოთ, რომ მოწყობილობას აქვს /dev/loop1 loopback ფაილი შედის /mnt/work/lxd/hddpool.imgდა მოწყობილობაში /dev/loop0 loopback ფაილი შედის /var/lib/lxd/disks/ssdpool.img რომელიც შეესაბამება ნაგულისხმევს საცავის აუზი.

შემდეგი ბრძანება ქმნის ახალს საცავის აუზი LXD-ში ჩვენ ახლახან მომზადებული loopback ფაილის საფუძველზე. LXD დააფორმატებს loopback ფაილს /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

loopback ფაილის ავტომატური ჩასმა loopback მოწყობილობის სლოტში ^

ჩვენ გვაქვს ერთი პატარა პრობლემა, მასპინძელი სისტემის გადატვირთვისას, ფაილი /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 0-ით, აქვს იგივე წვდომის უფლება, რაც პროცესს ჰოსტ სისტემაზე UID 0-ით. სხვა სიტყვებით რომ ვთქვათ, კონტეინერში root მომხმარებელს აქვს ყველა უფლება არა მხოლოდ კონტეინერი, არამედ მასპინძელ სისტემაზე, თუ მას შეუძლია კონტეინერის იზოლირებული სახელების სივრცის გარეთ გასვლა.
არაპრივილეგირებული კონტეინერები - ეს არის კონტეინერები, რომლებშიც პროცესები ეკუთვნის UID-ისა და GID-ის მფლობელს 0-დან 65535-მდე რიცხვით, მაგრამ მასპინძელი სისტემისთვის მფლობელი ნიღბავს დამატებული 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       |
+--------+----------+---------+-------------+---------+

თქვენ ასევე შეგიძლიათ დაადასტუროთ, რომ ქსელური მოწყობილობა შეიქმნა Linux-ის განაწილების სტანდარტული ხელსაწყოს გამოყენებით - ip link ან ip addr:

ip addr

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

კონფიგურაციის პროფილი ^

LXD-ის თითოეულ კონტეინერს აქვს საკუთარი კონფიგურაცია და შეუძლია გააფართოვოს იგი გლობალურად დეკლარირებული კონფიგურაციებით, რომელსაც ეწოდება კონფიგურაციის პროფილები. კონფიგურაციის პროფილების კონტეინერზე გამოყენებას აქვს კასკადური მოდელი, ამას ადასტურებს შემდეგი მაგალითი:

ამ მაგალითში LXD სისტემაში შეიქმნა სამი პროფილი: default, hddpool и hostfs. სამივე პროფილი გამოიყენება კონტეინერზე, რომელსაც აქვს ადგილობრივი კონფიგურაცია (ნაცრისფერი ზონა). პროფილი default აქვს მოწყობილობა root რომელსაც აქვს პარამეტრი pool ტოლია ssdpool, მაგრამ კასკადის კონფიგურაციის აპლიკაციის მოდელის წყალობით, ჩვენ შეგვიძლია გამოვიყენოთ პროფილი კონტეინერზე hddpool რომელსაც აქვს პარამეტრი pool გადააჭარბებს იმავე პარამეტრს პროფილიდან default და კონტეინერი მიიღებს მოწყობილობის კონფიგურაციას root პარამეტრით pool თანაბარი hddpoolდა პროფილი hostfs უბრალოდ ამატებს ახალ მოწყობილობას კონტეინერში.

ხელმისაწვდომი კონფიგურაციის პროფილების სიის სანახავად გამოიყენეთ შემდეგი ბრძანება:

lxc profile list

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

პროფილთან მუშაობისთვის ხელმისაწვდომი ბრძანებების სრული სია შეგიძლიათ მიიღოთ კლავიშის დამატებით --help:

lxc profile --help

Description:
  Manage profiles

Usage:
  lxc profile [command]

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

თქვენი პროფილის რედაქტირება ^

ნაგულისხმევი კონფიგურაციის პროფილი default არ აქვს ქსელის ბარათის კონფიგურაცია კონტეინერისთვის და ყველა ახლად შექმნილ კონტეინერს არ აქვს ქსელი, მათთვის აუცილებელია ადგილობრივი (გამოყოფილი) ქსელის მოწყობილობების შექმნა ცალკე ბრძანებით, მაგრამ ჩვენ შეგვიძლია შევქმნათ გლობალური ქსელის მოწყობილობა კონფიგურაციაში. პროფილი, რომელიც გაზიარდება ყველა კონტეინერს შორის ამ პროფილის გამოყენებით. ამ გზით, ახალი კონტეინერის შექმნის ბრძანების შემდეგ, მათ ექნებათ ქსელი ქსელის წვდომით. ამავდროულად, არ არსებობს შეზღუდვები; საჭიროების შემთხვევაში, ყოველთვის შეგვიძლია შევქმნათ ლოკალური ქსელის მოწყობილობა მოგვიანებით.

შემდეგი ბრძანება დაამატებს მოწყობილობას კონფიგურაციის პროფილში eth0 ტიპი nic დაკავშირებულია ქსელთან lxdbr0:

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

მნიშვნელოვანია აღინიშნოს, რომ მას შემდეგ, რაც ჩვენ რეალურად დავამატეთ მოწყობილობა კონფიგურაციის პროფილში, თუ ჩვენ დავაზუსტეთ სტატიკური IP მისამართი მოწყობილობაში, მაშინ ყველა კონტეინერი, რომელიც გამოიყენებს ამ პროფილს, იზიარებს იგივე IP მისამართს. თუ საჭიროა კონტეინერის შექმნა კონტეინერისთვის გამოყოფილი სტატიკური IP მისამართით, მაშინ უნდა შექმნათ ქსელური მოწყობილობის კონფიგურაცია კონტეინერის დონეზე (ლოკალური კონფიგურაცია) IP მისამართის პარამეტრით და არა პროფილის დონეზე.

მოდით შევამოწმოთ პროფილი:

lxc profile show default

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

ამ პროფილში ჩვენ ვხედავთ, რომ ყველა ახლად შექმნილი კონტეინერისთვის შეიქმნება ორი მოწყობილობა:

eth0 - მოწყობილობის ტიპი nic დაკავშირებული გადამრთველთან (ქსელის ხიდი) lxdbr0
root - მოწყობილობის ტიპი disk რომელიც იყენებს შესანახ აუზს ssdpool

ახალი პროფილების შექმნა ^

ადრე შექმნილი გამოსაყენებლად საცავის აუზი კონტეინერები, შექმენით კონფიგურაციის პროფილი ssdroot რომელშიც ჩვენ დავამატებთ მოწყობილობას, როგორიცაა disk სამონტაჟო წერტილით / (root) ადრე შექმნილის გამოყენებით საცავის აუზი - ssdpool:

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

ანალოგიურად, ჩვენ ვქმნით მოწყობილობას, როგორიცაა disk, მაგრამ ამ შემთხვევაში გამოყენებით საცავის აუზი - hddpool:

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

კონფიგურაციის პროფილების შემოწმება:

lxc profile show ssdroot

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

lxc profile show hddroot

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

გამოსახულების საცავი ^

კონტეინერები იქმნება სურათებისგან, რომლებიც სპეციალურად აწყობილი დისტრიბუციებია, რომლებსაც არ აქვთ Linux ბირთვი. ამიტომ, კონტეინერის გაშვებამდე, ის უნდა განლაგდეს ამ სურათიდან. სურათების წყარო არის ადგილობრივი საცავი, რომელშიც სურათები იტვირთება გარე საცავებიდან.

გამოსახულების დისტანციური საცავი ^

ნაგულისხმევად, LXD კონფიგურირებულია სურათების მისაღებად სამი დისტანციური წყაროდან:

ubuntu: (სტაბილური Ubuntu სურათებისთვის)
ubuntu-ყოველდღიური: (ყოველდღიური Ubuntu სურათებისთვის)
სურათები: (სხვა დისტროსთვის)

lxc remote list

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

მაგალითად, საცავი ubuntu: აქვს შემდეგი სურათები:

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

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

სვეტების შეზღუდული რაოდენობის საჩვენებლად ჩვენ გამოვიყენეთ ვარიანტი -c პარამეტრებით dasutდა ასევე შეზღუდა სიის სიგრძე ბრძანებით head.

ფილტრაცია ხელმისაწვდომია სურათების სიის საჩვენებლად. შემდეგი ბრძანება ჩამოთვლის ყველა ხელმისაწვდომი განაწილების არქიტექტურას AlpineLinux:

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 სურათი alias
სურათების მეტსახელების მართვა

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 რომელზედაც გადაეცემა მნიშვნელობები репозиторий:образ შემდეგ კი კონტეინერის სასურველი ID. საცავი შეიძლება განისაზღვროს როგორც ლოკალური local: ასეა ნებისმიერი გლობალური. თუ საცავი არ არის მითითებული, მაშინ ნაგულისხმევად ადგილობრივი საცავი გამოიყენება სურათის მოსაძებნად. თუ სურათი მითითებულია გლობალური საცავიდან, მაშინ სურათი ჯერ ჩამოიტვირთება ადგილობრივ საცავში და შემდეგ გამოყენებული იქნება კონტეინერის შესაქმნელად.

მოდით გავუშვათ შემდეგი ბრძანება ჩვენი პირველი კონტეინერის შესაქმნელად:

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

მოდით შევხედოთ ბრძანების კლავიშებს, რომლებსაც აქ ვიყენებთ თანმიმდევრობით:

alpine3 — ლოკალურ საცავში ადრე ატვირთული სურათისთვის მითითებულია მეტსახელი (ალიასი). თუ მეტსახელი არ არის შექმნილი ამ სურათისთვის, მაშინ ყოველთვის შეგიძლიათ მიმართოთ სურათს მისით თითის ანაბეჭდი რომელიც ნაჩვენებია ცხრილში.
alp — ადგენს კონტეინერის იდენტიფიკატორს
--storage — ეს გასაღები მიუთითებს რომელ საცავის აუზი შეიქმნება კონტეინერი
--profile — ეს კლავიშების კასკადი მიმართავს კონფიგურაციას ადრე შექმნილი კონფიგურაციის პროფილებიდან კონტეინერზე

ჩვენ გავუშვით კონტეინერი, რომელიც იწყებს განაწილების საწყისი სისტემის გაშვებას:

lxc start alp

თქვენ ასევე შეგიძლიათ გამოიყენოთ ბრძანება lxc launch რომელიც საშუალებას გაძლევთ გააერთიანოთ გუნდები lxc init и lxc start ერთ ოპერაციაში.

კონტეინერის მდგომარეობის შემოწმება:

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

კონტეინერის კონფიგურაციის შემოწმება:

lxc config show alp

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

განყოფილებაში profiles შეგვიძლია დავრწმუნდეთ, რომ ეს კონტეინერი იყენებს ორ კონფიგურაციის პროფილს − default и hddroot. განყოფილებაში devices ჩვენ შეგვიძლია მხოლოდ ერთი მოწყობილობის აღმოჩენა, რადგან ქსელის მოწყობილობა შეიქმნა პროფილის დონეზე default. იმისათვის, რომ ნახოთ კონტეინერის მიერ გამოყენებული ყველა მოწყობილობა, თქვენ უნდა დაამატოთ გასაღები --expanded:

lxc config show alp --expanded

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

სტატიკური IP მისამართის დაყენება ^

თუ ვცდილობთ დავაყენოთ IP მისამართი ქსელური მოწყობილობისთვის eth0 გუნდი lxc config device set alp განკუთვნილია კონტეინერის კონფიგურაციისთვის, მაშინ ჩვენ მივიღებთ შეცდომას, რომელიც შეგატყობინებთ, რომ მოწყობილობა არ არსებობს, რადგან მოწყობილობა eth0 რომელსაც იყენებს კონტეინერი ეკუთვნის პროფილს default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

ჩვენ, რა თქმა უნდა, შეგვიძლია დავაყენოთ სტატიკური IP მისამართი eth0 მოწყობილობები პროფილში, მაგრამ ეს იგივე იქნება ყველა კონტეინერისთვის, რომელიც გამოიყენებს ამ პროფილს. ამიტომ, დავამატოთ კონტეინერისთვის მიძღვნილი მოწყობილობა:

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

შემდეგ თქვენ უნდა გადატვირთოთ კონტეინერი:

lxc restart alp

თუ ახლა გადავხედავთ კონტეინერის კონფიგურაციას, ჩვენ არ გვჭირდება ოფციის გამოყენება --expanded ქსელური მოწყობილობის სანახავად eth0, ვინაიდან ჩვენ შევქმენით იგი კონტეინერის დონეზე და ის იმავე მოწყობილობაზე გადავიდა პროფილიდან default:

lxc config show alp

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

კონტეინერის ამოღება ^

კონტეინერის ამოსაღებად გამოიყენეთ ბრძანება lxc delete, მაგრამ კონტეინერის ამოღებამდე ის უნდა შეწყდეს ბრძანების გამოყენებით lxc stop:

lxc stop alp

lxc list

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

მას შემდეგ რაც შევამოწმეთ, რომ კონტეინერის მდგომარეობა გახდა შეჩერებულია, მისი ამოღება შესაძლებელია საცავის აუზი:

lxc delete alp

კონტეინერზე წვდომა ^

კონტეინერში ბრძანებების პირდაპირ შესასრულებლად, ქსელური კავშირების გვერდის ავლით, გამოიყენეთ ბრძანება lxc exec რომელიც ახორციელებს ბრძანებებს კონტეინერში სისტემის გარსის გაშვების გარეშე. თუ თქვენ გჭირდებათ ბრძანების შესრულება ჭურვიში გარსის შაბლონების გამოყენებით, როგორიცაა ცვლადები, ფაილების გადამისამართებები (მილები) და ა.

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

ბრძანება გამოიყენა სპეციალური გაქცევის სიმბოლო განსაკუთრებული ხასიათისთვის $ ისე რომ ცვლადი $HOME არ იყო ინტერპრეტირებული მასპინძელ მანქანაზე, მაგრამ ინტერპრეტირებული იყო მხოლოდ კონტეინერის შიგნით.

ასევე შესაძლებელია ინტერაქტიული გარსის რეჟიმის დაწყება და შემდეგ სესიის დასრულება ცხელი კლავიშის შესრულებით CTRL+D:

lxc exec alp -- /bin/sh

კონტეინერის რესურსების მართვა ^

LXD-ში შეგიძლიათ მართოთ კონტეინერის რესურსები კონფიგურაციის სპეციალური ნაკრების გამოყენებით. შეგიძლიათ იხილოთ კონტეინერის კონფიგურაციის პარამეტრების სრული სია დოკუმენტაციაში.

RAM რესურსის შეზღუდვა ^

პარამეტრის limits.memory ზღუდავს კონტეინერისთვის ხელმისაწვდომი ოპერატიული მეხსიერების რაოდენობას. მნიშვნელობა არის რიცხვი და ერთი ხელმისაწვდომი სუფიქსები.

მოდით დავაყენოთ კონტეინერის ოპერატიული მეხსიერების ლიმიტი 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: ""

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

იმისდა მიუხედავად, რომ ჩვენ დავაწესეთ ლიმიტი კონტეინერის root მოწყობილობისთვის 2 გბ-მდე, სისტემის კომუნალური საშუალებები, როგორიცაა df ვერ დაინახავს ამ შეზღუდვას. ამისათვის ჩვენ ჩავატარებთ პატარა ტესტს და გავარკვევთ როგორ მუშაობს.

მოდით შევქმნათ 2 ახალი იდენტური კონტეინერი იმავეში საცავის აუზი (hddpool):

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

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

მოდით შევქმნათ 1 გბ ფაილი ერთ-ერთ კონტეინერში:

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 დამონტაჟებულია როგორც root დანაყოფი საცავის აუზი რომელსაც ეს კონტეინერები იყენებენ, ამიტომ ისინი იზიარებენ მის მოცულობას ორს შორის.

რესურსების მოხმარების სტატისტიკა ^

შეგიძლიათ იხილოთ რესურსების მოხმარების სტატისტიკა კონტეინერისთვის ბრძანების გამოყენებით:

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-ს აქვს სხვა ტიპის სნეპშოტები - stateful, რომელიც ინახავს კონტეინერში არსებული ყველა პროცესის მიმდინარე მდგომარეობას. არსებობს მთელი რიგი საინტერესო და სასარგებლო ფუნქციები, რომლებიც დაკავშირებულია სახელმწიფო კადრებთან.

Სხვა რა? ^

მოდული ხელმისაწვდომია პითონის დეველოპერებისთვის PyLXD რომელიც უზრუნველყოფს API-ს LXD-ს

განახლება 10.04.2020/15/00 XNUMX:XNUMX: დამატებულია ნავიგაცია

წყარო: www.habr.com

LXD - Linux კონტეინერის სისტემების ძირითადი მახასიათებლები

ნავიგაცია

მონტაჟი LXD ^

LXD-ის ინსტალაცია Ubuntu დისტრიბუციებზე ^

LXD-ის ინსტალაცია Arch Linux დისტრიბუციებზე ^

შენახვის LXD (შენახვა) ^

LXD-ის ინიცირება ^

ფაილური სისტემის შერჩევა Storage Pool-ისთვის ^

ქსელის და Storage Pool-ის ინიცირება ოსტატის გამოყენებით ^

დამატებითი შენახვის აუზის შექმნა ^

საცავის აუზის ზომის გაზრდა ^

loopback ფაილის ავტომატური ჩასმა loopback მოწყობილობის სლოტში ^

Უსაფრთხოება. კონტეინერის პრივილეგიები ^

ვირტუალური ქსელის გადამრთველის შექმნა ^

კონფიგურაციის პროფილი ^

თქვენი პროფილის რედაქტირება ^

ახალი პროფილების შექმნა ^

გამოსახულების საცავი ^

გამოსახულების დისტანციური საცავი ^

ადგილობრივი სურათების საცავი ^

LXD კონფიგურაცია ^

კონტეინერის შექმნა და მართვა ^

სტატიკური IP მისამართის დაყენება ^

კონტეინერის ამოღება ^

კონტეინერზე წვდომა ^

კონტეინერის რესურსების მართვა ^

RAM რესურსის შეზღუდვა ^

CPU რესურსის ლიმიტი ^

დისკის სივრცის შეზღუდვა ^

რესურსების მოხმარების სტატისტიკა ^

სნეპშოტებთან მუშაობა ^

Სხვა რა? ^

ახალი კომენტარის დამატება

LXD - Linux კონტეინერის სისტემების ძირითადი მახასიათებლები

ნავიგაცია

მონტაჟი LXD ^

LXD-ის ინსტალაცია Ubuntu დისტრიბუციებზე ^

LXD-ის ინსტალაცია Arch Linux დისტრიბუციებზე ^

შენახვის LXD (შენახვა) ^

LXD-ის ინიცირება ^

ფაილური სისტემის შერჩევა Storage Pool-ისთვის ^

ქსელის და Storage Pool-ის ინიცირება ოსტატის გამოყენებით ^

დამატებითი შენახვის აუზის შექმნა ^

საცავის აუზის ზომის გაზრდა ^

loopback ფაილის ავტომატური ჩასმა loopback მოწყობილობის სლოტში ^

Უსაფრთხოება. კონტეინერის პრივილეგიები ^

ვირტუალური ქსელის გადამრთველის შექმნა ^

კონფიგურაციის პროფილი ^

თქვენი პროფილის რედაქტირება ^

ახალი პროფილების შექმნა ^

გამოსახულების საცავი ^

გამოსახულების დისტანციური საცავი ^

ადგილობრივი სურათების საცავი ^

LXD კონფიგურაცია ^

კონტეინერის შექმნა და მართვა ^

სტატიკური IP მისამართის დაყენება ^

კონტეინერის ამოღება ^

კონტეინერზე წვდომა ^

კონტეინერის რესურსების მართვა ^

RAM რესურსის შეზღუდვა ^

CPU რესურსის ლიმიტი ^

დისკის სივრცის შეზღუდვა ^

რესურსების მოხმარების სტატისტიკა ^

სნეპშოტებთან მუშაობა ^

Სხვა რა? ^

ახალი კომენტარის დამატება პასუხის გასაუქმებლად

ახალი კომენტარის დამატება