LXD yra naujos kartos sistemos konteinerių tvarkyklė, todėl sakoma šaltinis. Ji siūlo vartotojo sąsają, panašią į virtualias mašinas, tačiau vietoj jos naudoja „Linux“ konteinerius.

LXD šerdis yra privilegijuotas demonas (paslauga, veikianti su root teisėmis), teikianti REST API per vietinį unix lizdą, taip pat per tinklą, jei įdiegta atitinkama konfigūracija. Klientai, pvz., komandų eilutės įrankis, pateiktas su LXD, teikia užklausas per šią REST API. Tai reiškia, kad nesvarbu, ar naudojatės vietiniu, ar nuotoliniu kompiuteriu, viskas veikia taip pat.

Šiame straipsnyje mes nesigilinsime į LXD sąvokas, nenagrinėsime visų galimų galimybių, aprašytų dokumentacijoje, įskaitant naujausią LXD palaikymą QEMU virtualiose mašinose lygiagrečiai su konteineriais. Vietoj to, išmoksime tik konteinerių valdymo pagrindus – saugyklų telkinių nustatymą, tinklų kūrimą, konteinerio paleidimą, išteklių apribojimų taikymą ir momentinių nuotraukų naudojimą, kad gautumėte pagrindinį supratimą apie LXD ir galėtumėte naudoti konteinerius Linux sistemoje.

Norėdami gauti visą informaciją, žr. oficialų šaltinį:

• Kūrėjo svetainė
• Įrašai
• forumas

Navigacija

• Diegimas LXD
  • LXD diegimas Ubuntu platinimuose
  • LXD diegimas Arch Linux platinimuose
• LXD saugykla (saugykla)
• Inicijuoja LXD
  • Saugyklos failų sistemos pasirinkimas
  • Tinklo ir saugyklos fondo inicijavimas naudojant vedlį
  • Papildomo saugyklos baseino sukūrimas
    • Padidinkite saugyklos baseino dydį
    • Automatinis grįžtamojo ryšio failo įterpimas į grįžtamojo ryšio įrenginio lizdą
  • Saugumas. Sudėtinio rodinio privilegijos
  • Virtualaus tinklo jungiklio sukūrimas
  • Konfigūracijos profilis
    • Profilio redagavimas
    • Naujų profilių kūrimas
  • Vaizdų saugykla
    • Nuotolinės vaizdų saugyklos
    • Vietinė vaizdų saugykla
  • LXD konfigūracija
• Konteinerio kūrimas ir tvarkymas
  • Statinio IP adreso nustatymas
  • Talpyklos išėmimas
  • Prieiga prie konteinerio
  • Konteinerių išteklių valdymas
    • RAM išteklių apribojimas
    • CPU išteklių limitas
    • Vietos diske apribojimas
    • Išteklių vartojimo statistika
  • Darbas su momentinėmis nuotraukomis

Diegimas LXD ^

LXD diegimas Ubuntu platinimuose ^

Ubuntu 19.10 platinimo pakete lxd yra įjungta transliacija užklijuojamas paketas:

apt search lxd

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

Tai reiškia, kad vienu metu bus įdiegti du paketai: vienas kaip sistemos paketas, o kitas – kaip greitasis paketas. Sistemoje įdiegus du paketus, gali kilti problemų, kai sistemos paketas gali tapti našlaičiais, jei pritraukimo paketą pašalins pritraukimo paketų tvarkyklė.

Rasti paketą lxd snap saugykloje galite naudoti šią komandą:

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

Vykdydami komandą list galite įsitikinti, kad pakuotė lxd dar neįdiegta:

snap list

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

Nepaisant to, kad LXD yra greitasis paketas, jis turi būti įdiegtas per sistemos paketą lxd, kuri sistemoje sukurs atitinkamą grupę, reikalingos komunalinės paslaugos /usr/bin ir tt

sudo apt update
sudo apt install lxd

Įsitikinkite, kad paketas įdiegtas kaip greitas paketas:

snap list

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

LXD diegimas Arch Linux platinimuose ^

Norėdami įdiegti LXD paketą sistemoje, turite paleisti šias komandas: pirmoji atnaujins saugykloje esančių sistemos paketų sąrašą, antrasis tiesiogiai įdiegs paketą:

