LXD — je manažér systémových kontajnerov novej generácie, hovorí sa zdroj. Ponúka používateľské rozhranie podobné virtuálnym strojom, avšak namiesto toho používa kontajnery Linuxu.

Jadro LXD — je privilegovaný démon (služba spustená s právami roota), ktorý poskytuje REST API cez lokálny unix socket a tiež cez sieť, ak je nastavená príslušná konfigurácia. Klienti, ako je príkazový nástroj dodávaný s LXD, posielajú požiadavky cez toto REST API. To znamená, že bez ohľadu na to, či sa obraciate na lokálny hostiteľ alebo na vzdialený, všetko funguje rovnako.

V tomto článku sa nebudeme podrobne zaoberať konceptmi LXD, nepreskúmame všetky dostupné funkcie uvedené v dokumentácii, vrátane nedávnej implementácie v posledných verziách LXD podpory virtuálnych strojov QEMU paralelne s kontajnermi. Namiesto toho sa zameriame len na základné funkcie správy kontajnerov — nastavíme úložné pooly, sieť, spustíme kontajner, aplikujeme limity na zdroje a tiež preskúmame, ako používať snímky, aby ste mohli získať základný prehľad o LXD a používať kontajnery v Linuxe.

Pre získanie úplných informácií sa treba obrátiť na oficiálny zdroj:

• Webová stránka vývojára
• Dokumentácia
• Fórum

Navigácia

• Inštalácia LXD
  • Inštalácia LXD v distribúciách Ubuntu
  • Inštalácia LXD v distribúciách Arch Linux
• Úložisko LXD (Storage)
• Inicializácia LXD
  • Výber súborového systému pre Storage Pool
  • Inicializácia siete a Storage Pool pomocou asistenta
  • Vytvorenie dodatočného Storage Pool
    • Zvýšenie veľkosti Storage Pool
    • Automatické vloženie loopback súboru do slotu loopback zariadenia
  • Bezpečnosť. Privilégia kontajnerov
  • Vytvorenie virtuálneho prepínača siete
  • Profil konfigurácie
    • Úprava profilu
    • Vytvorenie nových profilov
  • Repúbnik obrazov
    • Vzdialené repozitáre obrazov
    • Lokálny repozitár obrazov
  • Konfigurácia LXD
• Vytvorenie a správa kontajnera
  • Nastavenie statickej IP adresy
  • Odstránenie kontajnera
  • Prístup k kontajneru
  • Správa zdrojov kontajnera
    • Obmedzenie zdrojov RAM (RAM)
    • Obmedzenie zdrojov CPU (CPU)
    • Obmedzenie diskového priestoru
    • Štatistika spotreby zdrojov
  • Práca so snímkami

Inštalácia LXD ^

Inštalácia LXD v distribúciách Ubuntu ^

V distribúcii Ubuntu 19.10 balík lxd má prechod na snap-balik:

apt search lxd

lxd/eoan 1:0.7 all
  Prechodný balík - lxd -> snap (lxd)

To znamená, že sa nainštalujú hneď dva balíčky, jeden systémový a druhý ako snap-pack. Inštalácia dvoch balíčkov v systéme môže spôsobiť určitý problém, pri ktorom sa systémový balíček môže stať osiroteným, ak sa snap balíček odstráni správcom snap balíčkov.

Nájsť balíček lxd v snap-repozitári je možné nasledujúcou príkazovou funkciou:

snap find lxd

Názov             Verzia        Zhrnutie
lxd              3.21           Správca systémových kontajnerov a API
lxd-demo-server  0+git.6d54658  Online softvérové demo relácie pomocou LXD
nova             ocata          OpenStack Compute Service (nova)
nova-hypervisor  ocata          OpenStack Compute Service - KVM Hypervisor (nova)
distrobuilder    1.0            Nástroj na vytvorenie obrazov pre LXC a LXD
fabrica          0.1            Vytvorte snápy jednoducho tak, že nasmerujete webový formulár na...
satellite        0.1.2          Pokročilá škálovateľná platforma otvorených zdrojov pre inteligenciu

Spustením príkazu list sa môžeme uistiť, že balíček lxd ešte nie je nainštalovaný:

snap list

Názov  Verzia    Rev   Sledovanie  Vydavateľ   Poznámky
core  16-2.43.3  8689  stable    canonical✓  core

Napriek tomu, že LXD je snap-pack, je potrebné ho nainštalovať cez systémový balíček lxd, ktorý vytvorí v systéme príslušnú skupinu, potrebné utilitné nástroje v /usr/bin a pod.

sudo apt update
sudo apt install lxd

Uistíme sa, že balíček je nainštalovaný ako snap-pack:

snap list

Názov  Verzia    Rev    Sledovanie  Vydavateľ   Poznámky
core  16-2.43.3  8689   stable    canonical✓  core
lxd   3.21       13474  stable\/…  canonical✓  -

Inštalácia LXD v distribúciách Arch Linux ^

Na inštaláciu balíčka LXD v systéme je potrebné spustiť nasledujúce príkazy, prvý — aktualizuje zoznam balíčkov v systéme dostupných v repozitári, druhý — priamo nainštaluje balíček:

sudo pacman -Syyu && sudo pacman -S lxd

Po inštalácii balíčka, pre správu LXD obyčajným používateľom je potrebné ho pridať do systémovej skupiny lxd:

sudo usermod -a -G lxd user1

Uistíme sa, že používateľ user1 bol pridaný do skupiny lxd:

id -Gn user1

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

Ak skupina lxd nie je viditeľná v zozname, je potrebné znovu aktivovať reláciu používateľa. Na to je potrebné sa odhlásiť a prihlásiť do systému pod tým istým používateľom.

Aktivujeme v systemd načítanie služby LXD pri štarte systému:

sudo systemctl enable lxd

Spustíme službu:

sudo systemctl start lxd

Kontrolujeme stav služby:

sudo systemctl status lxd

Úložisko LXD (Storage) ^

Pred začiatkom inicializácie musíme pochopiť, ako logicky funguje úložisko v LXD.

Úložisko (Storage) súčasťou z jedného alebo viacerých Storage Pool ktoré využíva jednu z podporovaných súborových systémov ako ZFS, BTRFS, LVM alebo obyčajné adresáre. Každé Storage Pool sa delí na objemy (Storage Volume) ktoré obsahujú obrazy, kontajnery alebo dáta na iné účely.

• Obrázky — to sú špeciálne zostavené distribúcie bez jadra Linux a sú dostupné z externých zdrojov
• Kontajnery — to sú rozšírené distribúcie z obrazov, pripravené na prevádzku
• Inkrementy — to sú snímky stavu kontajnerov, ku ktorým sa môžete vrátiť

Na správu úložiska v LXD slúži príkaz lxc storage na ktorý môžete získať pomoc zadaním kľúča — lxc storage --help

Nasledujúci príkaz zobrazí zoznam všetkých Storage Pool v LXD úložiskách:

lxc storage list

+---------+-------------+--------+--------------------------------+---------+
|  NÁZOV | POPIS       | OVLÁDAČ |             ZDROJ             | POUŽÍVA |
+---------+-------------+--------+--------------------------------+---------+
| hddpool |             | btrfs  | /dev/loop1                     | 2       |
+---------+-------------+--------+--------------------------------+---------+
| ssdpool |             | btrfs  | /var/lib/lxd/disks/ssdpool.img | 4       |
+---------+-------------+--------+--------------------------------+---------+

Na zobrazenie zoznamu všetkých Storage Volume v zvolenom Storage Pool slúži príkaz lxc storage volume list:

lxc storage volume list hddpool

+-------+----------------------------------+-------------+---------+
| TYP   |          NÁZOV                   | POPIS      | POUŽÍVA |
+-------+----------------------------------+-------------+---------+
| obraz | ebd565585223487526ddb3607f515... |             | 1       |
+-------+----------------------------------+-------------+---------+

lxc storage volume list ssdpool

+-----------+----------------------------------+-------------+---------+
|   TYP    |            NÁZOV                | POPIS      | POUŽÍVA |
+-----------+----------------------------------+-------------+---------+
| kontajner | alp3                             |             | 1       |
+-----------+----------------------------------+-------------+---------+
| kontajner | jupyter                          |             | 1       |
+-----------+----------------------------------+-------------+---------+
| obraz     | ebd565585223487526ddb3607f515... |             | 1       |
+-----------+----------------------------------+-------------+---------+

Takisto, ak bola pri vytváraní vybraná súborová sústava BTRFS, je možné získať zoznam Storage Pool subvolume Storage Volume alebo v interpretácii BTRFS pomocou nástrojov tejto súborovej sústavy: sudo btrfs subvolume list -p /var/lib/lxd/storage-pools/hddpoolID 257 gen 818 rodič 5 vrchol 5 cesta images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3

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

ID 257 gen 1820 rodič 5 vrchol 5 cesta images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
ID 260 gen 1819 rodič 5 vrchol 5 cesta containers/jupyter
ID 263 gen 1820 rodič 5 vrchol 5 cesta containers/alp3

Pred vytvorením a používaním kontajnerov je potrebné vykonať všeobecnú inicializáciu LXD, ktorá vytvára a nastavuje sieť a taktiež úložisko. To je možné vykonať ručne pomocou štandardných príkazov klienta, ktoré sú dostupné v zozname volaním príkazu

Inicializácia LXD ^

lxc --help alebo pomocou inštalačného sprievodcu lxd init odpovedaním na niekoľko otázok. odpovedaním na niekoľko otázok.

Výber súborového systému pre Storage Pool ^

Počas inicializácie LXD sa kladie niekoľko otázok, medzi ktorými bude aj určenie typu súborového systému pre predvolený Storage Pool. Predvolene sa vyberie súborový systém BTRFS. Zmeniť na iný FS bude nemožné. Na výber FS je navrhnutá tabuľka porovnania možností:

Funkcia
Adresár
Btrfs
LVM
ZFS
CEPH

Optimalizované ukladanie obrázkov
nie
yes
yes
yes
yes

