LXD është menaxheri i kontejnerëve të sistemit të gjeneratës së ardhshme, kështu thotë burim. Ai ofron një ndërfaqe përdoruesi të ngjashme me makinat virtuale, por përdor kontejnerët Linux në vend të tyre.

Bërthama LXD është një daemon i privilegjuar (një shërbim që funksionon me të drejta rrënjësore) që ofron një API REST nëpërmjet një prize unix lokale, si dhe përmes rrjetit nëse është instaluar konfigurimi i duhur. Klientët, si mjeti i linjës komanduese të ofruar me LXD, bëjnë kërkesa përmes këtij API REST. Kjo do të thotë që nëse jeni duke hyrë në një host lokal ose një host të largët, gjithçka funksionon njësoj.

Në këtë artikull ne nuk do të ndalemi në detaje në konceptet e LXD, nuk do të shqyrtojmë të gjitha aftësitë e disponueshme të përshkruara në dokumentacion, duke përfshirë zbatimin e fundit në versionet më të fundit të LXD të mbështetjes për makinat virtuale QEMU paralelisht me kontejnerët. Në vend të kësaj, ne do të mësojmë vetëm bazat e menaxhimit të kontejnerëve - vendosjen e pishinave të ruajtjes, rrjetëzimin, drejtimin e një kontejneri, aplikimin e kufijve të burimeve dhe si të përdorni fotografitë e çastit në mënyrë që të mund të kuptoni bazën e LXD dhe të përdorni kontejnerët në Linux.

Për informacion të plotë, ju lutemi referojuni burimit zyrtar:

• Faqja e internetit e zhvilluesit
• Records
• Forum

lundrim

• Instalimi LXD
  • Instalimi i LXD në shpërndarjet e Ubuntu
  • Instalimi i LXD në shpërndarjet e Arch Linux
• Magazinimi LXD (Storage)
• Inicializimi i LXD
  • Zgjedhja e një sistemi skedarësh për Storage Pool
  • Inicializimi i rrjetit dhe Storage Pool duke përdorur magjistarin
  • Krijimi i një pishinë ruajtëse shtesë
    • Rritja e madhësisë së pishinës së ruajtjes
    • Futja automatike e një skedari loopback në një vend të pajisjes loopback
  • Siguria. Privilegjet e kontejnerëve
  • Krijimi i një ndërprerësi të rrjetit virtual
  • Profili i konfigurimit
    • Redaktimi i profilit tuaj
    • Krijimi i profileve të reja
  • Depoja e imazheve
    • Depot e imazheve në distancë
    • Depo lokale e imazheve
  • Konfigurimi LXD
• Krijimi dhe menaxhimi i një kontejneri
  • Vendosja e një adrese IP statike
  • Heqja e një enë
  • Qasja në kontejner
  • Menaxhimi i burimeve të kontejnerëve
    • Kufizimi i burimeve RAM
    • Kufiri i burimeve të CPU
    • Kufizimi i hapësirës në disk
    • Statistikat e konsumit të burimeve
  • Puna me fotografi të çastit

Instalimi LXD ^

Instalimi i LXD në shpërndarjet e Ubuntu ^

Në paketën e shpërndarjes Ubuntu 19.10 lxd ka një transmetim të ndezur paketë e parakohshme:

apt search lxd

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

Kjo do të thotë se dy paketa do të instalohen në të njëjtën kohë, njëra si një paketë sistemi dhe tjetra si një paketë snap. Instalimi i dy paketave në një sistem mund të krijojë një problem ku paketa e sistemit mund të mbetet jetime nëse paketa snap hiqet nga menaxheri i paketave snap.

Gjeni paketën lxd në depon e snap mund të përdorni komandën e mëposhtme:

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

Duke ekzekutuar komandën list mund të siguroheni që paketa lxd nuk është instaluar ende:

snap list

Name  Version    Rev   Tracking  Publisher   Notes
core  16-2.43.3  8689  stable    canonical✓  core

Përkundër faktit se LXD është një paketë snap, ajo duhet të instalohet përmes paketës së sistemit lxd, i cili do të krijojë grupin përkatës në sistem, shërbimet e nevojshme në /usr/bin etj

sudo apt update
sudo apt install lxd

Le të sigurohemi që paketa të jetë instaluar si një paketë e parakohshme:

snap list

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

Instalimi i LXD në shpërndarjet e Arch Linux ^

Për të instaluar paketën LXD në sistem, duhet të ekzekutoni komandat e mëposhtme, e para do të përditësojë listën e paketave në sistemin e disponueshme në depo, e dyta do të instalojë drejtpërdrejt paketën:

