ProHoster > Blog > podávání > Základní funkce LXD, kontejnerového systému v Linux

Základní funkce LXD, kontejnerového systému v Linux

Základní funkce LXD, kontejnerového systému v Linux

Lxd je správce kontejnerů systému příští generace, jak se říká zdrojNabízí uživatelské rozhraní podobné virtuálním strojům, ale místo toho používá kontejnery. Linux.

Jádro LXD je privilegovaný démon (služba běžící s právy root), který poskytuje REST API prostřednictvím lokálního unixového soketu a také prostřednictvím sítě, pokud je nainstalována příslušná konfigurace. Klienti, jako je nástroj příkazového řádku dodávaný s LXD, zadávají požadavky prostřednictvím tohoto REST API. To znamená, že ať už přistupujete k místnímu hostiteli nebo ke vzdálenému hostiteli, vše funguje stejně.

V tomto článku se nebudeme podrobně zabývat koncepty LXD ani všemi dostupnými funkcemi popsanými v dokumentaci, včetně nedávné implementace podpory virtuálních strojů QEMU spolu s kontejnery v nejnovějších verzích LXD. Místo toho se zaměříme na základy správy kontejnerů – nastavení úložných fondů a sítí, spuštění kontejneru, použití limitů zdrojů a používání snapshotů – abyste získali základní znalosti o LXD a mohli kontejnery používat ve svém prostředí. Linux.

Kompletní informace naleznete v oficiálním zdroji:

Navigace

Instalace LXD ^

Instalace LXD v distribucích Ubuntu ^

V distribuci Ubuntu Balíček 19.10 lxd má zapnuté vysílání snap balíček:

apt search lxd

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

To znamená, že budou nainstalovány dva balíčky najednou, jeden jako systémový balíček a druhý jako snap balíček. Instalace dvou balíčků do systému může způsobit problém, kdy systémový balíček může osiřít, pokud je balíček snap odstraněn správcem balíčků snap.

Najít balíček lxd v úložišti snap můžete použít následující příkaz:

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

Spuštěním příkazu list můžete se ujistit, že balíček lxd ještě nenainstalované:

snap list

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

Navzdory skutečnosti, že LXD je balíček snap, musí být nainstalován prostřednictvím systémového balíčku lxd, která v systému vytvoří odpovídající skupinu, potřebné utility v /usr/bin atd.

sudo apt update
sudo apt install lxd

Ujistěte se, že je balíček nainstalován jako balíček snap:

snap list

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

Instalace LXD na distribuce Archu Linux ^

Chcete-li nainstalovat balíček LXD do systému, musíte spustit následující příkazy, první aktualizuje seznam balíčků v systému dostupných v úložišti, druhý přímo nainstaluje balíček:

sudo pacman -Syyu && sudo pacman -S lxd

Po instalaci balíčku, aby mohl LXD spravovat běžný uživatel, musí být přidán do systémové skupiny lxd:

sudo usermod -a -G lxd user1

Přesvědčte se, že uživatel user1 přidáno do skupiny lxd:

id -Gn user1

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

Pokud skupina lxd není v seznamu viditelný, pak musíte znovu aktivovat uživatelskou relaci. Chcete-li to provést, musíte se odhlásit a přihlásit pod stejným uživatelem.

Aktivovat v systemd načtení služby LXD při startu systému:

sudo systemctl enable lxd

Začněme službu:

sudo systemctl start lxd

Kontrola stavu služby:

sudo systemctl status lxd

Úložiště LXD (úložiště) ^

Než začne inicializace, musíme pochopit, jak je úložiště v LXD logicky uspořádáno.

Úložný prostor (Skladování) sestává z jednoho nebo více Skladovací bazén který používá jeden z podporovaných souborových systémů jako ZFS, BTRFS, LVM nebo běžné adresáře. Každý Skladovací bazén je rozdělena do svazků (Objem úložiště), které obsahují obrázky, kontejnery nebo data pro jiné účely.

  • Obrázky — jedná se o speciálně kompilované distribuce bez jádra Linux a přístupné z externích zdrojů
  • kontejnery - to jsou nasazené distribuce z obrazů, připravené k použití
  • Snímky - to jsou snímky stavu kontejnerů, ke kterým se můžete vrátit

