Lxd este următoarea generație de manager de containere de sistem, așa se spune sursă. Oferă o interfață de utilizator similară cu mașinile virtuale, dar folosește în schimb containere Linux.

Miez LXD este un daemon privilegiat (un serviciu care rulează cu drepturi root) care oferă un API REST printr-un socket Unix local, precum și prin intermediul rețelei dacă este instalată configurația corespunzătoare. Clienții, cum ar fi instrumentul de linie de comandă furnizat cu LXD, fac cereri prin acest API REST. Aceasta înseamnă că, indiferent dacă accesați o gazdă locală sau o gazdă la distanță, totul funcționează la fel.

În acest articol nu ne vom opri în detaliu asupra conceptelor de LXD, nu vom lua în considerare toate capabilitățile disponibile subliniate în documentație, inclusiv implementarea recentă în cele mai recente versiuni ale LXD a suportului pentru mașinile virtuale QEMU în paralel cu containerele. În schimb, vom învăța doar elementele de bază ale managementului containerelor - configurarea pool-urilor de stocare, crearea de rețele, rularea unui container, aplicarea limitelor de resurse și cum să folosiți instantanee, astfel încât să puteți obține o înțelegere de bază a LXD și să utilizați containere pe Linux.

Pentru informații complete, vă rugăm să consultați sursa oficială:

• Site-ul dezvoltatorului
• Documentație
• for

Navigare

• Instalare LXD
  • Instalarea LXD pe distribuțiile Ubuntu
  • Instalarea LXD pe distribuțiile Arch Linux
• Stocare LXD (depozitare)
• Se inițializează LXD
  • Selectarea unui sistem de fișiere pentru Pool-ul de stocare
  • Inițializarea rețelei și a pool-ului de stocare folosind vrăjitorul
  • Crearea unui pool de stocare suplimentar
    • Creșterea dimensiunii pool-ului de stocare
    • Inserarea automată a unui fișier loopback într-un slot pentru dispozitivul loopback
  • Siguranță. Privilegii container
  • Crearea unui comutator de rețea virtuală
  • Profil de configurare
    • Editarea profilului dvs
    • Crearea de noi profiluri
  • Depozitul de imagini
    • Arhivele de imagini de la distanță
    • Depozitul local de imagini
  • Configurație LXD
• Crearea și gestionarea unui container
  • Setarea unei adrese IP statice
  • Scoaterea unui recipient
  • Acces container
  • Managementul resurselor containerelor
    • Limitarea resurselor RAM
    • Limita resurselor CPU
    • Limitarea spațiului pe disc
    • Statistica consumului de resurse
  • Lucrul cu instantanee

Instalare LXD ^

Instalarea LXD pe distribuțiile Ubuntu ^

În pachetul de distribuție Ubuntu 19.10 lxd are o emisiune pe pachet snap:

apt search lxd

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

Aceasta înseamnă că două pachete vor fi instalate simultan, unul ca pachet de sistem și celălalt ca pachet rapid. Instalarea a două pachete pe un sistem poate crea o problemă în care pachetul de sistem poate deveni orfan dacă pachetul snap este eliminat de managerul de pachete snap.

Găsiți pachet lxd în depozitul snap puteți folosi următoarea comandă:

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

Prin rularea comenzii list vă puteți asigura că pachetul lxd neinstalat încă:

snap list

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

În ciuda faptului că LXD este un pachet rapid, acesta trebuie instalat prin pachetul de sistem lxd, care va crea grupul corespunzător în sistem, utilitățile necesare în /usr/bin etc

sudo apt update
sudo apt install lxd

Să ne asigurăm că pachetul este instalat ca pachet rapid:

snap list

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

Instalarea LXD pe distribuțiile Arch Linux ^

Pentru a instala pachetul LXD pe sistem, trebuie să rulați următoarele comenzi, prima va actualiza lista de pachete din sistem disponibilă în depozit, a doua va instala direct pachetul:

sudo pacman -Syyu && sudo pacman -S lxd

După instalarea pachetului, pentru a gestiona LXD de către un utilizator obișnuit, acesta trebuie adăugat la grupul de sistem lxd:

sudo usermod -a -G lxd user1

Să ne asigurăm că utilizatorul user1 adăugat la grup lxd:

id -Gn user1

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