sudo pacman -Syyu && sudo pacman -S lxd

Pas instalimit të paketës, për të menaxhuar LXD nga një përdorues i rregullt, duhet të shtohet në grupin e sistemit lxd:

sudo usermod -a -G lxd user1

Le të sigurohemi që përdoruesi user1 shtuar në grup lxd:

id -Gn user1

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

Nëse grupi lxd nuk është i dukshëm në listë, atëherë duhet të aktivizoni sërish seancën e përdoruesit. Për ta bërë këtë, duhet të dilni dhe të identifikoheni nën të njëjtin përdorues.

Aktivizoni në systemd ngarkimi i shërbimit LXD në fillimin e sistemit:

sudo systemctl enable lxd

Le të fillojmë shërbimin:

sudo systemctl start lxd

Kontrollimi i statusit të shërbimit:

sudo systemctl status lxd

Magazinimi LXD (Storage) ^

Përpara se të fillojë inicializimi, duhet të kuptojmë se si është rregulluar logjikisht ruajtja në LXD.

Magazinimi (Ruajtje) përfshin nga një ose më shumë Pishinë magazinimi i cili përdor një nga sistemet e skedarëve të mbështetur si ZFS, BTRFS, LVM ose direktori të rregullta. Çdo Pishinë magazinimi është e ndarë në vëllime (Vëllimi i magazinimit) që përmbajnë imazhe, kontejnerë ose të dhëna për qëllime të tjera.

• skulpturë - këto janë shpërndarje të montuara posaçërisht pa kernel Linux dhe të disponueshme nga burime të jashtme
• Konteйnerы - këto janë shpërndarje të vendosura nga imazhet, gati për përdorim
• Fotot e çastit - këto janë fotografi të gjendjes së kontejnerëve në të cilat mund të ktheheni

Për të menaxhuar ruajtjen në LXD, përdorni komandën lxc storage një certifikatë për të cilën mund të merrni duke specifikuar çelësin - lxc storage --help

Komanda e mëposhtme shfaq një listë të të gjithave Pishinë magazinimi në ruajtjen LXD:

lxc storage list

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

Për të parë një listë të të gjithave Vëllimi i magazinimit në të përzgjedhurit Pishinë magazinimi i shërben ekipit 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       |
+-----------+----------------------------------+-------------+---------+

Gjithashtu, nëse për Pishinë magazinimi Kur krijoni, u zgjodh sistemi i skedarëve BTRFS, pastaj merrni një listë Vëllimi i magazinimit ose nën vëllimet në interpretimin BTRFS, mund të përdorni paketën e veglave të këtij sistemi skedarësh:

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

Inicializimi i LXD ^

Përpara se të krijoni dhe përdorni kontejnerët, duhet të kryeni një inicializim të përgjithshëm LXD që krijon dhe konfiguron rrjetin dhe ruajtjen. Kjo mund të bëhet manualisht duke përdorur komandat standarde të klientit që janë të disponueshme në listë duke thirrur komandën lxc --help ose duke përdorur magjistarin e inicializimit lxd init duke iu përgjigjur disa pyetjeve.

Zgjedhja e një sistemi skedarësh për Storage Pool ^

Gjatë inicializimit, LXD bën disa pyetje, duke përfshirë përcaktimin e llojit të sistemit të skedarëve për parazgjedhjen Pishinë magazinimi. Si parazgjedhje, sistemi i skedarëve BTRFS është zgjedhur për të. Do të jetë e pamundur të ndryshohet në një FS tjetër pas krijimit. Për të zgjedhur një FS sugjerohet tabela e krahasimit të veçorive:

tipar
drejtori
btrfs
LVM
ZFS
CEPH

Ruajtja e optimizuar e imazhit
jo
po
po
po
po

Krijimi i shembullit të optimizuar
jo
po
po
po
po

Krijimi i fotografive të optimizuara
jo
po
po
po
po

Transferimi i optimizuar i imazhit
jo
po
jo
po
po

Transferimi i shembullit të optimizuar
jo
po
jo
po
po

kopjoni në shkrim
jo
po
po
po
po

Bazuar në bllok
jo
jo
po
jo
po

Klonimi i menjëhershëm
jo
po
po
po
po

Drejtues i ruajtjes i përdorshëm brenda një kontejneri
po
po
jo
jo
jo

Rivendosja nga fotografitë më të vjetra (jo më të fundit)
po
po
po
jo
po

Kuotat e ruajtjes
po(*)
po
po
po
jo