Základní funkce LXD, kontejnerového systému v Linux

Chcete-li spravovat úložiště v LXD, použijte příkaz lxc storage certifikát, který můžete získat zadáním klíče - lxc storage --help

Následující příkaz zobrazí seznam všech Skladovací bazén v úložišti LXD:

lxc storage list

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

Chcete-li zobrazit seznam všech Objem úložiště ve vybraném Skladovací bazén slouží týmu 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       |
+-----------+----------------------------------+-------------+---------+

Také, pokud pro Skladovací bazén Při vytváření byl vybrán souborový systém BTRFS a poté získat seznam Objem úložiště nebo subvolumy v interpretaci BTRFS můžete použít sadu nástrojů tohoto souborového systému:

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

Inicializace LXD ^

Před vytvořením a použitím kontejnerů musíte provést obecnou inicializaci LXD, která vytvoří a nakonfiguruje síť a úložiště. To lze provést ručně pomocí standardních klientských příkazů, které jsou dostupné v seznamu voláním příkazu lxc --help nebo pomocí inicializačního průvodce lxd init zodpovězení několika otázek.

Výběr systému souborů pro oblast úložiště ^

Během inicializace se LXD zeptá na několik otázek, včetně určení typu systému souborů pro výchozí nastavení Skladovací bazén. Ve výchozím nastavení je pro něj vybrán souborový systém BTRFS. Po vytvoření nebude možné přejít na jiný FS. Pro výběr FS se doporučuje srovnávací tabulka funkcí:

vlastnost
Adresář
Btrfs
LVM
ZFS
CEPH

Optimalizované ukládání obrázků
Ne
ano
ano
ano
ano

Optimalizované vytváření instancí
Ne
ano
ano
ano
ano

Optimalizované vytváření snímků
Ne
ano
ano
ano
ano

Optimalizovaný přenos obrazu
Ne
ano
Ne
ano
ano

Optimalizovaný přenos instancí
Ne
ano
Ne
ano
ano

Kopírovat na zápis
Ne
ano
ano
ano
ano

Na základě bloku
Ne
Ne
ano
Ne
ano

Okamžité klonování
Ne
ano
ano
ano
ano

Ovladač úložiště použitelný uvnitř kontejneru
ano
ano
Ne
Ne
Ne

Obnovit ze starších snímků (ne nejnovějších)
ano
ano
ano
Ne
ano

Kvóty úložiště
Ano(*)
ano
ano
ano
Ne

Inicializace sítě a fondu úložiště pomocí průvodce ^

Další příkaz, na který se podíváme, navrhuje nastavení hlavních součástí LXD pomocí odpovědí na jednoduché otázky pomocí inicializačního průvodce.

Spustit příkaz lxc init a zadejte odpovědi na otázky za dvojtečkou, jak je uvedeno v příkladu níže, nebo je změňte podle svých podmínek:

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

Vytvoření dalšího fondu úložiště ^

V předchozím kroku jsme vytvořili Skladovací bazén který dostal jméno ssdpool a jehož soubor je umístěn v mém systému na adrese /var/lib/lxd/disks/ssdpool.img. Tato adresa systému souborů odpovídá fyzické jednotce SSD v mém počítači.

Následující akce, rozšířit porozumění roli, kterou hraje Skladovací bazén v úložišti vytvoříme druhý Skladovací bazén který bude fyzicky umístěn na jiném typu disku, HDD. Problém je v tom, že LXD vám neumožňuje tvořit Skladovací bazén mimo adresu /var/lib/lxd/disks/ a ani symbolické odkazy nebudou fungovat, viz odpověď vývojáře. Toto omezení můžeme při inicializaci/formátování obejít Skladovací bazén zadáním hodnoty jako blokového zařízení namísto cesty k souboru zpětné smyčky zadáním této hodnoty v klíči source.