sudo pacman -Syyu && sudo pacman -S lxd

Įdiegus paketą, norint valdyti LXD paprastas vartotojas, jis turi būti įtrauktas į sistemos grupę lxd:

sudo usermod -a -G lxd user1

Įsitikinkite, kad vartotojas user1 įtraukta į grupę lxd:

id -Gn user1

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

Jei grupė lxd sąraše nerodomas, tuomet reikia dar kartą suaktyvinti vartotojo seansą. Norėdami tai padaryti, turite atsijungti ir prisijungti prie to paties vartotojo.

Įjungti systemd LXD paslaugos įkėlimas paleidžiant sistemą:

sudo systemctl enable lxd

Pradėkime paslaugą:

sudo systemctl start lxd

Paslaugos būsenos tikrinimas:

sudo systemctl status lxd

LXD saugykla (saugykla) ^

Prieš pradedant inicijavimą, turime suprasti, kaip LXD saugykla yra logiškai išdėstyta.

Saugykla (saugojimas) susideda iš iš vieno ar kelių Sandėliavimo baseinas kuri naudoja vieną iš palaikomų failų sistemų, tokių kaip ZFS, BTRFS, LVM arba įprasti katalogai. kas Sandėliavimo baseinas yra padalintas į tūrius (Saugyklos tūris), kuriuose yra vaizdų, konteinerių ar duomenų kitiems tikslams.

• Vaizdai - tai yra specialiai surinkti platinimai be Linux branduolio ir pasiekiami iš išorinių šaltinių
• Konteineriai - tai yra paskirstymai iš vaizdų, paruošti naudoti
• Momentinės nuotraukos – Tai yra konteinerių, į kuriuos galite grįžti, būklės momentinės nuotraukos

Norėdami valdyti LXD saugyklą, naudokite komandą lxc storage sertifikatas, kurį galite gauti nurodydami raktą - lxc storage --help

Ši komanda rodo visų sąrašą Sandėliavimo baseinas LXD saugykloje:

lxc storage list

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

Norėdami peržiūrėti visų sąrašą Saugyklos tūris pasirinktoje Sandėliavimo baseinas tarnauja komandai 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       |
+-----------+----------------------------------+-------------+---------+

Taip pat, jei už Sandėliavimo baseinas Kuriant buvo pasirinkta BTRFS failų sistema, tada gaukite sąrašą Saugyklos tūris arba porūšiai BTRFS interpretacijoje galite naudoti šios failų sistemos įrankių rinkinį:

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

Inicijuoja LXD ^

Prieš kurdami ir naudodami konteinerius, turite atlikti bendrą LXD inicijavimą, kuris sukuria ir sukonfigūruoja tinklą ir saugyklą. Tai galima padaryti rankiniu būdu naudojant standartines kliento komandas, kurios yra sąraše, iškvietus komandą lxc --help arba naudojant inicijavimo vedlį lxd init atsakydamas į keletą klausimų.

Saugyklos failų sistemos pasirinkimas ^

Inicijuojant LXD užduoda keletą klausimų, įskaitant failų sistemos tipo nustatymą pagal numatytuosius nustatymus Sandėliavimo baseinas. Pagal numatytuosius nustatymus jai pasirenkama BTRFS failų sistema. Sukūrus bus neįmanoma pakeisti į kitą FS. Siūloma pasirinkti FS funkcijų palyginimo lentelė:

ypatybė
katalogas
Btrfs
LVM
ZFS
CEPH

Optimizuota vaizdų saugykla
ne
taip
taip
taip
taip

Optimizuotas egzempliorių kūrimas
ne
taip
taip
taip
taip

Optimizuotas momentinių nuotraukų kūrimas
ne
taip
taip
taip
taip

Optimizuotas vaizdo perkėlimas
ne
taip
ne
taip
taip

Optimizuotas egzempliorių perkėlimas
ne
taip
ne
taip
taip

Kopijuoti rašant
ne
taip
taip
taip
taip

Blokų pagrindu
ne
ne
taip
ne
taip

Momentinis klonavimas
ne
taip
taip
taip
taip