Optimalizovaná tvorba inštancií
nie
yes
yes
yes
yes

Optimalizované vytváranie snímok
nie
yes
yes
yes
yes

Optimalizovaný prenos obrázkov
nie
yes
nie
yes
yes

Optimalizovaný prenos inštancií
nie
yes
nie
yes
yes

Kopírovanie pri zápise
nie
yes
yes
yes
yes

Na báze blokov
nie
nie
yes
nie
yes

Okamžité klonovanie
nie
yes
yes
yes
yes

Ovládač úložiska použiteľný vo vnútri kontajnera
yes
yes
nie
nie
nie

Obnova zo starších snapshotov (nie najnovších)
yes
yes
yes
nie
yes

Úložiskové kvóty
áno(*)
yes
yes
yes
nie

Inicializácia siete a Storage Pool pomocou asistenta ^

Ďalšia príkaz, ktorý preskúmame, ponúka nastaviť základné komponenty LXD pomocou odpovedí na jednoduché otázky cez sprievodcu inicializáciou.

Spustite príkaz lxc init a zadajte odpovede na otázky po dvojbodke, ako je to znázornené v príklade nižšie, alebo ich upravte podľa svojich podmienok:

lxd init

Chcete použiť LXD clustering? (áno/nie) [predvolené=nie]: 
Chcete nakonfigurovať novú úložnú skupinu? (áno/nie) [predvolené=áno]: 
Názov novej úložnej skupiny [predvolené=default]: ssdpool         
Názov úložného backendu, ktorý chcete použiť (lvm, btrfs, dir) [predvolené=btrfs]: 
Vytvoríte novú BTRFS skupinu? (áno/nie) [predvolené=áno]: 
Chcete použiť existujúce blokové zariadenie? (áno/nie) [predvolené=nie]: 
Veľkosť v GB novej slučkového zariadenia (minimálne 1 GB) [predvolené=15GB]: 10GB
Chcete sa pripojiť k serveru MAAS? (áno/nie) [predvolené=nie]: 
Chcete vytvoriť nový lokálny sieťový mostík? (áno/nie) [predvolené=áno]: 
Ako chcete nazvať nový mostík? [predvolené=lxdbr0]: 
Akú IPv4 adresu chcete použiť? (notácia CIDR subnet, „auto“ alebo „none“) [predvolené=auto]: 10.0.5.1/24
Chcete, aby LXD NAToval IPv4 traffic na vašom mostíku? [predvolené=áno]: 
Akú IPv6 adresu chcete použiť? (notácia CIDR subnet, „auto“ alebo „none“) [predvolené=auto]: none
Chcete, aby bol LXD dostupný na sieti? (áno/nie) [predvolené=nie]: 
Chcete, aby sa zastarané cacheované obrázky automaticky aktualizovali? (áno/nie) [predvolené=áno] nie
Chcete, aby bol vytlačený YAML "lxd init" predseeding? (áno/nie) [predvolené=nie]: 

Vytvorenie dodatočného Storage Pool ^

V predchádzajúcom kroku sme vytvorili Storage Pool ktorému sme dali názov ssdpool a súbor, ktorý sa nachádza v mojej systéme na adrese /var/lib/lxd/disks/ssdpool.img. Táto adresa súborového systému zodpovedá fyzickému SSD disku v mojom PC.

Nasledujúcimi krokmi, na rozšírenie porozumenia toho, akú úlohu hrá Storage Pool v úložisku, vytvoríme druhý Storage Pool ktorý bude fyzicky umiestnený na inom type disku, na HDD. Problém spočíva v tom, že LXD neumožňuje vytvárať Storage Pool mimo adresu /var/lib/lxd/disks/ a dokonca ani symbolické odkazy nebudú fungovať, pozrite odpoveď vývojára. Obísť toto obmedzenie môžeme pri inicializácii/formátovaní Storage Pool určujúc hodnotu ako blokové zariadenie namiesto cesty k súboru loopback, uvedením toho v kľúči source.

Takže, pred vytvorením Storage Pool Je potrebné určiť loopback súbor alebo existujúcu partíciu vo vašom súborovom systéme, ktorú bude používať. Na tento účel vytvoríme a použijeme súbor, ktorý obmedzíme na veľkosť 10GB:

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

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

Pripojíme loopback súbor do voľného loopback zariadenia:

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

\/dev\/loop1

Vďaka kľúču --show vykonanie príkazu vráti na obrazovku názov zariadenia, do ktorého sme pripojili náš loopback súbor. Ak je to potrebné, môžeme zobraziť zoznam všetkých obsadených zariadení tohto typu, aby sme sa uistili v správnosti našich akcií:

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

Zoznam ukazuje, že v zariadení /dev/loop1 je pripojený loopback súbor /mnt/work/lxd/hddpool.img, a v zariadení /dev/loop0 je pripojený loopback súbor /var/lib/lxd/disks/ssdpool.img ktoré zodpovedá predvolenému Storage Pool.