Takže před tvorbou Skladovací bazén musíte definovat soubor zpětné smyčky nebo existující oddíl v systému souborů, který bude používat. K tomu vytvoříme a použijeme soubor, jehož velikost omezíme na 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

Pojďme připojit soubor zpětné smyčky k bezplatnému zařízení zpětné smyčky:

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

/dev/loop1

Díky klíči --show provedení příkazu vrátí na obrazovku název zařízení, ke kterému je připojen náš soubor zpětné smyčky. V případě potřeby můžeme zobrazit seznam všech vytížených zařízení tohoto typu, abychom se ujistili, že naše akce jsou správné:

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

Ze seznamu zjistíte, že zařízení má /dev/loop1 součástí souboru zpětné smyčky /mnt/work/lxd/hddpool.imga v zařízení /dev/loop0 součástí souboru zpětné smyčky /var/lib/lxd/disks/ssdpool.img což odpovídá výchozímu nastavení Skladovací bazén.

Následující příkaz vytvoří nový Skladovací bazén v LXD na základě souboru zpětné smyčky, který jsme právě připravili. LXD naformátuje soubor zpětné smyčky /mnt/work/lxd/hddpool.img v zařízení /dev/loop1 pro souborový systém BTRFS:

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

Ukážeme si seznam všech Skladovací bazén na obrazovku:

lxc storage list

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

Zvětšení velikosti úložiště ^

Po vytvoření Skladovací bazén, v případě potřeby jej lze rozšířit. Pro Skladovací bazén na základě systému souborů BTRFS spusťte následující pří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žení souboru zpětné smyčky do slotu zařízení zpětné smyčky ^

Máme jeden malý problém, při restartu hostitelského systému, soubor /mnt/work/lxd/hddpool.img "vyletí" ze zařízení /dev/loop1 a služba LXD se při načítání zhroutí, protože ji v tomto zařízení neuvidí. Chcete-li tento problém vyřešit, musíte vytvořit systémovou službu, která tento soubor vloží do zařízení /dev/loop1 při spuštění hostitelského systému.

Pojďme tvořit jednotka typ souboru servis в /etc/systemd/system/ pro inicializační systém 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

Aktivujte službu:

sudo systemctl enable lxd-hddpool

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

Po restartu hostitelského systému zkontrolujeme stav služby:

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

Z výstupu můžeme ověřit, že je stav služby aktivní, přestože bylo vykonání našeho skriptu z jednoho příkazu dokončeno, volba nám to umožnila RemainAfterExit=true.

Bezpečnost. Kontejnerová privilegia ^

Vzhledem k tomu, že všechny procesy kontejneru ve skutečnosti běží izolovaně na hostitelském systému pomocí jeho jádra, pro další ochranu přístupu procesů kontejneru k hostitelskému systému nabízí LXD procesní oprávnění, kde:

  • Privilegované kontejnery - jedná se o kontejnery, ve kterých procesy s UID a GID odpovídají stejnému vlastníkovi jako na hostitelském systému. Například proces běžící v kontejneru s UID 0 má všechna stejná přístupová práva jako proces na hostitelském systému s UID 0. Jinými slovy, uživatel root v kontejneru má všechna práva nejen v kontejneru, ale také na hostitelském systému, pokud může jít mimo izolovaný jmenný prostor kontejneru.

  • Neprivilegované kontejnery - jedná se o kontejnery, ve kterých procesy patří vlastníkovi UID a GID s číslem od 0 do 65535, ale pro hostitelský systém je vlastník maskován pomocí přidaných bitů SubUID a SubGID. Například uživatel s UID=0 v kontejneru bude v hostitelském systému viděn jako SubUID + UID. To chrání hostitelský systém, protože pokud je jakýkoli proces v kontejneru schopen uniknout ze svého izolovaného jmenného prostoru, může komunikovat s hostitelským systémem pouze jako proces s neznámým, velmi vysokým UID/GID.

Ve výchozím nastavení mají nově vytvořené kontejnery status neprivilegovaného, ​​a proto musíme definovat SubUID a SubGID.

Vytvoříme dva konfigurační soubory, ve kterých nastavíme masku pro SubUID a SubGID, v tomto pořadí:

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