Sandėliavimo tvarkyklė, kurią galima naudoti konteinerio viduje
taip
taip
ne
ne
ne

Atkurti iš senesnių momentinių nuotraukų (ne naujausių)
taip
taip
taip
ne
taip

Sandėliavimo kvotos
taip (*)
taip
taip
taip
ne

Tinklo ir saugyklos fondo inicijavimas naudojant vedlį ^

Kita komanda, į kurią žiūrėsime, siūlo nustatyti pagrindinius LXD komponentus atsakant į paprastus klausimus naudojant inicijavimo vedlį.

Vykdyti komandą lxc init ir po dvitaškio įveskite atsakymus į klausimus, kaip parodyta toliau pateiktame pavyzdyje, arba pakeiskite juos pagal savo sąlygas:

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

Papildomo saugyklos baseino sukūrimas ^

Ankstesniame žingsnyje sukūrėme Sandėliavimo baseinas kuriam buvo suteiktas vardas ssdpool ir kurio failas yra mano sistemoje adresu /var/lib/lxd/disks/ssdpool.img. Šis failų sistemos adresas atitinka fizinį SSD diską mano kompiuteryje.

Toliau pateikiami veiksmai, siekiant išplėsti supratimą apie atliekamą vaidmenį Sandėliavimo baseinas saugykloje sukursime antrą Sandėliavimo baseinas kuris fiziškai bus kitokio tipo diske, HDD. Problema ta, kad LXD neleidžia kurti Sandėliavimo baseinas iš adreso /var/lib/lxd/disks/ ir net simbolinės nuorodos neveiks, žiūrėkite kūrėjo atsakymą. Šį apribojimą galime apeiti inicijuodami / formatuodami Sandėliavimo baseinas nurodydami reikšmę kaip blokinį įrenginį, o ne kelią į grįžtamojo ryšio failą, nurodydami tai rakte source.

Taigi, prieš kuriant Sandėliavimo baseinas turite apibrėžti grįžtamojo ryšio failą arba esamą failų sistemos skaidinį, kurį jis naudos. Norėdami tai padaryti, sukursime ir naudosime failą, kurio dydį apribosime iki 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

Prijunkite atgalinio ryšio failą prie nemokamo atgalinio ryšio įrenginio:

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

/dev/loop1

Rakto dėka --show įvykdžius komandą į ekraną grąžinamas įrenginio, prie kurio prijungtas mūsų grįžtamojo ryšio failas, pavadinimas. Jei reikia, galime parodyti visų tokio tipo užimtų įrenginių sąrašą, kad įsitikintume, jog mūsų veiksmai yra teisingi:

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

Iš sąrašo galite sužinoti, kad įrenginys turi /dev/loop1 įtrauktas atgalinis failas /mnt/work/lxd/hddpool.img, ir įrenginyje /dev/loop0 įtrauktas atgalinis failas /var/lib/lxd/disks/ssdpool.img kuri atitinka numatytąjį Sandėliavimo baseinas.

Ši komanda sukuria naują Sandėliavimo baseinas LXD, remiantis ką tik paruoštu grįžtamojo ryšio failu. LXD formatuos grįžtamojo ryšio failą /mnt/work/lxd/hddpool.img įrenginyje /dev/loop1 BTRFS failų sistemai:

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

Parodykime visų sąrašą Sandėliavimo baseinas į ekraną:

lxc storage list

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

Padidinkite saugyklos baseino dydį ^

Po sukūrimo Sandėliavimo baseinas, jei reikia, jį galima išplėsti. Dėl Sandėliavimo baseinas Remdamiesi BTRFS failų sistema, paleiskite šias komandas:

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

Automatinis grįžtamojo ryšio failo įterpimas į grįžtamojo ryšio įrenginio lizdą ^

Turime vieną nedidelę problemą, perkraunant pagrindinę sistemą, failą /mnt/work/lxd/hddpool.img „išskris“ iš įrenginio /dev/loop1 ir LXD paslauga įkeliant sugenda, nes jos nematys šiame įrenginyje. Norėdami išspręsti šią problemą, turite sukurti sistemos paslaugą, kuri įterps šį failą į įrenginį /dev/loop1 kai paleidžiama pagrindinio kompiuterio sistema.