Dacă grupul lxd nu este vizibil în listă, atunci trebuie să activați din nou sesiunea utilizator. Pentru a face acest lucru, trebuie să vă deconectați și să vă conectați sub același utilizator.

Activați în systemd încărcarea serviciului LXD la pornirea sistemului:

sudo systemctl enable lxd

Să începem serviciul:

sudo systemctl start lxd

Verificarea stării serviciului:

sudo systemctl status lxd

Stocare LXD (depozitare) ^

Înainte de a începe inițializarea, trebuie să înțelegem cum este aranjată logic stocarea în LXD.

Depozitare (Depozitare) constă din de la unul sau mai multe Bazin de depozitare care utilizează unul dintre sistemele de fișiere acceptate, cum ar fi ZFS, BTRFS, LVM sau directoare obișnuite. Fiecare Bazin de depozitare este împărțit în volume (Volumul de stocare) care conțin imagini, containere sau date în alte scopuri.

• imagini - acestea sunt distribuții special asamblate fără nucleul Linux și disponibile din surse externe
• containere - acestea sunt distribuții implementate din imagini, gata de utilizare
• Instantanee - acestea sunt instantanee ale stării containerelor la care vă puteți întoarce

Pentru a gestiona stocarea în LXD, utilizați comanda lxc storage un certificat pentru care puteți obține prin specificarea cheii - lxc storage --help

Următoarea comandă afișează o listă cu toate Bazin de depozitare în stocarea LXD:

lxc storage list

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

Pentru a vizualiza o listă cu toate Volumul de stocare în cele selectate Bazin de depozitare servește echipa 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       |
+-----------+----------------------------------+-------------+---------+

De asemenea, dacă pentru Bazin de depozitare La creare, a fost selectat sistemul de fișiere BTRFS, apoi obțineți o listă Volumul de stocare sau subvolume în interpretarea BTRFS, puteți utiliza setul de instrumente al acestui sistem de fișiere:

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

Se inițializează LXD ^

Înainte de a crea și utiliza containere, trebuie să efectuați o inițializare generală LXD care creează și configurează rețeaua și stocarea. Acest lucru se poate face manual folosind comenzile client standard care sunt disponibile în listă prin apelarea comenzii lxc --help sau folosind vrăjitorul de inițializare lxd init răspunzând la câteva întrebări.

Selectarea unui sistem de fișiere pentru Pool-ul de stocare ^

În timpul inițializării, LXD pune mai multe întrebări, inclusiv determinarea tipului sistemului de fișiere pentru sistemul implicit Bazin de depozitare. În mod implicit, sistemul de fișiere BTRFS este selectat pentru acesta. Va fi imposibil să treceți la un alt FS după creare. Pentru a selecta un FS este sugerat tabel de comparație a caracteristicilor:

Caracteristică
director
Btrfs
LVM
ZFS
CEPH

Stocare optimizată a imaginilor
Nu.
da
da
da
da

Crearea de instanțe optimizată
Nu.
da
da
da
da

Crearea de instantanee optimizată
Nu.
da
da
da
da

Transfer de imagini optimizat
Nu.
da
Nu.
da
da

Transfer optimizat de instanță
Nu.
da
Nu.
da
da

Copie pe scriere
Nu.
da
da
da
da

Bazat pe bloc
Nu.
Nu.
da
Nu.
da

Clonarea instantanee
Nu.
da
da
da
da

Driver de stocare utilizabil în interiorul unui container
da
da
Nu.
Nu.
Nu.

Restaurați din instantanee mai vechi (nu cele mai recente)
da
da
da
Nu.
da

Cote de stocare
da(*)
da
da
da
Nu.

Inițializarea rețelei și a pool-ului de stocare folosind vrăjitorul ^

Următoarea comandă pe care o vom analiza sugerează configurarea componentelor principale ale LXD, răspunzând la întrebări simple folosind vrăjitorul de inițializare.

Executa comanda lxc init și introduceți răspunsurile la întrebări după două puncte așa cum se arată în exemplul de mai jos sau modificați-le în funcție de condițiile dvs.:

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

Crearea unui pool de stocare suplimentar ^

În pasul anterior am creat Bazin de depozitare căruia i s-a dat numele ssdpool și al cărui fișier se află pe sistemul meu la /var/lib/lxd/disks/ssdpool.img. Această adresă de sistem de fișiere corespunde unității SSD fizice din computerul meu.