Ďalší príkaz vytvára nový Storage Pool v LXD na základe práve pripraveného loopback súboru. LXD naformátuje loopback súbor /mnt/work/lxd/hddpool.img v zariadení /dev/loop1 pod súborový systém BTRFS:

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

Zobrazíme zoznam všetkých Storage Pool na obrazovke:

lxc storage list

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

Zvýšenie veľkosti Storage Pool ^

Po vytvorení Storage Pool, ak je to potrebné, môže sa rozšíriť. Pre Storage Pool založené na súborovom systéme BTRFS vykonajte nasledujúce príkazy:

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

Automatické vloženie loopback súboru do slotu loopback zariadenia ^

Máme jeden malý problém, pri reštarte hostiteľského systému sa súbor /mnt/work/lxd/hddpool.img "odpojí" z zariadenia /dev/loop1 a služba LXD spadne pri spúšťaní, pretože ho v tomto zariadení neuvidí. Na vyriešenie tohto problému je potrebné vytvoriť systémovú službu, ktorá do zariadenia vloží tento súbor /dev/loop1 pri spúšťaní hostiteľského systému.

Vytvoríme unit súbor typu service v /etc/systemd/system/ pre systémovú inicializáciu 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

Aktivujeme službu:

sudo systemctl enable lxd-hddpool

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

Po reštarte hostiteľského systému overíme stav služby:

systemctl status lxd-hddpool.service 

● lxd-hddpool.service - Losetup LXD Storage Pool (hddpool)
     Načítané: načítané (/etc/systemd/system/lxd-hddpool.service; povolené; predvolený preset: zakázané)
     Aktívne: aktívne (ukončené) od stredy 2020-04-08 03:43:53 MSK; pred 1 min 37 s
    Proces: 711 ExecStart=/sbin/losetup /dev/loop1 /mnt/work/lxd/hddpool.img (kód=ukončené, stav=0/SUCCESS)
   Hlavný PID: 711 (kód=ukončené, stav=0/SUCCESS)

apr 08 03:43:52 manjaro systemd[1]: Spúšťam Losetup LXD Storage Pool (hddpool)...
apr 08 03:43:53 manjaro systemd[1]: Dokončené Losetup LXD Storage Pool (hddpool).

Z výstupu sa môžeme uistiť, že stav služby je active, aj keď sa spustenie nášho skriptu z jednej príkazu ukončilo, umožnila nám to voľba RemainAfterExit=true.

Bezpečnosť. Privilégia kontajnerov ^

Keďže všetky procesy kontajnera sa skutočne vykonávajú v izolácii v hostiteľskom systéme s použitím jeho jadra, LXD ponúka ďalšiu ochranu prístupu procesov kontajnera k hostiteľskej sústave ponúkaním privilégií procesov, kde:

• Privilegované kontajnery sú kontajnery, kde procesy s UID a GID zodpovedajú rovnakému vlastníkovi ako v hostiteľskom systéme. Napríklad proces spustený v kontajneri s UID rovný 0 má všetky rovnaké prístupové práva ako proces hostiteľského systému s UID rovný 0. Inými slovami, používateľ root v kontajneri má všetky práva nielen v kontajneri, ale aj v hostiteľskom systéme, ak sa mu podarí uniknúť z izolovaného priestoru kontajnera.

• Nepretržované kontajnery sú kontajnery, kde procesy patria vlastníkovi UID a GID s číslom od 0 do 65535, ale pre hostiteľský systém je vlastník maskovaný pomocou pridanej bity SubUID a SubGID. Napríklad používateľ s UID=0 v kontajneri bude zviditeľnený v hostiteľskom systéme ako SubUID + UID. To chráni hostiteľský systém, pretože akýkoľvek proces v kontajneri unikne zo svojho izolovaného priestoru, môže komunikovať s hostiteľským systémom iba ako proces s neznámym, veľmi vysokým UID/GID.

Predvolene majú novo vytvorené kontajnery status nepriviligovaných, a preto musíme určiť SubUID a SubGID.

Vytvoríme dva konfiguračné súbory, v ktorých nastavíme masku pre SubUID a SubGID:

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

Na aplikovanie zmien musí byť služba LXD reštartovaná:

sudo systemctl restart lxd

Vytvorenie virtuálneho prepínača siete ^

Keďže sme predtým inicializovali sieť pomocou sprievodcu inicializáciou odpovedaním na niekoľko otázok. a vytvorili sme sieťové zariadenie lxdbr0, v tejto sekcii sa len oboznámime so sieťou v LXD a s tým, ako vytvoriť virtuálny prepínač (sieťový most, bridge) pomocou príkazu klienta.

Nasledujúca schéma ukazuje, ako prepínač (sieťový most, bridge) spája hostiteľa a kontajnery do siete:

Kontajnery môžu vzájomne komunikovať cez sieť s inými kontajnermi alebo hostiteľom, na ktorom sú tieto kontajnery spravované. Na to je potrebné prepojiť virtuálne sieťové karty kontajnerov s virtuálnym prepínačom. Na začiatku vytvoríme prepínač a sieťové rozhrania kontajnera budú prepojené v nasledujúcich kapitolách, po vytvorení samotného kontajnera.