Pro použití změn je nutné restartovat službu LXD:

sudo systemctl restart lxd

Vytvoření virtuálního síťového přepínače ^

Protože jsme dříve inicializovali síť pomocí inicializačního průvodce lxd init a vytvořili síťové zařízení lxdbr0, pak se v této části jednoduše seznámíme se síťováním v LXD a jak vytvořit virtuální switch (bridge) pomocí příkazu client.

Následující diagram ukazuje, jak přepínač (most) připojuje hostitele a kontejnery do sítě:

Základní funkce LXD, kontejnerového systému v Linux

Kontejnery mohou komunikovat prostřednictvím sítě s jinými kontejnery nebo hostitelem, na kterém jsou tyto kontejnery obsluhovány. Chcete-li to provést, musíte propojit virtuální síťové karty kontejnerů s virtuálním přepínačem. Nejprve vytvoříme přepínač a síťová rozhraní kontejneru budou propojena v následujících kapitolách, až bude kontejner samotný vytvořen.

Následující příkaz vytvoří přepínač s podsítí 10.0.5.0/24 a IPv4 adresu 10.0.5.1/24, a také zahrnuje ipv4.nat aby kontejnery mohly přistupovat k internetu prostřednictvím hostitele pomocí služby NAT:

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

Kontrola seznamu síťových zařízení dostupných v LXD:

lxc network list

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

Můžete také ověřit, zda bylo síťové zařízení vytvořeno pomocí standardního nástroje. Linux-distribuce — ip link nebo 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

Konfigurační profil ^

Každý kontejner v LXD má svou vlastní konfiguraci a může ji rozšířit o globálně deklarované konfigurace tzv konfigurační profily. Použití konfiguračních profilů na kontejner má kaskádový model, což ukazuje následující příklad:

Základní funkce LXD, kontejnerového systému v Linux

V tomto příkladu byly v systému LXD vytvořeny tři profily: default, hddpool и hostfs. Všechny tři profily jsou aplikovány na kontejner, který má místní konfiguraci (šedá oblast). Profil default má zařízení root který má parametr pool rovná ssdpool, ale díky aplikačnímu modelu kaskádové konfigurace můžeme na kontejner aplikovat profil hddpool který má parametr pool přepíše stejný parametr z profilu default a kontejner obdrží konfiguraci zařízení root s parametrem pool stejný hddpoola profil hostfs jednoduše přidá nové zařízení do kontejneru.

Chcete-li zobrazit seznam dostupných konfiguračních profilů, použijte následující příkaz:

lxc profile list

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

Kompletní seznam dostupných příkazů pro práci s profilem lze získat přidáním klíče --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 vašeho profilu ^

Výchozí konfigurační profil default nemá konfiguraci síťové karty pro kontejner a všechny nově vytvořené kontejnery nemají síť, pro ně je nutné vytvořit lokální (dedikovaná) síťová zařízení samostatným příkazem, ale v konfiguraci můžeme vytvořit globální síťové zařízení profil, který bude sdílen mezi všemi kontejnery používajícími tento profil. Ihned po příkazu k vytvoření nového kontejneru tak budou mít síť se síťovým přístupem. Zároveň neexistují žádná omezení, v případě potřeby můžeme kdykoli později vytvořit místní síťové zařízení.

Následující příkaz přidá zařízení do konfiguračního profilu eth0 typ nic připojený k síti lxdbr0:

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

Je důležité si uvědomit, že jelikož jsme zařízení skutečně přidali do konfiguračního profilu, pokud jsme v zařízení zadali statickou IP adresu, pak všechny kontejnery, které budou tento profil používat, budou sdílet stejnou IP adresu. Pokud je potřeba vytvořit kontejner se statickou IP adresou přidělenou kontejneru, měli byste vytvořit konfiguraci síťového zařízení na úrovni kontejneru (místní konfigurace) s parametrem IP adresa, a ne na úrovni profilu.