Kurkime vienetas Failo tipas tarnyba в /etc/systemd/system/ SystemD inicijavimo sistemai:

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

Suaktyvinkite paslaugą:

sudo systemctl enable lxd-hddpool

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

Iš naujo paleidę pagrindinę sistemą, patikriname paslaugos būseną:

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

Iš išvesties galime patikrinti, ar paslaugos būsena yra aktyvus, nepaisant to, kad mūsų scenarijaus vykdymas iš vienos komandos buvo baigtas, ši parinktis leido mums tai padaryti RemainAfterExit=true.

Saugumas. Sudėtinio rodinio privilegijos ^

Kadangi visi konteinerio procesai iš tikrųjų veikia atskirai pagrindinėje sistemoje, naudojant jos branduolį, siekiant toliau apsaugoti konteinerio procesų prieigą prie pagrindinės sistemos, LXD siūlo proceso privilegiją, kur:

• Privilegijuotieji konteineriai - tai yra konteineriai, kuriuose procesai su UID ir GID atitinka tą patį savininką kaip ir pagrindinėje sistemoje. Pavyzdžiui, procesas, vykdomas konteineryje, kurio UID yra 0, turi visas tokias pačias prieigos teises kaip ir pagrindinės sistemos procesas, kurio UID yra 0. Kitaip tariant, pagrindinis vartotojas konteineryje turi visas teises ne tik sudėtinį rodinį, bet ir pagrindinio kompiuterio sistemoje, jei jis gali išeiti už atskiros sudėtinio rodinio vardų erdvės.

• Neprivilegijuoti konteineriai - tai yra konteineriai, kuriuose procesai priklauso UID ir GID savininkui, kurių skaičius yra nuo 0 iki 65535, tačiau pagrindinės sistemos savininkas yra užmaskuotas naudojant atitinkamai pridėtus SubUID ir SubGID bitus. Pavyzdžiui, vartotojas, kurio UID=0 konteineryje, bus matomas pagrindinio kompiuterio sistemoje kaip SubUID + UID. Tai apsaugo pagrindinę sistemą, nes jei kuris nors konteineryje esantis procesas gali išeiti iš savo izoliuotos vardų erdvės, jis gali susisiekti su pagrindine sistema tik kaip procesas su nežinomu, labai aukštu UID / GID.

Pagal numatytuosius nustatymus naujai sukurti konteineriai turi neprivilegijuotą būseną, todėl turime apibrėžti SubUID ir SubGID.

Sukurkime du konfigūracijos failus, kuriuose atitinkamai nustatysime SubUID ir SubGID kaukę:

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

Norint pritaikyti pakeitimus, reikia iš naujo paleisti LXD paslaugą:

sudo systemctl restart lxd

Virtualaus tinklo jungiklio sukūrimas ^

Kadangi anksčiau tinklą inicijavome naudodami inicijavimo vedlį lxd init ir sukūrė tinklo įrenginį lxdbr0, tada šiame skyriuje tiesiog susipažinsime su tinklų kūrimu LXD ir kaip sukurti virtualų jungiklį (tiltą) naudojant kliento komandą.

Šioje diagramoje parodyta, kaip jungiklis (tiltas) sujungia pagrindinį kompiuterį ir konteinerius į tinklą:

Konteineriai gali susisiekti per tinklą su kitais konteineriais arba pagrindiniu kompiuteriu, kuriame šie konteineriai aptarnaujami. Norėdami tai padaryti, turite susieti konteinerių virtualiąsias tinklo plokštes su virtualiu jungikliu. Pirmiausia sukursime jungiklį, o konteinerio tinklo sąsajos bus susietos kituose skyriuose, kai bus sukurtas pats konteineris.

Ši komanda sukuria jungiklį su potinkliu 10.0.5.0/24 ir IPv4 adresas 10.0.5.1/24, taip pat apima ipv4.nat kad konteineriai galėtų pasiekti internetą per pagrindinį kompiuterį naudodami NAT paslaugą:

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

LXD pasiekiamų tinklo įrenginių sąrašo tikrinimas:

lxc network list

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

Taip pat galite patikrinti, ar tinklo įrenginys buvo sukurtas naudojant standartinį Linux platinimo įrankį - ip link arba 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