Nasledujúci príkaz vytvorí prepínač s podsúborom 10.0.5.0/24 a IPv4 adresou 10.0.5.1/24, a tiež zapne ipv4.nat aby kontajnery mohli získať internet prostredníctvom hostiteľa pomocou služby NAT:

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

Kontrolujeme zoznam sieťových zariadení dostupných v LXD:

lxc network list

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

Taktiež môžete skontrolovať vytvorenie sieťového zariadenia pomocou štandardného nástroja Linuxovej distribúcie — ip link alebo ip addr:

ip addr

1: lo:  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:  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:  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:  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

Profil konfigurácie ^

Každý kontajner v LXD má svoju vlastnú konfiguráciu a môže ju rozširovať pomocou globálne deklarovaných konfigurácií, ktoré sa nazývajú profil konfigurácie. Použitie profilov konfigurácie na kontajner má kaskádový model, nasledujúci príklad to demonštruje:

V tomto príklade sú v systéme LXD vytvorené tri profily: default, hddpool a hostfs. Všetky tri profily sú aplikované na kontajner, ktorý má lokálnu konfiguráciu (šedá zóna). Profil default má zariadenie root ktoré má parameter pool rovný ssdpool, ale vďaka kaskádovému modelu aplikácie konfigurácie môžeme aplikovať na kontajner profil hddpool ktoré má parameter pool prekrýva tento istý parameter z profilu default a kontajner dostane konfiguráciu zariadenia root s parametrom pool rovný hddpool, a profil hostfs jednoducho pridáva nové zariadenie do kontajnera.

Aby ste videli zoznam dostupných profilov konfigurácie, slúži nasledujúca príkaz:

lxc profile list

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

Úplný zoznam dostupných príkazov na prácu s profilom môžete získať pridaním kľúča --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

Úprava profilu ^

Profil konfigurácie predvolene default nemá konfiguráciu sieťovej karty pre kontajner a všetky novovytvorené kontajnery nemajú sieť, pre nich je potrebné vytvárať lokálne (vyhradené) zariadenia siete samostatným príkazom, ale môžeme vytvoriť v profile konfigurácie globálne sieťové zariadenie, ktoré bude zdieľané medzi všetkými kontajnermi používajúcimi tento profil. Takže, hneď po príkaze vytvorenia nového kontajnera budú mať sieť s prístupom do siete. Pri tom, nie sú obmedzenia, vždy môžeme neskôr vytvoriť lokálne sieťové zariadenie, ak to bude potrebné.

Nasledujúci príkaz pridá do profilu konfigurácie zariadenie eth0 typu nic pripojené k sieti lxdbr0:

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

Je dôležité poznamenať, že keďže sme skutočne pridali zariadenie do profilu konfigurácie, ak by sme v zariadení uviedli statickú IP adresu, všetky kontajnery, ktoré by tento profil použili, by zdieľali rovnakú IP adresu. Ak je potrebné vytvoriť kontajner so statickou IP adresou vyhradenou pre ten kontajner, je potrebné vytvoriť konfiguráciu sieťového zariadenia na úrovni kontajnera (lokálna konfigurácia) s parametrom IP adresy, a nie na úrovni profilu.

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

V tomto profile môžeme vidieť, že pre všetky novo vytvorené kontajnery budú vytvorené dva zariadenia (devices):

• eth0 — Zariadenie typu nic pripojené k prepínaču (sieťovému mostu) lxdbr0
• root — Zariadenie typu disk ktoré využíva úložný pool ssdpool

Vytvorenie nových profilov ^

Na použitie predtým vytvorených Storage Pool kontajnerov, vytvoríme profil konfigurácie ssdroot v ktorom pridáme zariadenie typu disk s bodom pripojenia / (root) používajúce predtým vytvorené Storage Pool — ssdpool:

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

Podobne, vytvárame zariadenie typu disk, ale v tomto prípade používa Storage Pool — hddpool:

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

Kontrolujeme profily konfigurácie:

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

Repúbnik obrazov ^

Kontajnery sa vytvárajú z obrazov, ktoré sú špeciálne zostavené distribúcie, nemajúce jadro Linux. Preto, pred spustením kontajnera, musí byť rozvinutý z tohto obrazu. Zdrojem obrazov je lokálny repozitár, do ktorého sa obrazy nahrávajú z externých repozitárov.

Vzdialené repozitáre obrazov ^

Predvolený LXD je nastavený na získavanie obrazov z troch vzdialených zdrojov:

• ubuntu: (pre stabilné obrazové verzie Ubuntu)
• ubuntu-daily: (pre dennodenné obrazové verzie Ubuntu)
• images: (pre množstvo iných distribúcií)

lxc remote list