Podívejme se na 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 profilu vidíme, že pro všechny nově vytvořené kontejnery budou vytvořena dvě zařízení:

  • eth0 - Typ zařízení nic připojeno k přepínači (síťový most) lxdbr0
  • root - Typ zařízení disk který využívá skladovací bazén ssdpool

Vytváření nových profilů ^

Chcete-li použít dříve vytvořené Skladovací bazén kontejnery, vytvořte konfigurační profil ssdroot do kterého přidáme zařízení jako disk s montážním bodem / (root) pomocí dříve vytvořeného Skladovací bazén - ssdpool:

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

Podobně vytvoříme zařízení jako disk, ale v tomto případě pomocí Skladovací bazén - hddpool:

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

Kontrola konfiguračních profilů:

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

Úložiště obrázků ^

Kontejnery se vytvářejí z obrazů, což jsou speciálně kompilované distribuce, které nemají jádro. LinuxPřed spuštěním kontejneru je proto nutné jej z tohoto obrazu nasadit. Zdroj obrazu je lokální repozitář, do kterého se obrazy stahují z externích repozitářů.

Vzdálená úložiště obrázků ^

Ve výchozím nastavení je LXD nakonfigurován pro příjem obrázků ze tří vzdálených zdrojů:

  • ubuntu: (pro stabilní Ubuntu snímky)
  • ubuntu-denní: (pro denní Ubuntu snímky)
  • snímky: (pro spoustu dalších distribucí)

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

Například úložiště ubuntu: má následující obrázky:

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

Pro zobrazení omezeného počtu sloupců jsme použili možnost -c s parametry dasut, a také omezil délku seznamu pomocí příkazu head.

K dispozici je filtrování pro zobrazení seznamu obrázků. Následující příkaz zobrazí seznam všech dostupných distribučních architektur VysokohorskýLinux:

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

Místní úložiště obrázků ^

Chcete-li kontejner začít používat, musíte do místního přidat obrázek z globálního úložiště local:. Nyní je místní úložiště prázdné, příkaz se o to postará lxc image list. Pokud metoda list nezadávejte úložiště, ve výchozím nastavení se použije místní úložiště - local:

lxc image list local:

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

Obrázky v úložišti jsou spravovány pomocí následujících metod:

Tým
popis

obrázek lxc přezdívka
Správa aliasů obrázků

obrázek lxc kopie
Kopírování obrázků mezi servery

obrázek lxc vymazat
Mazat obrázky

obrázek lxc editovat
Upravit vlastnosti obrázku

obrázek lxc export
Exportujte a stahujte obrázky

obrázek lxc import
Importujte obrázky do úložiště obrázků

obrázek lxc info
Zobrazit užitečné informace o obrázcích

obrázek lxc lest
Seznam obrázků

obrázek lxc Obnovit
Obnovit obrázky

obrázek lxc show
Zobrazit vlastnosti obrázku

Zkopírujte obrázek do místního úložiště z globálního images::

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

Image copied successfully!

Zobrazme seznam všech obrázků aktuálně dostupných v místním úložišti local::

lxc image -c lfdatsu list local:

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

Konfigurace LXD ^

Kromě interaktivního režimu podporuje LXD také režim instalace neinteraktivní konfigurace, kdy je konfigurace specifikována ve formě souboru YAML, což je speciální formát, který vám umožní nainstalovat celou konfiguraci najednou a obejít provádění z mnoha interaktivních příkazů, které byly popsány výše v tomto článku, včetně konfigurace sítě, vytváření konfiguračních profilů atd. Tuto oblast zde nebudeme pokrývat, můžete se na to podívat sami. v dokumentaci.

Další interaktivní příkaz lxc config na který se podíváme, umožňuje nastavit konfiguraci. Abychom například zajistili, že stažené obrázky do místního úložiště nebudou automaticky aktualizovány z globálních úložišť, můžeme toto chování povolit pomocí následujícího příkazu:

lxc config set images.auto_update_cached=false

Vytvoření a správa kontejneru ^