Inicializimi i rrjetit dhe Storage Pool duke përdorur magjistarin ^

Komanda tjetër që do të shikojmë sugjeron vendosjen e komponentëve kryesorë të LXD duke iu përgjigjur pyetjeve të thjeshta duke përdorur magjistarin e inicializimit.

Ekzekutoni komandën lxc init dhe shkruani përgjigjet e pyetjeve pas dy pikave siç tregohet në shembullin më poshtë ose ndryshoni ato sipas kushteve tuaja:

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

Krijimi i një pishinë ruajtëse shtesë ^

Në hapin e mëparshëm që krijuam Pishinë magazinimi që iu dha emri ssdpool dhe skedari i të cilit ndodhet në sistemin tim në /var/lib/lxd/disks/ssdpool.img. Kjo adresë e sistemit të skedarëve korrespondon me diskun fizik SSD në kompjuterin tim.

Veprimet e mëposhtme, për të zgjeruar të kuptuarit e rolit të luajtur nga Pishinë magazinimi në depo, ne do të krijojmë një të dytë Pishinë magazinimi i cili do të vendoset fizikisht në një lloj tjetër disku, HDD. Problemi është se LXD nuk ju lejon të krijoni Pishinë magazinimi jashtë adresës /var/lib/lxd/disks/ dhe madje lidhjet simbolike nuk do të funksionojnë, shikoni përgjigjen e zhvilluesit. Ne mund ta anashkalojmë këtë kufizim gjatë inicializimit/formatimit Pishinë magazinimi duke specifikuar vlerën si një pajisje bllok në vend të shtegut për në skedarin loopback duke specifikuar këtë në çelës source.

Pra, para krijimit Pishinë magazinimi ju duhet të përcaktoni një skedar loopback ose një ndarje ekzistuese në sistemin tuaj të skedarëve që do të përdorë. Për ta bërë këtë, ne do të krijojmë dhe përdorim një skedar që do ta kufizojmë në madhësi në 10 GB:

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

Le të lidhim skedarin loopback me një pajisje loopback falas:

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

/dev/loop1

Falë çelësit --show ekzekutimi i komandës kthen në ekran emrin e pajisjes në të cilën është lidhur skedari ynë loopback. Nëse është e nevojshme, ne mund të shfaqim një listë të të gjitha pajisjeve të zëna të këtij lloji për t'u siguruar që veprimet tona janë të sakta:

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

Nga lista mund të gjeni se pajisja ka /dev/loop1 skedar loopback i përfshirë /mnt/work/lxd/hddpool.img, dhe në pajisje /dev/loop0 skedar loopback i përfshirë /var/lib/lxd/disks/ssdpool.img që i përgjigjet standardit Pishinë magazinimi.

Komanda e mëposhtme krijon një të re Pishinë magazinimi në LXD bazuar në skedarin loopback që sapo përgatitëm. LXD do të formatojë skedarin loopback /mnt/work/lxd/hddpool.img në pajisje /dev/loop1 për sistemin e skedarëve BTRFS:

lxc storage create hddpool btrfs size=10GB source=/dev/loop1

Le të shfaqim një listë të të gjithave Pishinë magazinimi në ekran:

lxc storage list

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

Rritja e madhësisë së pishinës së ruajtjes ^

Pas krijimit Pishinë magazinimi, nëse është e nevojshme, mund të zgjerohet. Për Pishinë magazinimi bazuar në sistemin e skedarëve BTRFS, ekzekutoni komandat e mëposhtme:

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

Futja automatike e një skedari loopback në një vend të pajisjes loopback ^

Ne kemi një problem të vogël, kur rindizni sistemin pritës, skedarin /mnt/work/lxd/hddpool.img do të "fluturojë" jashtë pajisjes /dev/loop1 dhe shërbimi LXD do të prishet kur ngarkohet sepse nuk do ta shohë atë në këtë pajisje. Për të zgjidhur këtë problem, duhet të krijoni një shërbim të sistemit që do ta futë këtë skedar në pajisje /dev/loop1 kur sistemi pritës niset.

Le të krijojmë njësi lloji i skedarit shërbim в /etc/systemd/system/ për sistemin e inicializimit të 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

Aktivizoni shërbimin:

sudo systemctl enable lxd-hddpool

Created symlink /etc/systemd/system/local-fs.target.wants/lxd-hddpool.service → /etc/systemd/system/lxd-hddpool.service.

Pas rinisjes së sistemit pritës, ne kontrollojmë statusin e shërbimit:

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).