+-----------------+------------------------------------------+--------+--------+
|      NÁZOV      |                   URL                    | VERJNÝ | STATICKÝ |
+-----------------+------------------------------------------+--------+--------+
| obrazy          | https://images.linuxcontainers.org       | ÁNO    | NIE     |
+-----------------+------------------------------------------+--------+--------+
| miestny (predvolený) | unix://                                  | NIE    | ÁNO     |
+-----------------+------------------------------------------+--------+--------+
| ubuntu          | https://cloud-images.ubuntu.com/releases | ÁNO    | ÁNO     |
+-----------------+------------------------------------------+--------+--------+
| ubuntu-daily    | https://cloud-images.ubuntu.com/daily    | ÁNO    | ÁNO     |
+-----------------+------------------------------------------+--------+--------+

Napríklad, repozitár ubuntu: má nasledujúce obrazy:

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

+----------------------------------------------+--------------+----------+------------+
|                   POPIS                    | ARCHITEKTÚRA |   VEĽKOSŤ  |   TYP      |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150728)  | x86_64       | 153.72MB | KONTAJNER  |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150819)  | x86_64       | 152.91MB | KONTAJNER  |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150906)  | x86_64       | 154.69MB | KONTAJNER  |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150930)  | x86_64       | 153.86MB | KONTAJNER  |
+----------------------------------------------+--------------+----------+------------+

Na zobrazenie obmedzeného počtu stĺpcov sme použili možnosť -c s parametrami dasut, a taktiež sme obmedzili dĺžku zoznamu príkazom head.

Na zobrazenie zoznamu obrazov je k dispozícii filtrovanie. Nasledujúci príkaz zobrazí zoznam všetkých dostupných architektúr distribúcie AlpineLinux:

lxc image -c ldast list images:alpine/3.11

+------------------------------+--------------------------------------+--------------+
|            ALIAS             |             POPIS                    | ARCHITEKTÚRA |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11 (3 viac)         | Alpine 3.11 amd64 (20200220_13:00)   | x86_64       |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/arm64 (1 viac)   | Alpine 3.11 arm64 (20200220_13:00)   | aarch64      |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/armhf (1 viac)   | Alpine 3.11 armhf (20200220_13:00)   | armv7l       |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/i386 (1 viac)    | Alpine 3.11 i386 (20200220_13:01)    | i686         |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/ppc64el (1 viac) | Alpine 3.11 ppc64el (20200220_13:00) | ppc64le      |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/s390x (1 viac)   | Alpine 3.11 s390x (20200220_13:00)   | s390x        |
+------------------------------+--------------------------------------+--------------+

Lokálny repozitár obrazov ^

Na začiatok využívania kontajnera je potrebné pridať obraz z globálneho repozitára do lokálneho local:. Teraz je lokálny repozitár prázdny, čo nám ukáže príkaz lxc image list. Ak nie je v metóde list špecifikovaný repozitár, bude sa použivať lokálny repozitár ako predvolený — local:

lxc image list local:

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

Správa obrazov v repozitári sa vykonáva nasledujúcimi metódami:

Tím
Popis

lxc image alias
Spravovať aliasy obrazov

lxc image copy
Kopírovať obrazy medzi servermi

lxc image vymazať
Odstrániť obrazy

lxc image edit
Upraviť vlastnosti obrazu

lxc image export
Exportovať a stiahnuť obrazy

lxc image import
Importovať obrazy do úložiska obrazov

lxc image info
Zobraziť užitočné informácie o obrazoch

lxc image list
Zoznam obrazov

lxc image refresh
Obnoviť obrazy

lxc image zobraziť
Zobraziť vlastnosti obrazu

Kopírujeme obraz do lokálneho repozitára z globálneho images::

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

Obraz bol úspešne skopírovaný!

Zobrazíme zoznam všetkých obrazov, ktoré sú teraz dostupné v lokálnom repozitári local::

lxc image -c lfdatsu list local:

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

Konfigurácia LXD ^

Okrem interaktívneho režimu LXD podporuje aj neinteraktívny režim nastavenia konfigurácie, čo znamená, že konfigurácia sa zadáva vo forme YAML súboru, špeciálneho formátu, ktorý umožňuje nastaviť celú konfiguráciu naraz, bez vykonávania množstva interaktívnych príkazov, ktoré boli uvedené vyššie v tomto článku, vrátane konfigurácie siete, vytvárania profilov konfigurácie a podobne. Túto oblasť tu nebudeme podrobne preberať, môžete sa s ňou samostatne oboznámiť. v dokumentácii.

Nasledujúci interaktívny príkaz lxc config ktorý zvážime, umožňuje nastavovať konfiguráciu. Napríklad, aby sa stiahnuté obrazy do lokálneho repozitára automaticky neaktualizovali z globálnych repozitárov, môžeme túto funkcionalitu zapnúť nasledujúcim príkazom:

lxc config set images.auto_update_cached=false

Vytvorenie a správa kontajnera ^

Na vytvorenie kontajnera slúži príkaz lxc init ktorému sa odovzdajú hodnoty repozitár:obraz a následne požadovaný identifikátor pre kontajner. Repozitár môže byť špecifikovaný ako lokálny local: Tak aj každý globálny. Ak repozitár nie je uvedený, predpokladá sa, že na hľadanie obrazu sa používa miestny repozitár. Ak je obraz uvedený z globálneho repozitára, najskôr sa obraz načíta do miestneho repozitára a potom sa použije na vytvorenie kontajnera.