K vytvoření kontejneru použijte příkaz lxc init kterým se předávají hodnoty репозиторий:образ a poté požadované ID pro kontejner. Úložiště lze zadat jako místní local: stejně jako každý globální. Pokud není úložiště zadáno, pak se k vyhledání obrázku standardně použije místní úložiště. Pokud je obrázek zadán z globálního úložiště, bude obrázek nejprve stažen do místního úložiště a poté použit k vytvoření kontejneru.

Spusťte následující příkaz k vytvoření našeho prvního kontejneru:

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

Podívejme se na příkazové klávesy, které zde používáme:

  • alpine3 — Zadejte alias (alias) pro obrázek, který byl dříve nahrán do místního úložiště. Pokud pro tento obrázek nebyl vytvořen alias, můžete na obrázek vždy odkazovat jeho pomocí otisk prstu který je zobrazen v tabulce.
  • alp — Nastavuje identifikátor pro kontejner
  • --storage — Tato klávesa označuje, ve kterém Skladovací bazén vytvoří se kontejner
  • --profile — Tato kaskáda klíčů aplikuje konfiguraci z dříve vytvořených konfiguračních profilů na kontejner

Spustíme kontejner, který začne spouštět init systém distribuce:

lxc start alp

Můžete také použít příkaz lxc launch což umožňuje kombinovat týmy lxc init и lxc start v jedné operaci.

Kontrola stavu kontejneru:

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

Kontrola konfigurace kontejneru:

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 sekci profiles můžeme se ujistit, že tento kontejner používá dva konfigurační profily − default и hddroot. V sekci devices můžeme detekovat pouze jedno zařízení, protože síťové zařízení bylo vytvořeno na úrovni profilu default. Abyste viděli všechna zařízení používaná kontejnerem, musíte přidat klíč --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: ""

Nastavení statické IP adresy ^

Pokud se pokusíme nastavit IP adresu síťového zařízení eth0 tým lxc config device set alp určené pro konfiguraci kontejneru, pak obdržíme chybu, která bude hlásit, že zařízení neexistuje, protože zařízení eth0 který kontejner používá patří do profilu default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Můžeme samozřejmě nastavit statickou IP adresu eth0 zařízení v profilu, ale bude stejný pro všechny kontejnery, které budou tento profil používat. Proto přidejte zařízení určené pro kontejner:

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

Poté musíte restartovat kontejner:

lxc restart alp

Pokud se nyní podíváme na konfiguraci kontejneru, nemusíme tuto možnost používat --expanded pro zobrazení síťového zařízení eth0, protože jsme jej vytvořili na úrovni kontejneru a kaskádově se přenesl přes stejné zařízení z profilu 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: ""

Odstranění kontejneru ^

Chcete-li odstranit kontejner, použijte příkaz lxc delete, ale před odstraněním kontejneru je třeba jej zastavit pomocí příkazu lxc stop:

lxc stop alp

lxc list

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

Poté, co jsme ověřili, že se stav kontejneru stal ZASTAVIL, lze jej odstranit z Skladovací bazén:

lxc delete alp

Přístup ke kontejneru ^

Chcete-li spouštět příkazy v kontejneru přímo a obejít síťová připojení, použijte příkaz lxc exec který provádí příkazy v kontejneru bez spuštění systémového shellu. Pokud potřebujete provést příkaz v shellu pomocí vzorů shellu, jako jsou proměnné, přesměrování souborů (pipe) atd., musíte explicitně spustit shell a předat příkaz jako klíč, například:

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

Příkaz používal speciální znak escape pro zvláštní charakter $ takže proměnná $HOME nebyl interpretován na hostitelském počítači, ale byl interpretován pouze uvnitř kontejneru.

Je také možné spustit režim interaktivního shellu a poté relaci ukončit spuštěním horké klávesy CTRL+D:

lxc exec alp -- /bin/sh

Správa kontejnerových zdrojů ^

V LXD můžete spravovat prostředky kontejneru pomocí speciální sady konfigurací. Kompletní seznam konfiguračních parametrů kontejneru naleznete v dokumentaci.

Omezení zdrojů RAM ^

Parametr limits.memory omezuje množství paměti RAM dostupné pro kontejner. Hodnota je číslo a jedna z dostupné přípony.