Nga dalja mund të verifikojmë që gjendja e shërbimit është aktiv, përkundër faktit se ekzekutimi i skenarit tonë nga një komandë ishte përfunduar, opsioni na lejoi ta bënim këtë RemainAfterExit=true.

Siguria. Privilegjet e kontejnerëve ^

Meqenëse të gjitha proceset e kontejnerit në fakt ekzekutohen të izoluara në sistemin pritës duke përdorur kernelin e tij, për të mbrojtur më tej aksesin e proceseve të kontejnerit në sistemin pritës, LXD ofron privilegjin e procesit, ku:

• Kontejnerë të privilegjuar - këto janë kontejnerë në të cilët proceset me UID dhe GID korrespondojnë me të njëjtin pronar si në sistemin pritës. Për shembull, një proces që ekzekutohet në një kontejner me një UID prej 0 ka të njëjtat të drejta aksesi si një proces në sistemin pritës me një UID prej 0. Me fjalë të tjera, përdoruesi rrënjë në kontejner ka të gjitha të drejtat jo vetëm në kontejnerin, por edhe në sistemin pritës nëse ai mund të dalë jashtë hapësirës së emrave të izoluar të kontejnerit.

• Kontejnerë të paprivilegjuar - këto janë kontejnerë në të cilët proceset i përkasin pronarit të UID dhe GID me një numër nga 0 deri në 65535, por për sistemin pritës pronari maskohet duke përdorur respektivisht bitet e shtuara SubUID dhe SubGID. Për shembull, një përdorues me UID=0 në një kontejner do të shihet në sistemin pritës si SubUID + UID. Kjo mbron sistemin pritës sepse nëse ndonjë proces në kontejner është në gjendje të shpëtojë nga hapësira e tij e izoluar e emrave, ai mund të komunikojë vetëm me sistemin pritës si një proces me një UID/GID të panjohur, shumë të lartë.

Si parazgjedhje, kontejnerët e krijuar rishtazi kanë një status të paprivilegjuar dhe për këtë arsye ne duhet të përcaktojmë një SubUID dhe SubGID.

Le të krijojmë dy skedarë konfigurimi në të cilët do të vendosim maskën për SubUID dhe SubGID, përkatësisht:

sudo touch /etc{/subuid,/subgid}
sudo usermod --add-subuids 1000000-1065535 root 
sudo usermod --add-subgids 1000000-1065535 root

Për të aplikuar ndryshimet, shërbimi LXD duhet të riniset:

sudo systemctl restart lxd

Krijimi i një ndërprerësi të rrjetit virtual ^

Meqenëse më parë kemi inicializuar rrjetin duke përdorur magjistarin e inicializimit lxd init dhe krijoi një pajisje rrjeti lxdbr0, atëherë në këtë seksion thjesht do të njihemi me rrjetëzimin në LXD dhe si të krijojmë një switch (urë) virtuale duke përdorur komandën klient.

Diagrami i mëposhtëm tregon se si një ndërprerës (urë) lidh hostin dhe kontejnerët në një rrjet:

Kontejnerët mund të komunikojnë nëpërmjet një rrjeti me kontejnerë të tjerë ose hostin në të cilin shërbehen këto kontejnerë. Për ta bërë këtë, duhet të lidhni kartat e rrjetit virtual të kontejnerëve me një ndërprerës virtual. Së pari do të krijojmë një ndërprerës dhe ndërfaqet e rrjetit të kontejnerit do të lidhen në kapitujt pasues, pasi të jetë krijuar vetë kontejneri.

Komanda e mëposhtme krijon një ndërprerës me një nënrrjet 10.0.5.0/24 dhe adresën IPv4 10.0.5.1/24, dhe gjithashtu përfshin ipv4.nat në mënyrë që kontejnerët të mund të hyjnë në internet përmes hostit duke përdorur shërbimin NAT:

lxc network create lxdbr0 ipv4.address=10.0.5.1/24 ipv4.nat=true ipv6.address=none

Kontrollimi i listës së pajisjeve të rrjetit të disponueshme në LXD:

lxc network list

+--------+----------+---------+-------------+---------+
|  NAME  |   TYPE   | MANAGED | DESCRIPTION | USED BY |
+--------+----------+---------+-------------+---------+
| eno1   | physical | NO      |             | 0       |
+--------+----------+---------+-------------+---------+
| lxdbr0 | bridge   | YES     |             | 0       |
+--------+----------+---------+-------------+---------+

Ju gjithashtu mund të verifikoni që një pajisje rrjeti është krijuar duke përdorur mjetin standard të shpërndarjes Linux - ip link ose 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