Konfigūracijos profilis ^

Kiekvienas LXD konteineris turi savo konfigūraciją ir gali ją išplėsti pasauliniu mastu deklaruotomis konfigūracijomis konfigūracijos profiliai. Konfigūracijos profilių taikymas konteineriui turi kaskadinį modelį. Tai parodo šis pavyzdys:

Šiame pavyzdyje LXD sistemoje buvo sukurti trys profiliai: default, hddpool и hostfs. Visi trys profiliai taikomi konteineriui, kurio konfigūracija yra vietinė (pilka sritis). Profilis default turi įrenginį root kuris turi parametrą pool yra lygus ssdpool, tačiau dėl kaskadinės konfigūracijos taikymo modelio konteineriui galime pritaikyti profilį hddpool kuris turi parametrą pool nepaisys to paties parametro iš profilio default ir konteineris gaus įrenginio konfigūraciją root su parametru pool lygus hddpoolir profilį hostfs tiesiog prideda naują įrenginį prie konteinerio.

Norėdami pamatyti galimų konfigūracijos profilių sąrašą, naudokite šią komandą:

lxc profile list

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

Visą galimų komandų, skirtų darbui su profiliu, sąrašą galima gauti pridėjus raktą --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

Profilio redagavimas ^

Numatytasis konfigūracijos profilis default neturi konteinerio tinklo plokštės konfigūracijos ir visi naujai sukurti konteineriai neturi tinklo, jiems reikia sukurti vietinio (dedikuoto) tinklo įrenginius su atskira komanda, tačiau konfigūracijoje galime sukurti globalaus tinklo įrenginį profilis, kuris bus bendrinamas tarp visų šį profilį naudojančių sudėtinių rodinių. Tokiu būdu, iškart po komandos sukurti naują konteinerį, jie turės tinklą su prieiga prie tinklo. Tuo pačiu metu nėra jokių apribojimų, prireikus visada galime sukurti vietinio tinklo įrenginį vėliau.

Ši komanda pridės įrenginį prie konfigūracijos profilio eth0 tipo nic prijungtas prie tinklo lxdbr0:

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

Svarbu pažymėti, kad kadangi mes iš tikrųjų įtraukėme įrenginį į konfigūracijos profilį, jei įrenginyje nurodėme statinį IP adresą, visi konteineriai, kurie naudos šį profilį, turės tą patį IP adresą. Jei reikia sukurti konteinerį su statiniu konteineriui skirtu IP adresu, tinklo įrenginio konfigūraciją turėtumėte sukurti konteinerio lygiu (vietinė konfigūracija) su IP adreso parametru, o ne profilio lygiu.

Pažiūrėkime profilį:

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

Šiame profilyje matome, kad visiems naujai sukurtiems konteineriams bus sukurti du įrenginiai:

• eth0 - Prietaiso tipas nic prijungtas prie jungiklio (tinklo tilto) lxdbr0
• root - Prietaiso tipas disk kuri naudoja saugyklos baseiną ssdpool

Naujų profilių kūrimas ^

Norėdami naudoti anksčiau sukurtą Sandėliavimo baseinas konteinerius, sukurkite konfigūracijos profilį ssdroot kuriame pridėsime tokį įrenginį kaip disk su tvirtinimo tašku / (root) naudojant anksčiau sukurtą Sandėliavimo baseinas - ssdpool:

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

Panašiai sukuriame tokį įrenginį kaip disk, bet šiuo atveju naudojant Sandėliavimo baseinas - hddpool:

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

Konfigūracijos profilių tikrinimas:

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

Vaizdų saugykla ^

Konteineriai kuriami iš vaizdų, kurie yra specialiai surinkti paskirstymai, neturintys Linux branduolio. Todėl prieš paleisdami konteinerį, jį reikia įdiegti iš šio vaizdo. Vaizdų šaltinis yra vietinė saugykla, į kurią vaizdai atsisiunčiami iš išorinių saugyklų.

Nuotolinės vaizdų saugyklos ^

Pagal numatytuosius nustatymus LXD yra sukonfigūruotas gauti vaizdus iš trijų nuotolinių šaltinių:

• ubuntu: (stabiliems Ubuntu vaizdams)
• ubuntu kasdien: (kasdieniams Ubuntu vaizdams)
• vaizdai: (daugeliui kitų platinimų)

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

Pavyzdžiui, saugykla ubuntu: yra šie vaizdai:

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

Kad būtų rodomas ribotas stulpelių skaičius, naudojome parinktį -c su parametrais dasut, taip pat apribojo sąrašo ilgį komanda head.

Galimas filtravimas, kad būtų rodomas vaizdų sąrašas. Šioje komandoje bus išvardytos visos galimos platinimo architektūros 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        |
+------------------------------+--------------------------------------+--------------+

Vietinė vaizdų saugykla ^

Norėdami pradėti naudoti konteinerį, turite pridėti vaizdą iš pasaulinės saugyklos į vietinę local:. Dabar vietinė saugykla tuščia, komanda tuo įsitikins lxc image list. Jei metodas list nenurodykite saugyklos, tada vietinė saugykla bus naudojama pagal numatytuosius nustatymus - local:

lxc image list local:

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

Vaizdai saugykloje tvarkomi šiais būdais:

Komanda
aprašymas

lxc vaizdas pravardė
Tvarkykite vaizdų slapyvardžius

lxc vaizdas nukopijuoti
Kopijuoti vaizdus tarp serverių

lxc vaizdas panaikinti
Ištrinti vaizdus

lxc vaizdas redaguoti
Redaguoti vaizdo ypatybes

lxc vaizdas eksportuoti
Eksportuoti ir atsisiųsti paveikslėlius

lxc vaizdas importuoti
Importuokite vaizdus į vaizdų parduotuvę

lxc vaizdas informacijos
Rodyti naudingos informacijos apie vaizdus

lxc vaizdas sąrašas
Pateikite vaizdų sąrašą

lxc vaizdas atnaujinti
Atnaujinti vaizdus

lxc vaizdas Parodyti
Rodyti vaizdo ypatybes

Nukopijuokite vaizdą į vietinę saugyklą iš pasaulinės saugyklos images::

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

Image copied successfully!

Parodykime visų šiuo metu vietinėje saugykloje esančių vaizdų sąrašą local::

lxc image -c lfdatsu list local:

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

LXD konfigūracija ^

Be interaktyvaus režimo, LXD taip pat palaiko neinteraktyvų konfigūracijos diegimo režimą, tai yra tada, kai konfigūracija nurodoma YAML failo forma, specialus formatas, leidžiantis įdiegti visą konfigūraciją iš karto, apeinant vykdymą. daugelio interaktyvių komandų, kurios buvo aptartos aukščiau šiame straipsnyje, įskaitant tinklo konfigūraciją, konfigūracijos profilių kūrimą ir kt. Šios srities čia neapimsime, galite tai patikrinti patys. dokumentacijoje.

Kita interaktyvi komanda lxc config kurią apžvelgsime leidžia nustatyti konfigūraciją. Pavyzdžiui, norėdami užtikrinti, kad į vietinę saugyklą atsisiųsti vaizdai nebūtų automatiškai atnaujinami iš visuotinių saugyklų, galime įjungti šį veiksmą naudodami šią komandą:

lxc config set images.auto_update_cached=false

Konteinerio kūrimas ir tvarkymas ^

Norėdami sukurti konteinerį, naudokite komandą lxc init kurioms perduodamos vertybės репозиторий:образ tada norimą konteinerio ID. Saugyklą galima nurodyti kaip vietinę local: taip pat bet koks pasaulinis. Jei saugykla nenurodyta, pagal numatytuosius nustatymus vaizdo paieškai naudojama vietinė saugykla. Jei vaizdas nurodytas iš visuotinės saugyklos, vaizdas pirmiausia bus atsiųstas į vietinę saugyklą ir naudojamas kuriant konteinerį.

Paleiskite šią komandą, kad sukurtume pirmąjį konteinerį:

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

Pažvelkime į komandų klavišus, kuriuos naudojame čia:

• alpine3 — Vaizdui, kuris anksčiau buvo įkeltas į vietinę saugyklą, nurodytas slapyvardis (alias). Jei šio vaizdo slapyvardis nebuvo sukurtas, visada galite nurodyti vaizdą pagal jį pirštų atspaudas kuris rodomas lentelėje.
• alp – nustato konteinerio identifikatorių
• --storage — Šis klavišas nurodo, kuriame Sandėliavimo baseinas bus sukurtas konteineris
• --profile — Šie raktai pakopoje taiko konfigūraciją iš anksčiau sukurtų konfigūracijos profilių konteineriui

Paleidžiame konteinerį, kuris pradeda paleisti platinimo init sistemą:

lxc start alp

Taip pat galite naudoti komandą lxc launch kuri leidžia sujungti komandas lxc init и lxc start per vieną operaciją.

Konteinerio būklės patikrinimas:

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

Konteinerio konfigūracijos tikrinimas:

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

Skyriuje profiles galime įsitikinti, kad šis konteineris naudoja du konfigūracijos profilius − default и hddroot. Skyriuje devices galime aptikti tik vieną įrenginį, nes tinklo įrenginys buvo sukurtas profilio lygiu default. Norėdami pamatyti visus konteinerio naudojamus įrenginius, turite pridėti raktą --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: ""

Statinio IP adreso nustatymas ^

Jei bandysime nustatyti tinklo įrenginio IP adresą eth0 komanda lxc config device set alp skirtas konteinerio konfigūracijai, tada gausime klaidą, kuri praneš, kad įrenginio nėra, nes įrenginys eth0 kurį naudoja konteineris, priklauso profiliui default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Žinoma, galime nustatyti statinį IP adresą eth0 įrenginių profilyje, tačiau jis bus toks pat visuose konteineriuose, kuriuose bus naudojamas šis profilis. Todėl pridėkime konteineriui skirtą įrenginį:

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

Tada turite iš naujo paleisti konteinerį:

lxc restart alp

Jei dabar pažvelgsime į konteinerio konfigūraciją, šios parinkties naudoti nereikia --expanded norėdami pamatyti tinklo įrenginį eth0, nes sukūrėme jį konteinerio lygiu ir jis perėjo per tą patį įrenginį iš profilio 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: ""

Talpyklos išėmimas ^

Norėdami pašalinti konteinerį, naudokite komandą lxc delete, bet prieš išimant konteinerį, jį reikia sustabdyti naudojant komandą lxc stop:

lxc stop alp

lxc list

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

Po to, kai patikrinome, ar konteinerio būsena tapo STOPPED, jį galima išimti iš Sandėliavimo baseinas:

lxc delete alp

Prieiga prie konteinerio ^

Norėdami tiesiogiai vykdyti komandas konteineryje, apeinant tinklo ryšius, naudokite komandą lxc exec kuri vykdo komandas konteineryje nepaleidžiant sistemos apvalkalo. Jei jums reikia vykdyti komandą apvalkale naudojant apvalkalo šablonus, tokius kaip kintamieji, failų peradresavimai (vamzdis) ir kt., tuomet turite aiškiai paleisti apvalkalą ir perduoti komandą kaip raktą, pavyzdžiui:

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

Komanda naudojo specialų pabėgimo simbolį dėl ypatingo charakterio $ kad kintamasis $HOME nebuvo interpretuojamas pagrindiniame kompiuteryje, bet buvo interpretuojamas tik konteinerio viduje.

Taip pat galima paleisti interaktyvų apvalkalo režimą, o tada užbaigti seansą paspaudus spartųjį klavišą CTRL+D:

lxc exec alp -- /bin/sh

Konteinerių išteklių valdymas ^

LXD galite valdyti konteinerio išteklius naudodami specialų konfigūracijos rinkinį. Galima rasti visą konteinerio konfigūracijos parametrų sąrašą dokumentacijoje.

RAM išteklių apribojimas ^

Parametras limits.memory riboja talpykloje pasiekiamos RAM kiekį. Reikšmė yra skaičius ir vienas iš turimos priesagos.

Nustatykime konteinerio RAM limitą į 256 MB:

lxc config set alp limits.memory 256MB

Taip pat yra ir kitų atminties ribojimo parametrų:

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

Komanda lxc config show leidžia rodyti visą sudėtinio rodinio konfigūraciją, įskaitant taikomą išteklių limitą, kuris buvo nustatytas:

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 išteklių limitas ^