Nastavíme limit RAM kontejneru na 256 MB:

lxc config set alp limits.memory 256MB

Existují také další parametry pro omezení paměti:

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

Tým lxc config show umožňuje zobrazit celou konfiguraci kontejneru, včetně limitu použitého zdroje, který byl 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: ""

Limit prostředků CPU ^

Existuje několik způsobů, jak omezit zdroje CPU. typy omezení:

  • limit.cpu - sváže kontejner s jedním nebo více jádry CPU
  • limits.cpu.allowance - spravuje buď kvóty plánovače CFS, když uplynul časový limit, nebo mechanismus sdílení univerzálního CPU, když uplynulo procento
  • limits.cpu.priority - priorita plánovače, když je více instancím sdílejících sadu procesorů přiřazeno stejné procento procesorů

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

Omezení místa na disku ^

Kromě omezení např limits.read, limits.write můžeme také omezit množství místa na disku spotřebovaného kontejnerem (funguje pouze se ZFS nebo BTRFS):

lxc config device set alp root size=2GB

Po instalaci v parametru devices.root.size Stanovený limit můžeme ověřit:

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

Pro zobrazení použitých diskových kvót můžeme získat z pří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

Navzdory tomu, že jsme nastavili limit pro kořenové zařízení kontejneru na 2GB, systémové utility jako např df toto omezení neuvidí. Za tímto účelem provedeme malý test a zjistíme, jak to funguje.

Vytvořme 2 nové stejné kontejnery ve stejném Skladovací bazén (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         |
+------+---------+------------------+------+-----------+-----------+

Vytvořme 1GB soubor v jednom z kontejnerů:

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

Ujistěte se, že je soubor vytvořen:

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

Pokud se podíváme do druhého kontejneru, zkontrolujeme existenci souboru ve stejném umístění, tento soubor tam nebude, což se očekává, protože kontejnery jsou vytvořeny ve vlastním Objem úložiště ve stejné Skladovací bazén:

lxc exec alp2 -- ls -lh
total 0

Ale pojďme porovnat hodnoty, které produkuje df na jedné a druhé nádobě:

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

Zařízení /dev/loop1 připojený jako kořenový oddíl Skladovací bazén které tyto nádoby využívají, takže jeho objem sdílejí mezi dva.

Statistika spotřeby zdrojů ^

Statistiku spotřeby zdrojů pro kontejner můžete zobrazit pomocí pří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áce se snímky ^

LXD má schopnost vytvářet snímky a obnovovat z nich stav kontejneru.

Chcete-li vytvořit snímek, spusťte následující příkaz:

lxc snapshot alp snapshot1

Tým lxc snapshot není k dispozici žádný klíč list, proto k zobrazení seznamu snímků musíte použít příkaz, který zobrazí obecné informace o kontejneru:

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

Pomocí příkazu můžete obnovit kontejner ze snímku lxc restore zadáním kontejneru, pro který bude obnova provedena, a aliasu snímku:

lxc restore alp snapshot1

Následující příkaz se používá k odstranění snímku. Upozorňujeme, že syntaxe příkazu není podobná všem ostatním; zde musíte zadat lomítko za názvem kontejneru. Pokud je lomítko vynecháno, je příkaz k odstranění snímku interpretován jako příkaz k odstranění kontejneru!

lxc delete alp/snapshot1

Ve výše uvedeném příkladu jsme se podívali na takzvané bezstavové snímky. LXD má další typ snapshotů – stavový, který ukládá aktuální stav všech procesů v kontejneru. Se stavovými snímky je spojena řada zajímavých a užitečných funkcí.

Co jiného? ^

  • Pro vývojáře Pythonu je k dispozici modul PyLXD který poskytuje API LXD

AKTUALIZACE 10.04.2020 15:00: Přidána navigace

Zdroj: www.habr.com

Kupte si spolehlivý hosting pro stránky s DDoS ochranou, VPS VDS servery 🔥 Kupte si spolehlivý webhosting s ochranou DDoS, VPS VDS servery | ProHoster