Profili i konfigurimit ^

Çdo kontejner në LXD ka konfigurimin e vet dhe mund ta zgjerojë atë me konfigurimet e deklaruara globalisht të quajtura profilet e konfigurimit. Aplikimi i profileve të konfigurimit në një kontejner ka një model kaskadë, shembulli i mëposhtëm e demonstron këtë:

Në këtë shembull, tre profile janë krijuar në sistemin LXD: default, hddpool и hostfs. Të tre profilet aplikohen në një enë që ka një konfigurim lokal (zona gri). Profili default ka një pajisje root që ka një parametër pool është ssdpool, por falë modelit të aplikimit të konfigurimit të kaskadës, ne mund të aplikojmë një profil në kontejner hddpool që ka një parametër pool do të anashkalojë të njëjtin parametër nga profili default dhe kontejneri do të marrë konfigurimin e pajisjes root me parametër pool të barabartë hddpool, dhe profilin hostfs thjesht shton një pajisje të re në kontejner.

Për të parë listën e profileve të disponueshme të konfigurimit, përdorni komandën e mëposhtme:

lxc profile list

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

Një listë e plotë e komandave të disponueshme për të punuar me një profil mund të merret duke shtuar tastin --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

Redaktimi i profilit tuaj ^

Profili i konfigurimit të parazgjedhur default nuk ka një konfigurim të kartës së rrjetit për kontejnerin dhe të gjithë kontejnerët e krijuar rishtazi nuk kanë një rrjet, për ta është e nevojshme të krijohen pajisje të rrjetit lokal (të dedikuar) me një komandë të veçantë, por ne mund të krijojmë një pajisje rrjeti global në konfigurim profili që do të ndahet ndërmjet të gjithë kontejnerëve që përdorin këtë profil. Në këtë mënyrë, menjëherë pas komandës për të krijuar një kontenier të ri, ata do të kenë një rrjet me akses në rrjet. Në të njëjtën kohë, nuk ka kufizime; ne gjithmonë mund të krijojmë një pajisje të rrjetit lokal më vonë nëse është e nevojshme.

Komanda e mëposhtme do ta shtojë pajisjen në profilin e konfigurimit eth0 lloj nic lidhur me rrjetin lxdbr0:

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

Është e rëndësishme të theksohet se meqenëse në fakt e kemi shtuar pajisjen në profilin e konfigurimit, nëse kemi specifikuar një adresë IP statike në pajisje, atëherë të gjithë kontejnerët që do të përdorin këtë profil do të ndajnë të njëjtën adresë IP. Nëse ka nevojë për të krijuar një kontejner me një adresë IP statike të caktuar për kontejnerin, atëherë duhet të krijoni një konfigurim të pajisjes së rrjetit në nivelin e kontejnerit (konfigurim lokal) me parametrin e adresës IP, dhe jo në nivelin e profilit.

Le të kontrollojmë profilin:

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: []

Në këtë profil mund të shohim se për të gjithë kontejnerët e krijuar rishtazi do të krijohen dy pajisje:

• eth0 - Lloji i pajisjes nic i lidhur me një ndërprerës (urë rrjeti) lxdbr0
• root - Lloji i pajisjes disk e cila përdor një pishinë magazinimi ssdpool

Krijimi i profileve të reja ^

Për të përdorur krijuar më parë Pishinë magazinimi kontejnerët, krijoni një profil konfigurimi ssdroot në të cilën do të shtojmë një pajisje si disk me pikë montimi / (rrënjë) duke përdorur të krijuar më parë Pishinë magazinimi - ssdpool:

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

Në mënyrë të ngjashme, ne krijojmë një pajisje si disk, por në këtë rast duke përdorur Pishinë magazinimi - hddpool:

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

Kontrollimi i profileve të konfigurimit:

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: []

Depoja e imazheve ^

Kontejnerët krijohen nga imazhe që janë shpërndarje të montuara posaçërisht që nuk kanë një kernel Linux. Prandaj, përpara se të ekzekutoni kontejnerin, ai duhet të vendoset nga ky imazh. Burimi i imazheve është një depo lokale në të cilën shkarkohen imazhet nga depo të jashtme.

Depot e imazheve në distancë ^

Si parazgjedhje, LXD është konfiguruar të marrë imazhe nga tre burime të largëta:

• ubuntu: (për imazhe të qëndrueshme të Ubuntu)
• ubuntu-ditore: (për imazhet e përditshme të Ubuntu)
• imazhe: (për një mori shpërndarjesh të tjera)

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    |
+-----------------+------------------------------------------+--------+--------+