Următoarele acțiuni, pentru a extinde înțelegerea rolului jucat de Bazin de depozitare în depozit, vom crea un al doilea Bazin de depozitare care va fi localizat fizic pe un alt tip de disc, HDD. Problema este că LXD nu vă permite să creați Bazin de depozitare în afara adresei /var/lib/lxd/disks/ și nici măcar link-urile simbolice nu vor funcționa, vezi răspunsul dezvoltatorului. Putem ocoli această limitare în timpul inițializării/formatării Bazin de depozitare prin specificarea valorii ca dispozitiv bloc în loc de calea către fișierul loopback, specificând aceasta în cheie source.

Deci, înainte de a crea Bazin de depozitare trebuie să definiți un fișier loopback sau o partiție existentă pe sistemul dvs. de fișiere pe care o va folosi. Pentru a face acest lucru, vom crea și folosi un fișier pe care îl vom limita în dimensiune la 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

Să conectăm fișierul loopback la un dispozitiv de loopback gratuit:

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

/dev/loop1

Datorită cheii --show executarea comenzii returnează pe ecran numele dispozitivului la care este conectat fișierul nostru de loopback. Dacă este necesar, putem afișa o listă cu toate dispozitivele ocupate de acest tip pentru a ne asigura că acțiunile noastre sunt corecte:

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

Din listă puteți afla că dispozitivul are /dev/loop1 fișier loopback inclus /mnt/work/lxd/hddpool.img, și în dispozitiv /dev/loop0 fișier loopback inclus /var/lib/lxd/disks/ssdpool.img care corespunde implicit Bazin de depozitare.

Următoarea comandă creează una nouă Bazin de depozitare în LXD pe baza fișierului loopback pe care tocmai l-am pregătit. LXD va formata fișierul loopback /mnt/work/lxd/hddpool.img în aparat /dev/loop1 pentru sistemul de fișiere BTRFS:

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

Să afișăm o listă cu toate Bazin de depozitare la ecran:

lxc storage list

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

Creșterea dimensiunii pool-ului de stocare ^

După creație Bazin de depozitare, dacă este necesar, poate fi extins. Pentru Bazin de depozitare pe baza sistemului de fișiere BTRFS, rulați următoarele comenzi:

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

Inserarea automată a unui fișier loopback într-un slot pentru dispozitivul loopback ^

Avem o mică problemă, la repornirea sistemului gazdă, fișierul /mnt/work/lxd/hddpool.img va „zbura” din dispozitiv /dev/loop1 iar serviciul LXD se va bloca la încărcare, deoarece nu îl va vedea pe acest dispozitiv. Pentru a rezolva această problemă, trebuie să creați un serviciu de sistem care va introduce acest fișier în dispozitiv /dev/loop1 când sistemul gazdă pornește.

Să creăm unitate tip fișier serviciu в /etc/systemd/system/ pentru sistemul de inițializare 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

Activați serviciul:

sudo systemctl enable lxd-hddpool

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

După repornirea sistemului gazdă, verificăm starea serviciului:

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

Din rezultat putem verifica dacă starea serviciului este activ, în ciuda faptului că execuția scriptului nostru dintr-o comandă a fost finalizată, opțiunea ne-a permis să facem acest lucru RemainAfterExit=true.

Siguranță. Privilegii container ^

Deoarece toate procesele container rulează de fapt izolat pe sistemul gazdă folosind nucleul său, pentru a proteja în continuare accesul proceselor container la sistemul gazdă, LXD oferă privilegii de proces, unde:

• Containere privilegiate - acestea sunt containere în care procesele cu UID și GID corespund aceluiași proprietar ca pe sistemul gazdă. De exemplu, un proces care rulează într-un container cu un UID de 0 are toate aceleași drepturi de acces ca un proces pe sistemul gazdă cu un UID de 0. Cu alte cuvinte, utilizatorul rădăcină din container are toate drepturile nu numai în containerul, dar și pe sistemul gazdă dacă poate ieși în afara spațiului de nume izolat al containerului.