Vykonáme nasledujúci príkaz na vytvorenie nášho prvého kontajnera:

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

Podrobne rozoberieme kľúče príkazu, ktoré tu používame:

• alpine3 — Uvádza pseudonym (alias) pre obraz, ktorý bol predtým načítaný do miestneho repozitára. Ak by alias nebol vytvorený pre tento obraz, je možné vždy odkázať na obraz podľa jeho Fingerprint , ktorý sa zobrazuje v tabuľke.
• alp — Určuje identifikátor pre kontajner
• --storage — Tento kľúč určuje, v akom Storage Pool bude kontajner vytvorený
• --profile — Tieto kľúče kaskádovo aplikujú na kontajner konfiguráciu z predtým vytvorených profilov konfigurácie

Spustíme kontajner, ktorý začne spúšťať init systém distribúcie:

lxc start alp

Taktiež je možné využiť príkaz lxc launch , ktorý umožňuje skombinovať príkazy lxc init a lxc start do jednej operácie.

Overíme stav kontajnera:

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

Skontrolujeme konfiguráciu kontajnera:

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

V sekcii profily môžeme sa uistiť, že tento kontajner používa dva profily konfigurácie — default a hddroot. V sekcii zariadenia môžeme odhaliť len jedno zariadenie, keďže sieťové zariadenie bolo vytvorené na úrovni profilu default. Aby ste videli všetky zariadenia používané kontajnerom, je potrebné pridať kľúč --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: ""

Nastavenie statickej IP adresy ^

Ak sa pokúsime nastaviť IP adresu pre sieťové zariadenie eth0 príkazom lxc config device set alp určenej na konfiguráciu kontajnera, dostaneme chybu, ktorá oznámi, že zariadenie neexistuje, pretože zariadenie eth0 používané kontajnerom patrí profilu default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Samozrejme, môžeme nastaviť statickú IP adresu pre eth0 zariadenie v profile, ale bude to jediné pre všetky kontajnery, ktoré tento profil budú používať. Preto pridáme vyhradené zariadenie pre kontajner:

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

Potom bude potrebné reštartovať kontajner:

lxc restart alp

Ak sa teraz pozrieme na konfiguráciu kontajnera, už nemusíme používať možnosť --expanded aby sme videli sieťové zariadenie eth0, pretože sme ho vytvorili na úrovni kontajnera a to prekrýva to isté zariadenie z profilu default:

lxc config show alp

architektúra: x86_64
config:
  image.architektúra: amd64
  image.popis: Alpine 3.11 amd64 (20200326_13:39)
  image.os: Alpine
  image.uvoľnenie: "3.11"
  image.séria: "20200326_13:39"
  image.typ: squashfs
  volatile.základný_obraz: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
  volatile.eth0.meno_hosta: veth2a1dc59d
  volatile.eth0.hwaddr: 00:16:3e:0e:e2:71
  volatile.idmap.základ: "0"
  volatile.idmap.súčasný: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.idmap.následujúci: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.posledný_stav.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
  volatile.posledný_stav.sila: RUNNING
devices:
  eth0:
    ipv4.adresa: 10.0.5.5
    meno: eth0
    nictype: bridged
    rodič: lxdbr0
    typ: nic
  root:
    cesta: \/
    pool: hddpool
    typ: disk
ephemeral: false
profil:
- default
- hddroot
stavový: false
deskripcia: ""

Odstránenie kontajnera ^

Na odstránenie kontajnera slúži príkaz lxc delete, ale predtým ako odstránite kontajner, musí byť zastavený pomocou príkazu lxc stop:

lxc stop alp

lxc list

+------+---------+-------------------+------+-----------+-----------+
| NÁZOV |  STAV   |       IPV4        | IPV6 |   TYP     | SNAPSHOTS |
+------+---------+-------------------+------+-----------+-----------+
| alp  | STOPNUTÝ | 10.0.5.10 (eth0)  |      | KONTAINER  | 0         |
+------+---------+-------------------+------+-----------+-----------+

Akonáhle sme sa uistili, že stav kontajnera je STOPPED, môže byť odstránený z Storage Pool:

lxc delete alp

Prístup k kontajneru ^

Na vykonávanie príkazov v kontajneri, priamo, mimo sieťových pripojení, slúži príkaz lxc exec ktorý vykonáva príkazy v kontajneri bez spustenia systémového shellu. Ak chcete vykonať príkaz v shelli so špeciálnymi vzormi, ako sú premenné, presmerovania súborov (pipe) atď., musíte jasne spustiť shell a odovzdať príkaz ako kľúč, napríklad:

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

V príkaze bol použitý špeciálny znak escape pre špeciálny znak $ aby premenná $HOME nebola interpretovaná na hostiteľskom zariadení, ale bola interpretovaná iba vnútri kontajnera.

Taktiež je možné spustiť interaktívny režim shellu a po ukončení relácie stlačiť klávesovú skratku CTRL+D:

lxc exec alp -- \/bin\/sh