Për shembull, depoja ubuntu: ka imazhet e mëposhtme:

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  |
+----------------------------------------------+--------------+----------+------------+

Për të shfaqur një numër të kufizuar kolonash kemi përdorur opsionin -c me parametra dasut, dhe gjithashtu kufizoi gjatësinë e listës me komandën head.

Filtrimi është i disponueshëm për të shfaqur një listë imazhesh. Komanda e mëposhtme do të listojë të gjitha arkitekturat e disponueshme të shpërndarjes 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        |
+------------------------------+--------------------------------------+--------------+

Depo lokale e imazheve ^

Për të filluar përdorimin e kontejnerit, duhet të shtoni një imazh nga depoja globale në atë lokale local:. Tani depoja lokale është bosh, komanda do të sigurohet për këtë lxc image list. Nëse metoda list mos specifikoni një depo, atëherë depoja lokale do të përdoret si parazgjedhje - local:

lxc image list local:

+-------+-------------+--------+-------------+--------------+------+------+
| ALIAS | FINGERPRINT | PUBLIC | DESCRIPTION | ARCHITECTURE | TYPE | SIZE |
+-------+-------------+--------+-------------+--------------+------+------+

Imazhet në depo menaxhohen duke përdorur metodat e mëposhtme:

Ekip
Përshkrim

imazh lxc pseudonim
Menaxho pseudonimet e imazhit

imazh lxc kopje
Kopjoni imazhet midis serverëve

imazh lxc fshij
Fshi imazhet

imazh lxc redaktoj
Redaktoni vetitë e imazhit

imazh lxc eksport
Eksporto dhe shkarko imazhe

imazh lxc import
Importoni imazhe në dyqanin e imazheve

imazh lxc info
Trego informacione të dobishme rreth imazheve

imazh lxc listë
Listoni imazhet

imazh lxc refresh
Rifresko imazhet

imazh lxc Tregoj
Trego vetitë e imazhit

Kopjoni imazhin në depo lokale nga ajo globale images::

lxc image copy images:alpine/3.11/amd64 local: --alias=alpine3

Image copied successfully!

Le të shfaqim një listë të të gjitha imazheve të disponueshme aktualisht në depon lokale local::

lxc image -c lfdatsu list local:

+---------+--------------+------------------------------------+--------------+
|  ALIAS  | FINGERPRINT  |            DESCRIPTION             | ARCHITECTURE |
+---------+--------------+------------------------------------+--------------+
| alpine3 | 73a3093d4a5c | Alpine 3.11 amd64 (20200220_13:00) | x86_64       |
+---------+--------------+------------------------------------+--------------+

Konfigurimi LXD ^

Përveç modalitetit interaktiv, LXD mbështet gjithashtu një mënyrë instalimi të konfigurimit jo-interaktiv, kjo është kur konfigurimi specifikohet në formën e një skedari YAML, një format i veçantë që ju lejon të instaloni të gjithë konfigurimin menjëherë, duke anashkaluar ekzekutimin e shumë komandave ndërvepruese që u diskutuan më lart në këtë artikull, duke përfshirë konfigurimin e rrjetit, krijimin e profileve të konfigurimit, etj. Ne nuk do ta mbulojmë këtë zonë këtu, ju mund ta kontrolloni vetë. në dokumentacion.

Komanda tjetër interaktive lxc config që do të shikojmë ju lejon të vendosni konfigurimin. Për shembull, për të siguruar që imazhet e shkarkuara në depo lokale nuk përditësohen automatikisht nga depot globale, ne mund ta aktivizojmë këtë sjellje me komandën e mëposhtme:

lxc config set images.auto_update_cached=false

Krijimi dhe menaxhimi i një kontejneri ^

Për të krijuar një kontejner përdorni komandën lxc init në të cilat kalohen vlerat репозиторий:образ dhe më pas ID-në e dëshiruar për kontejnerin. Depoja mund të specifikohet si lokale local: kështu është çdo global. Nëse depoja nuk është e specifikuar, atëherë si parazgjedhje depoja lokale përdoret për të kërkuar imazhin. Nëse imazhi specifikohet nga depoja globale, atëherë imazhi së pari do të shkarkohet në depo lokale dhe më pas do të përdoret për të krijuar kontejnerin.

Le të ekzekutojmë komandën e mëposhtme për të krijuar kontejnerin tonë të parë:

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

Le të shohim me radhë çelësat e komandës që përdorim këtu:

• alpine3 — Një pseudonim (alias) është specifikuar për imazhin që është ngarkuar më parë në depon lokale. Nëse pseudonimi nuk është krijuar për këtë imazh, atëherë gjithmonë mund t'i referoheni imazhit me anë të tij gjurmë gishtash e cila është paraqitur në tabelë.
• alp — Vendos identifikuesin për kontejnerin
• --storage — Ky çelës tregon se në cilin Pishinë magazinimi do të krijohet një enë
• --profile — Këta kaskadë çelësash zbatojnë konfigurimin nga profilet e konfigurimit të krijuara më parë në kontejner

Ne lëshojmë kontejnerin, i cili fillon të nisë sistemin init të shpërndarjes:

lxc start alp

Ju gjithashtu mund të përdorni komandën lxc launch e cila ju lejon të kombinoni ekipe lxc init и lxc start në një operacion.

Kontrollimi i gjendjes së kontejnerit:

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

Kontrollimi i konfigurimit të kontejnerit:

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

Në seksionin profiles mund të sigurohemi që ky kontejner përdor dy profile konfigurimi − default и hddroot. Në seksion devices ne mund të zbulojmë vetëm një pajisje sepse pajisja e rrjetit është krijuar në nivelin e profilit default. Për të parë të gjitha pajisjet e përdorura nga kontejneri, duhet të shtoni një çelës --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: ""

Vendosja e një adrese IP statike ^

Nëse përpiqemi të vendosim një adresë IP për një pajisje rrjeti eth0 ekipi lxc config device set alp të destinuara për konfigurimin e kontejnerit, atëherë do të marrim një gabim që do të raportojë se pajisja nuk ekziston sepse pajisja eth0 e cila përdoret nga ena i përket profilit default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Sigurisht që mund të vendosim një adresë IP statike për eth0 pajisjet në profil, por do të jetë e njëjtë për të gjithë kontejnerët që do të përdorin këtë profil. Prandaj, le të shtojmë një pajisje të dedikuar për kontejnerin:

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

Pastaj ju duhet të rindizni kontejnerin:

lxc restart alp

Nëse shikojmë tani konfigurimin e kontejnerit, nuk kemi nevojë të përdorim opsionin --expanded për të parë pajisjen e rrjetit eth0, meqenëse e krijuam atë në nivelin e kontejnerit dhe ai kaloi mbi të njëjtën pajisje nga profili 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: ""

Heqja e një enë ^

Për të hequr një enë, përdorni komandën lxc delete, por përpara se të hiqni kontejnerin, ai duhet të ndalet duke përdorur komandën lxc stop:

lxc stop alp

lxc list

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

Pasi të kemi verifikuar që gjendja e kontejnerit është bërë u ndal, mund të hiqet nga Pishinë magazinimi:

lxc delete alp

Qasja në kontejner ^

Për të ekzekutuar komandat në një kontejner direkt, duke anashkaluar lidhjet e rrjetit, përdorni komandën lxc exec i cili ekzekuton komandat në kontejner pa lëshuar shell-in e sistemit. Nëse ju duhet të ekzekutoni një komandë në një predhë duke përdorur modele të guaskës si variablat, ridrejtimet e skedarëve (tub) etj., atëherë duhet të nisni në mënyrë eksplicite shell-in dhe të kaloni komandën si çelës, për shembull:

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

Komanda përdori një karakter të veçantë ikjeje për karakter të veçantë $ në mënyrë që ndryshorja $HOME nuk u interpretua në makinën pritës, por u interpretua vetëm brenda kontejnerit.

Është gjithashtu e mundur të filloni modalitetin ndërveprues të guaskës dhe më pas të përfundoni seancën duke ekzekutuar çelësin e nxehtë CTRL+D:

lxc exec alp -- /bin/sh

Menaxhimi i burimeve të kontejnerëve ^

Në LXD, ju mund të menaxhoni burimet e kontejnerëve duke përdorur një grup të veçantë konfigurimi. Mund të gjendet një listë e plotë e parametrave të konfigurimit të kontejnerit në dokumentacion.

Kufizimi i burimeve RAM ^

Parametër limits.memory kufizon sasinë e RAM-it në dispozicion të kontejnerit. Vlera është një numër dhe një nga prapashtesa të disponueshme.

Le të vendosim kufirin e RAM-it të kontejnerit në 256 MB:

lxc config set alp limits.memory 256MB

Gjithashtu, ka parametra të tjerë për kufizimin e kujtesës:

• limits.memory.enforce
• limits.memory.hugepages
• limits.memory.swap
• limits.memory.swap.priority