• Containere neprivilegiate - acestea sunt containere în care procesele aparțin proprietarului UID-ului și GID-ului cu un număr de la 0 la 65535, dar pentru sistemul gazdă proprietarul este mascat folosind biții SubUID și, respectiv, SubGID adăugați. De exemplu, un utilizator cu UID=0 într-un container va fi văzut pe sistemul gazdă ca SubUID + UID. Acest lucru protejează sistemul gazdă deoarece, dacă orice proces din container este capabil să scape spațiul de nume izolat, poate comunica cu sistemul gazdă doar ca proces cu un UID/GID necunoscut, foarte mare.

În mod implicit, containerele nou create au un statut neprivilegiat și, prin urmare, trebuie să definim un SubUID și un SubGID.

Să creăm două fișiere de configurare în care vom seta masca pentru SubUID și respectiv SubGID:

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

Pentru a aplica modificările, serviciul LXD trebuie repornit:

sudo systemctl restart lxd

Crearea unui comutator de rețea virtuală ^

Deoarece am inițializat anterior rețeaua folosind vrăjitorul de inițializare lxd init și a creat un dispozitiv de rețea lxdbr0, apoi în această secțiune ne vom familiariza pur și simplu cu rețelele în LXD și cum să creați un comutator virtual (punte) folosind comanda client.

Următoarea diagramă demonstrează modul în care un comutator (punte) conectează gazda și containerele într-o rețea:

Containerele pot comunica prin intermediul unei rețele cu alte containere sau cu gazda pe care sunt deservite aceste containere. Pentru a face acest lucru, trebuie să conectați cardurile de rețea virtuale ale containerelor cu un comutator virtual. Vom crea mai întâi un comutator, iar interfețele de rețea ale containerului vor fi legate în capitolele următoare, după ce containerul în sine a fost creat.

Următoarea comandă creează un comutator cu o subrețea 10.0.5.0/24 și adresa IPv4 10.0.5.1/24, și include, de asemenea ipv4.nat astfel încât containerele să poată accesa Internetul prin gazdă folosind serviciul NAT:

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

Verificarea listei de dispozitive de rețea disponibile în LXD:

lxc network list

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

De asemenea, puteți verifica dacă un dispozitiv de rețea a fost creat folosind instrumentul standard al distribuției Linux - ip link sau 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

Profil de configurare ^

Fiecare container din LXD are propria sa configurație și o poate extinde cu configurații declarate global numite profiluri de configurare. Aplicarea profilurilor de configurare la un container are un model în cascadă, următorul exemplu demonstrează acest lucru:

În acest exemplu, au fost create trei profiluri în sistemul LXD: default, hddpool и hostfs. Toate cele trei profiluri sunt aplicate unui container care are o configurație locală (zonă gri). Profil default are un dispozitiv root care are un parametru pool este egal cu ssdpool, dar datorită modelului de aplicație de configurare în cascadă, putem aplica un profil containerului hddpool care are un parametru pool va suprascrie același parametru din profil default iar containerul va primi configurația dispozitivului root cu parametru pool egal hddpool, și profilul hostfs adaugă pur și simplu un nou dispozitiv la container.

Pentru a vedea lista profilurilor de configurare disponibile, utilizați următoarea comandă:

lxc profile list

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

O listă completă a comenzilor disponibile pentru lucrul cu un profil poate fi obținută prin adăugarea cheii --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

Editarea profilului dvs ^

Profil de configurare implicit default nu are o configurație de placă de rețea pentru container și toate containerele nou create nu au rețea, pentru ele este necesar să se creeze dispozitive de rețea locale (dedicate) cu o comandă separată, dar putem crea un dispozitiv de rețea globală în configurație profil care va fi partajat între toate containerele care utilizează acest profil. Astfel, imediat după comanda de a crea un container nou, vor avea o rețea cu acces la rețea. În același timp, nu există restricții; putem crea oricând un dispozitiv de rețea locală mai târziu, dacă este necesar.

Următoarea comandă va adăuga dispozitivul la profilul de configurare eth0 tip nic conectat la rețea lxdbr0:

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

Este important de reținut că, deoarece am adăugat de fapt dispozitivul la profilul de configurare, dacă am specificat o adresă IP statică în dispozitiv, atunci toate containerele care vor folosi acest profil vor împărtăși aceeași adresă IP. Dacă este nevoie să creați un container cu o adresă IP statică alocată containerului, atunci ar trebui să creați o configurație a dispozitivului de rețea la nivel de container (configurație locală) cu parametrul de adresă IP și nu la nivel de profil.