Yra keletas būdų, kaip apriboti procesoriaus išteklius. apribojimų tipai:

• limit.cpu - susieja konteinerį su vienu ar daugiau procesoriaus branduolių
• limits.cpu.allowance - valdo arba CFS planuoklio kvotas, kai pasibaigia terminas, arba universalų procesoriaus išteklių dalijimosi mechanizmą, kai praeina procentas
• limits.cpu.priority - planuotojo prioritetas, kai keliems egzemplioriams, dalijantiems procesorių rinkinį, priskiriama tokia pati procesorių procentinė dalis

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

Vietos diske apribojimas ^

Be apribojimų, tokių limits.read, limits.write taip pat galime apriboti konteinerio sunaudojamos vietos diske kiekį (veikia tik su ZFS arba BTRFS):

lxc config device set alp root size=2GB

Po įdiegimo, parametre devices.root.size Mes galime patikrinti nustatytą limitą:

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

Norėdami peržiūrėti panaudotas disko kvotas, galime gauti iš komandos 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

Nepaisant to, kad pagrindiniam konteinerio įrenginiui nustatėme 2 GB apribojimą, sistemos komunalinės paslaugos, pvz. df nematys šio apribojimo. Norėdami tai padaryti, atliksime nedidelį testą ir išsiaiškinsime, kaip tai veikia.

Sukurkime 2 naujus identiškus konteinerius Sandėliavimo baseinas (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         |
+------+---------+------------------+------+-----------+-----------+

Sukurkime 1 GB failą viename iš konteinerių:

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

Įsitikinkite, kad failas sukurtas:

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

Jei pažvelgsime į antrąjį konteinerį, patikrinkite, ar toje pačioje vietoje yra failas, tada šio failo ten nebus, ko tikimasi, nes konteineriai kuriami atskirai Saugyklos tūris tame pačiame Sandėliavimo baseinas:

lxc exec alp2 -- ls -lh
total 0

Bet palyginkime jo sukurtas vertes df ant vieno ir kito konteinerio:

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

Įrenginys /dev/loop1 sumontuotas kaip šakninis skaidinys Sandėliavimo baseinas kuriuos naudoja šie konteineriai, todėl jų tūris dalijasi tarp dviejų.

Išteklių vartojimo statistika ^

Galite peržiūrėti konteinerio išteklių suvartojimo statistiką naudodami komandą:

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

Darbas su momentinėmis nuotraukomis ^

LXD turi galimybę kurti momentines nuotraukas ir iš jų atkurti konteinerio būseną.

Norėdami sukurti momentinę nuotrauką, paleiskite šią komandą:

lxc snapshot alp snapshot1

Komanda lxc snapshot nera rakto list, todėl norėdami peržiūrėti momentinių vaizdų sąrašą, turite naudoti komandą, kuri rodo bendrą informaciją apie konteinerį:

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

Galite atkurti konteinerį iš momentinės nuotraukos naudodami komandą lxc restore nurodant konteinerį, kuriam bus atliktas atkūrimas, ir momentinės nuotraukos slapyvardį:

lxc restore alp snapshot1

Ši komanda naudojama momentinei nuotraukai ištrinti. Atkreipkite dėmesį, kad komandos sintaksė nėra panaši į visų kitų; čia reikia nurodyti pasvirąjį brūkšnį po konteinerio pavadinimo. Jei pasvirasis brūkšnys praleistas, tada komanda ištrinti momentinę nuotrauką interpretuojama kaip komanda ištrinti konteinerį!

lxc delete alp/snapshot1

Aukščiau pateiktame pavyzdyje apžvelgėme taip vadinamus momentinius vaizdus be būsenos. LXD turi kito tipo momentines nuotraukas – būsenas, kurios išsaugo esamą visų konteineryje esančių procesų būseną. Yra daug įdomių ir naudingų funkcijų, susijusių su būsenos momentinėmis nuotraukomis.

Kas dar? ^

• Python kūrėjams yra prieinamas modulis PyLXD kuri suteikia API LXD

ATNAUJINIMAS 10.04.2020-15-00 XNUMX:XNUMX: Pridėta navigacija

Šaltinis: www.habr.com