Správa zdrojov kontajnera ^

V LXD môžete spravovať zdroje kontajnera pomocou špeciálneho súboru konfigurácie. Úplný zoznam konfiguračných parametrov kontajnera nájdete v dokumentácii.

Obmedzenie zdrojov RAM (RAM) ^

Parameter limits.memory obmedzuje objem RAM dostupný pre kontajner. Ako hodnotu sa uvádza číslo a jeden z dostupných prípon.

Nastavíme kontajneru obmedzenie na objem RAM rovný 256 MB:

lxc config set alp limits.memory 256MB

Existujú aj ďalšie parametre na obmedzenie pamäte:

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

Tím lxc config show umožňuje zobraziť celú konfiguráciu kontajnera, vrátane aplikovaného obmedzenia zdrojov, ktoré bolo nastavené:

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

Obmedzenie zdrojov CPU (CPU) ^

Na obmedzenie zdrojov CPU existuje niekoľko typov obmedzení:

• limit.cpu — priraďuje kontajner k jednému alebo viacerým jadrám CPU
• limits.cpu.allowance — spravuje buď kvóty plánovača CFS, keď uplynulo obmedzenie času, alebo univerzálny mechanizmus zdieľania zdrojov CPU, keď uplynula percentuálna hodnota
• limits.cpu.priority — priorita plánovača, keď je pre viaceré inštancie, ktoré zdieľajú procesory, priradené rovnaké percento procesorov

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

Obmedzenie diskového priestoru ^

Okrem obmedzení, ako sú limits.read, limits.write môžeme tiež obmedziť objem diskového priestoru, ktorý kontajner spotrebuje (funguje iba s ZFS alebo BTRFS):

lxc config device set alp root size=2GB

Po nastavení, v parametri devices.root.size sa môžeme uistiť o nastavenom obmedzení:

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

Na zobrazenie používaných kvót na disk môžeme získať z príkazu 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

Napriek tomu, že sme nastavili obmedzenie pre koreňové zariadenie kontajnera na 2GB, systémové nástroje ako df toto obmedzenie neuvidia. Pre toto vykonáme malý test a zistíme, ako to funguje.

Vytvoríme 2 nové identické kontajnery na rovnakom Storage Pool (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) |      | KONTAJNER | 0         |
+------+---------+------------------+------+-----------+-----------+
| alp2 | RUNNING | 10.0.5.30 (eth0) |      | KONTAJNER | 0         |
+------+---------+------------------+------+-----------+-----------+

V jednom z kontajnerov vytvoríme súbor veľkosti 1GB:

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

Uistíme sa, že súbor bol vytvorený:

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

Ak sa pozrieme do druhého kontajnera a overíme existenciu súboru na tom istom mieste, ten súbor tam nebude, čo je očakávané, pretože kontajnery sa vytvárajú vo svojich vlastných Storage Volume v rovnakom Storage Pool:

lxc exec alp2 -- ls -lh
total 0

Ale porovnajme hodnoty, ktoré vykazuje df na jednom a druhom kontajneri:

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

Zariadenie /dev/loop1 pripojené ako koreňový oddiel je Storage Pool ktorý tieto kontajnery používajú, preto si jeho objem rozdelia rovnako.

Štatistika spotreby zdrojov ^

Štatistiku spotreby zdrojov pre kontajner môžete získať pomocou príkazu:

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

Práca so snímkami ^

V LXD existuje možnosť vytvárania snapshotov a obnovy zo snapshotov stavu kontajnera.

Aby ste vytvorili snapshot, vykonajte nasledujúci príkaz:

lxc snapshot alp snapshot1

Príkaz lxc snapshot nemá žiadnu možnosť list, preto na zobrazenie zoznamu snapshotov musíte využiť príkaz, ktorý zobrazí celkové informácie o kontajneri:

lxc info alp
...
...
Snapshots:
  snapshot1 (pozané 2020/04/08 18:18 UTC) (bezstavový)

Obnoviť kontajner zo snapshotu je možné príkazom lxc restore s uvedením kontajnera, pre ktorý sa uskutoční obnova, a aliasu snapshotu:

lxc restore alp snapshot1

Ďalší príkaz slúži na odstránenie snapshotu. Upozorňujeme, že syntax príkazu sa nezhoduje so všetkými ostatnými; je potrebné uviesť priamu lomku po názve kontajnera. Ak sa lomka vynechá, príkaz na odstránenie snapshotu bude interpretovaný ako príkaz na odstránenie kontajnera!

lxc delete alp/snapshot1

Vo vyššie uvedenom príklade sme preskúmali takzvané bezstavové snapshoty. V LXD existuje aj iný typ snapshotov — stavové, v ktorých sa uchováva aktuálny stav všetkých procesov v kontajneri. So stavovými snapshotmi sú spojené viaceré zaujímavé a užitočné funkcie.

Čo ešte? ^

• Pre vývojárov v Pythone je k dispozícii modul PyLXD ktorý poskytuje API k LXD

AKTUALIZÁCIA 10.04.2020 15:00: Pridal som navigáciu

Zdroj: habr.com