Să verificăm profilul:

lxc profile show default

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

În acest profil putem vedea că pentru toate containerele nou create vor fi create două dispozitive:

• eth0 - Tip de dispozitiv nic conectat la un comutator (punte de rețea) lxdbr0
• root - Tip de dispozitiv disk care utilizează un bazin de stocare ssdpool

Crearea de noi profiluri ^

Pentru a utiliza creat anterior Bazin de depozitare containere, creați un profil de configurare ssdroot în care vom adăuga un dispozitiv ca disk cu punct de montare / (rădăcină) folosind cea creată anterior Bazin de depozitare - ssdpool:

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

În mod similar, creăm un dispozitiv ca disk, dar în acest caz folosind Bazin de depozitare - hddpool:

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

Verificarea profilurilor de configurare:

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

Depozitul de imagini ^

Containerele sunt create din imagini care sunt distribuții special asamblate care nu au un nucleu Linux. Prin urmare, înainte de a rula containerul, acesta trebuie să fie implementat din această imagine. Sursa imaginilor este un depozit local în care imaginile sunt descărcate din depozite externe.

Arhivele de imagini de la distanță ^

În mod implicit, LXD este configurat să primească imagini de la trei surse de la distanță:

• ubuntu: (pentru imagini stabile Ubuntu)
• ubuntu-zilnic: (pentru imagini zilnice Ubuntu)
• imagini: (pentru o grămadă de alte distribuții)

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

De exemplu, depozit ubuntu: are urmatoarele imagini:

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

Pentru a afișa un număr limitat de coloane am folosit opțiunea -c cu parametrii dasutși, de asemenea, a limitat lungimea listei cu comanda head.

Filtrarea este disponibilă pentru a afișa o listă de imagini. Următoarea comandă va lista toate arhitecturile de distribuție disponibile AlpineLinux:

lxc image -c ldast list images:alpine/3.11

+------------------------------+--------------------------------------+--------------+
|            ALIAS             |             DESCRIPTION              | ARCHITECTURE |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11 (3 more)         | Alpine 3.11 amd64 (20200220_13:00)   | x86_64       |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/arm64 (1 more)   | Alpine 3.11 arm64 (20200220_13:00)   | aarch64      |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/armhf (1 more)   | Alpine 3.11 armhf (20200220_13:00)   | armv7l       |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/i386 (1 more)    | Alpine 3.11 i386 (20200220_13:01)    | i686         |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/ppc64el (1 more) | Alpine 3.11 ppc64el (20200220_13:00) | ppc64le      |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/s390x (1 more)   | Alpine 3.11 s390x (20200220_13:00)   | s390x        |
+------------------------------+--------------------------------------+--------------+

Depozitul local de imagini ^

Pentru a începe să utilizați containerul, trebuie să adăugați o imagine din depozitul global la cel local local:. Acum, depozitul local este gol, comanda se va asigura de acest lucru lxc image list. Dacă metoda list nu specificați un depozit, atunci depozitul local va fi folosit implicit - local:

lxc image list local:

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

Imaginile din depozit sunt gestionate folosind următoarele metode:

Echipă
descriere

imagine lxc alias
Gestionați aliasurile de imagine

imagine lxc copiaţi
Copiați imagini între servere

imagine lxc șterge
Ștergeți imaginile

imagine lxc edita
Editați proprietățile imaginii

imagine lxc exporturile
Exportați și descărcați imagini

imagine lxc import
Importați imagini în magazinul de imagini

imagine lxc info
Afișați informații utile despre imagini

imagine lxc listă
Lista imagini

imagine lxc reîmprospăta
Reîmprospătați imaginile

imagine lxc Arăta
Afișați proprietățile imaginii

Copiați imaginea în depozitul local din cel global images::

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

Image copied successfully!

Să afișăm o listă cu toate imaginile disponibile în prezent în depozitul local local::

lxc image -c lfdatsu list local:

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

Configurație LXD ^

Pe lângă modul interactiv, LXD acceptă și un mod de instalare a configurației neinteractive, acesta fiind momentul în care configurația este specificată sub forma unui fișier YAML, un format special care vă permite să instalați întreaga configurație dintr-o dată, ocolind execuția din multe comenzi interactive care au fost discutate mai sus în acest articol, inclusiv configurarea rețelei, crearea profilurilor de configurare etc. Nu vom acoperi această zonă aici, o puteți verifica pe cont propriu. în documentare.