Ekip lxc config show ju lejon të shfaqni të gjithë konfigurimin e kontejnerit, duke përfshirë kufirin e aplikuar të burimit që ishte vendosur:

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

Kufiri i burimeve të CPU ^

Ka disa mënyra për të kufizuar burimet e CPU. llojet e kufizimeve:

• limit.cpu - lidh një kontejner me një ose më shumë bërthama CPU
• limits.cpu.allowance - menaxhon ose kuotat e planifikuesit CFS kur ka kaluar afati, ose mekanizmin universal të ndarjes së burimeve të CPU-së kur përqindja ka kaluar
• limits.cpu.priority - Prioriteti i planifikuesit kur instancave të shumta që ndajnë një grup procesorësh u caktohet e njëjta përqindje e procesorëve

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

Kufizimi i hapësirës në disk ^

Përveç kufizimeve të tilla limits.read, limits.write ne gjithashtu mund të kufizojmë sasinë e hapësirës në disk të konsumuar nga kontejneri (punon vetëm me ZFS ose BTRFS):

lxc config device set alp root size=2GB

Pas instalimit, në parametrin devices.root.size Ne mund të verifikojmë kufirin e caktuar:

lxc config show alp
...
devices:
  root:
    path: /
    pool: hddpool
    size: 2GB
    type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""

Për të parë kuotat e diskut të përdorur mund të marrim nga komanda 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

Pavarësisht se kemi vendosur një kufi për pajisjen rrënjësore të kontejnerit në 2 GB, shërbimet e sistemit si p.sh. df nuk do ta shohë këtë kufizim. Për ta bërë këtë, ne do të bëjmë një test të vogël dhe do të zbulojmë se si funksionon.

Le të krijojmë 2 kontejnerë të rinj identikë në të njëjtën Pishinë magazinimi (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         |
+------+---------+------------------+------+-----------+-----------+

Le të krijojmë një skedar 1 GB në një nga kontejnerët:

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

Le të sigurohemi që skedari të jetë krijuar:

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

Nëse shikojmë në kontejnerin e dytë, kontrollojmë ekzistencën e një skedari në të njëjtin vend, atëherë ky skedar nuk do të jetë aty, gjë që pritet, pasi kontejnerët krijohen në vetvete. Vëllimi i magazinimit ne te njejten Pishinë magazinimi:

lxc exec alp2 -- ls -lh
total 0

Por le të krahasojmë vlerat që prodhon df në një dhe në tjetrin enë:

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% /
...

pajisje /dev/loop1 montuar siç është ndarja rrënjë Pishinë magazinimi që përdorin këto kontejnerë, kështu që vëllimin e tyre e ndajnë mes dy.

Statistikat e konsumit të burimeve ^

Ju mund të shikoni statistikat e konsumit të burimeve për një kontejner duke përdorur komandën:

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

Puna me fotografi të çastit ^

LXD ka aftësinë të krijojë fotografi dhe të rivendosë gjendjen e kontejnerit prej tyre.

Për të krijuar një fotografi, ekzekutoni komandën e mëposhtme:

lxc snapshot alp snapshot1

Ekipi lxc snapshot asnjë çelës në dispozicion listPrandaj, për të parë listën e fotografive, duhet të përdorni komandën që shfaq informacione të përgjithshme rreth kontejnerit:

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

Ju mund të rivendosni një enë nga një fotografi duke përdorur komandën lxc restore duke specifikuar kontejnerin për të cilin do të kryhet restaurimi dhe pseudonimi i fotografisë së çastit:

lxc restore alp snapshot1

Komanda e mëposhtme përdoret për të fshirë një fotografi. Ju lutemi vini re se sintaksa e komandës nuk është e ngjashme me të gjitha të tjerat; këtu duhet të specifikoni një prerje përpara pas emrit të kontejnerit. Nëse vija e pjerrët hiqet, atëherë komanda për të fshirë një pamje të çastit interpretohet si një komandë për të fshirë një kontejner!

lxc delete alp/snapshot1

Në shembullin e mësipërm, ne shikuam të ashtuquajturat fotografi pa shtetësi. LXD ka gjithashtu një lloj tjetër fotografie - statusful, i cili ruan gjendjen aktuale të të gjitha proceseve në kontejner. Ka një sërë veçorish interesante dhe të dobishme që lidhen me fotografitë e gjendjes.

Çfarë tjetër? ^

• Një modul është i disponueshëm për zhvilluesit e Python PyLXD i cili ofron një API për LXD

PËRDITËSIM 10.04.2020/15/00 XNUMX:XNUMX: U shtua navigacion

Burimi: www.habr.com