Următoarea comandă interactivă lxc config la care ne vom uita vă permite să setați configurația. De exemplu, pentru a ne asigura că imaginile descărcate în depozitul local nu sunt actualizate automat din arhivele globale, putem activa acest comportament cu următoarea comandă:

lxc config set images.auto_update_cached=false

Crearea și gestionarea unui container ^

Pentru a crea un container utilizați comanda lxc init la care se transmit valori репозиторий:образ și apoi ID-ul dorit pentru container. Depozitul poate fi specificat ca local local: la fel este orice global. Dacă depozitul nu este specificat, atunci în mod implicit, depozitul local este folosit pentru a căuta imaginea. Dacă imaginea este specificată din depozitul global, atunci imaginea va fi mai întâi descărcată în depozitul local și apoi folosită pentru a crea containerul.

Să rulăm următoarea comandă pentru a crea primul nostru container:

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

Să ne uităm la tastele de comandă pe care le folosim aici în ordine:

• alpine3 — Este specificat un alias (alias) pentru imaginea care a fost încărcată anterior în depozitul local. Dacă aliasul nu a fost creat pentru această imagine, atunci puteți oricând să vă referiți la imagine prin intermediul acesteia amprentă digitală care este afișat în tabel.
• alp — Setează identificatorul pentru container
• --storage — Această cheie indică în care Bazin de depozitare va fi creat un container
• --profile — Aceste taste aplică în cascadă configurația din profilurile de configurare create anterior la container

Lansăm containerul, care începe să lanseze sistemul init al distribuției:

lxc start alp

De asemenea, puteți utiliza comanda lxc launch care vă permite să combinați echipe lxc init и lxc start într-o singură operație.

Verificarea stării containerului:

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

Verificarea configurației containerului:

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

In sectiunea profiles ne putem asigura că acest container folosește două profiluri de configurare − default и hddroot. In sectiune devices putem detecta doar un dispozitiv deoarece dispozitivul de rețea a fost creat la nivel de profil default. Pentru a vedea toate dispozitivele utilizate de container, trebuie să adăugați o cheie --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: ""

Setarea unei adrese IP statice ^

Dacă încercăm să setăm o adresă IP pentru un dispozitiv de rețea eth0 echipă lxc config device set alp destinat configurației containerului, atunci vom primi o eroare care va raporta că dispozitivul nu există din cauza dispozitivului eth0 care este folosit de container aparține profilului default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Desigur, putem seta o adresă IP statică pentru eth0 dispozitive din profil, dar va fi același pentru toate containerele care vor folosi acest profil. Prin urmare, să adăugăm un dispozitiv dedicat containerului:

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

Apoi trebuie să reporniți containerul:

lxc restart alp

Dacă ne uităm la configurația containerului acum, nu este nevoie să folosim opțiunea --expanded pentru a vedea dispozitivul de rețea eth0, deoarece l-am creat la nivel de container și a cascat peste același dispozitiv din profil 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: ""

Scoaterea unui recipient ^

Pentru a elimina un container, utilizați comanda lxc delete, dar înainte de a scoate containerul, acesta trebuie oprit folosind comanda lxc stop:

lxc stop alp

lxc list

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

După ce am verificat că starea containerului a devenit OPRIT, poate fi scos din Bazin de depozitare:

lxc delete alp

Acces container ^

Pentru a executa comenzi direct într-un container, ocolind conexiunile de rețea, utilizați comanda lxc exec care execută comenzi în container fără a lansa shell-ul sistemului. Dacă trebuie să executați o comandă într-un shell folosind modele de shell, cum ar fi variabile, redirecționări de fișiere (pipe), etc., atunci trebuie să lansați în mod explicit shell-ul și să transmiteți comanda ca o cheie, de exemplu:

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

Comanda a folosit un caracter de escape special pentru caracter special $ astfel încât variabila $HOME nu a fost interpretat pe mașina gazdă, ci a fost interpretat numai în interiorul containerului.

De asemenea, este posibil să porniți modul shell interactiv și apoi să încheiați sesiunea prin executarea tastei rapide CTRL+D:

lxc exec alp -- /bin/sh

Managementul resurselor containerelor ^

În LXD, puteți gestiona resursele containerului folosind un set special de configurare. O listă completă a parametrilor de configurare a containerului poate fi găsită în documentare.

Limitarea resurselor RAM ^

Parametru limits.memory limitează cantitatea de RAM disponibilă pentru container. Valoarea este un număr și unul dintre sufixe disponibile.

Să setăm limita RAM a containerului la 256 MB:

lxc config set alp limits.memory 256MB

De asemenea, există și alți parametri pentru limitarea memoriei:

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

Echipă lxc config show vă permite să afișați întreaga configurație a containerului, inclusiv limita de resurse aplicată care a fost setată:

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

Limita resurselor CPU ^

Există mai multe moduri de a limita resursele CPU. tipuri de restricții:

• limit.cpu - leagă un container la unul sau mai multe nuclee CPU
• limits.cpu.allowance - gestionează fie cotele de planificare CFS când limita de timp a depășit, fie mecanismul universal de partajare a resurselor CPU când procentul a depășit
• limits.cpu.priority - prioritatea planificatorului atunci când mai multor instanțe care partajează un set de procesoare li se atribuie același procent de procesoare

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

Limitarea spațiului pe disc ^

Pe lângă restricţii de genul limits.read, limits.write putem limita, de asemenea, cantitatea de spațiu pe disc consumată de container (funcționează doar cu ZFS sau BTRFS):

lxc config device set alp root size=2GB

După instalare, în parametru devices.root.size Putem verifica limita stabilită:

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

Pentru a vizualiza cotele de disc utilizate, le putem obține din comandă 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

În ciuda faptului că am stabilit o limită pentru dispozitivul rădăcină al containerului la 2 GB, utilități de sistem precum df nu va vedea această restricție. Pentru a face acest lucru, vom efectua un mic test și vom afla cum funcționează.

Să creăm 2 containere noi identice în același Bazin de depozitare (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         |
+------+---------+------------------+------+-----------+-----------+

Să creăm un fișier de 1 GB într-unul dintre containere:

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

Să ne asigurăm că fișierul este creat:

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

Dacă ne uităm în al doilea container, verificăm existența unui fișier în aceeași locație, atunci acest fișier nu va fi acolo, ceea ce este de așteptat, deoarece containerele sunt create în propriile lor Volumul de stocare în același Bazin de depozitare:

lxc exec alp2 -- ls -lh
total 0

Dar să comparăm valorile pe care le produce df pe unul și pe celălalt recipient:

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

dispozitiv /dev/loop1 montat ca partiția rădăcină Bazin de depozitare pe care aceste containere le folosesc, astfel încât acestea împart volumul între doi.

Statistica consumului de resurse ^

Puteți vizualiza statisticile consumului de resurse pentru un container utilizând comanda:

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

Lucrul cu instantanee ^

LXD are capacitatea de a crea instantanee și de a restabili starea containerului din acestea.

Pentru a crea un instantaneu, executați următoarea comandă:

lxc snapshot alp snapshot1

Echipa lxc snapshot nicio cheie disponibilă list, prin urmare, pentru a vizualiza lista de instantanee trebuie să utilizați comanda care afișează informații generale despre container:

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

Puteți restaura un container dintr-un instantaneu folosind comanda lxc restore specificând containerul pentru care va fi efectuată restaurarea și aliasul instantaneului:

lxc restore alp snapshot1

Următoarea comandă este folosită pentru a șterge un instantaneu. Vă rugăm să rețineți că sintaxa comenzii nu este similară cu toate celelalte; aici trebuie să specificați o bară oblică după numele containerului. Dacă bara oblică este omisă, atunci comanda de ștergere a unui instantaneu este interpretată ca o comandă de ștergere a unui container!

lxc delete alp/snapshot1

În exemplul de mai sus, ne-am uitat la așa-numitele instantanee fără stat. LXD are un alt tip de instantanee - cu stare, care salvează starea curentă a tuturor proceselor din container. Există o serie de caracteristici interesante și utile asociate cu instantanee cu stare.

Ce altceva? ^

• Un modul este disponibil pentru dezvoltatorii Python PyLXD care oferă un API pentru LXD

UPDATE 10.04.2020/15/00 XNUMX:XNUMX: Navigare adăugată

Sursa: www.habr.com