LXD és el gestor de contenidors del sistema de nova generació, així ho diu font. Ofereix una interfície d'usuari similar a les màquines virtuals, però utilitza contenidors Linux.

Nucli LXD és un dimoni privilegiat (un servei que s'executa amb drets d'arrel) que proporciona una API REST mitjançant un sòcol Unix local, així com a través de la xarxa si hi ha instal·lada la configuració adequada. Els clients, com ara l'eina de línia d'ordres proporcionada amb LXD, fan sol·licituds mitjançant aquesta API REST. Això vol dir que tant si accediu a un host local com a un host remot, tot funciona igual.

En aquest article no ens detenem en detall en els conceptes de LXD, no considerarem totes les capacitats disponibles descrites a la documentació, inclosa la recent implementació en les últimes versions de LXD de suport per a màquines virtuals QEMU en paral·lel amb contenidors. En canvi, aprendrem només els conceptes bàsics de la gestió de contenidors: configurar grups d'emmagatzematge, xarxes, executar un contenidor, aplicar límits de recursos i com utilitzar instantànies perquè pugueu obtenir una comprensió bàsica de LXD i utilitzar contenidors a Linux.

Per obtenir informació completa, consulteu la font oficial:

• Lloc web del desenvolupador
• Registres
• Fòrum

Навигация

• Instal·lació LXD
  • Instal·lació de LXD a les distribucions d'Ubuntu
  • Instal·lació de LXD a les distribucions d'Arch Linux
• Emmagatzematge LXD (emmagatzematge)
• Inicialització de LXD
  • Selecció d'un sistema de fitxers per a l'agrupació d'emmagatzematge
  • Inicialització de la xarxa i l'agrupació d'emmagatzematge mitjançant l'assistent
  • Creació d'una agrupació d'emmagatzematge addicional
    • Augment de la mida de l'agrupació d'emmagatzematge
    • Inserció automàtica d'un fitxer de loopback a una ranura de dispositiu de loopback
  • Seguretat. Privilegis del contenidor
  • Creació d'un commutador de xarxa virtual
  • Perfil de configuració
    • Editant el teu perfil
    • Creació de nous perfils
  • Repositori d'imatges
    • Repositoris d'imatges remots
    • Repositori local d'imatges
  • Configuració LXD
• Creació i gestió d'un contenidor
  • Configuració d'una adreça IP estàtica
  • Retirada d'un contenidor
  • Accés al contenidor
  • Gestió de recursos de contenidors
    • Limitació de recursos RAM
    • Límit de recursos de la CPU
    • Limitació d'espai en disc
    • Estadístiques de consum de recursos
  • Treballant amb instantànies

Instal·lació LXD ^

Instal·lació de LXD a les distribucions d'Ubuntu ^

Al paquet de distribució Ubuntu 19.10 lxd té una emissió activada paquet ràpid:

apt search lxd

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

Això vol dir que s'instal·laran dos paquets alhora, un com a paquet del sistema i l'altre com a paquet instantani. La instal·lació de dos paquets en un sistema pot crear algun problema on el paquet del sistema es pot quedar orfe si el gestor de paquets snap elimina el paquet snap.

Cerca paquet lxd al repositori Snap podeu utilitzar l'ordre següent:

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

En executar l'ordre list podeu assegurar-vos que el paquet lxd encara no instal·lat:

snap list

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

Tot i que LXD és un paquet instantani, s'ha d'instal·lar mitjançant el paquet del sistema lxd, que crearà el grup corresponent al sistema, les utilitats necessàries en /usr/bin etcètera

sudo apt update
sudo apt install lxd

Assegurem-nos que el paquet estigui instal·lat com a paquet instantani:

snap list

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

Instal·lació de LXD a les distribucions d'Arch Linux ^

Per instal·lar el paquet LXD al sistema, heu d'executar les ordres següents, el primer actualitzarà la llista de paquets del sistema disponible al repositori, el segon instal·larà directament el paquet:

sudo pacman -Syyu && sudo pacman -S lxd

Després d'instal·lar el paquet, per poder gestionar LXD per un usuari habitual, s'ha d'afegir al grup del sistema lxd:

sudo usermod -a -G lxd user1

Assegurem-nos que l'usuari user1 afegit al grup lxd:

id -Gn user1

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

Si el grup lxd no és visible a la llista, llavors cal que torneu a activar la sessió d'usuari. Per fer-ho, heu de tancar la sessió i iniciar sessió amb el mateix usuari.

Activa en systemd carregant el servei LXD a l'inici del sistema:

sudo systemctl enable lxd

Comencem el servei:

sudo systemctl start lxd

Comprovació de l'estat del servei:

sudo systemctl status lxd

Emmagatzematge LXD (emmagatzematge) ^

Abans de començar la inicialització, hem d'entendre com s'organitza lògicament l'emmagatzematge a LXD.

Emmagatzematge (Dipòsit) consisteix en d'un o més Piscina d'emmagatzematge que utilitza un dels sistemes de fitxers compatibles com ZFS, BTRFS, LVM o directoris normals. Cada Piscina d'emmagatzematge es divideix en volums (Volum d'emmagatzematge) que continguin imatges, contenidors o dades per a altres finalitats.

• Imatges - Són distribucions especialment muntades sense el nucli Linux i disponibles des de fonts externes
• contenidors - Es tracta de distribucions desplegades a partir d'imatges, llestes per al seu ús
• Imatges instantànies - aquestes són instantànies de l'estat dels contenidors als quals podeu tornar

Per gestionar l'emmagatzematge a LXD, utilitzeu l'ordre lxc storage un certificat que podeu obtenir especificant la clau - lxc storage --help

L'ordre següent mostra una llista de tots Piscina d'emmagatzematge en emmagatzematge LXD:

lxc storage list

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

Per veure una llista de tots Volum d'emmagatzematge en el seleccionat Piscina d'emmagatzematge serveix a l'equip 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       |
+-----------+----------------------------------+-------------+---------+

També, si per Piscina d'emmagatzematge En crear, es va seleccionar el sistema de fitxers BTRFS i, a continuació, obteniu una llista Volum d'emmagatzematge o subvolums a la interpretació BTRFS, podeu utilitzar el conjunt d'eines d'aquest sistema de fitxers:

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

Inicialització de LXD ^

Abans de crear i utilitzar contenidors, heu de realitzar una inicialització general de LXD que crea i configura la xarxa i l'emmagatzematge. Això es pot fer manualment mitjançant ordres de client estàndard que estan disponibles a la llista cridant l'ordre lxc --help o utilitzant l'assistent d'inicialització lxd init responent unes quantes preguntes.

Selecció d'un sistema de fitxers per a l'agrupació d'emmagatzematge ^

Durant la inicialització, LXD fa diverses preguntes, inclosa la determinació del tipus de sistema de fitxers per defecte Piscina d'emmagatzematge. Per defecte, el sistema de fitxers BTRFS està seleccionat per a això. Serà impossible canviar a un altre FS després de la creació. Es recomana seleccionar un FS taula de comparació de característiques:

característica
directori
Btrfs
LVM
ZFS
CEPH

Emmagatzematge d'imatges optimitzat
no
yes
yes
yes
yes

Creació d'instàncies optimitzada
no
yes
yes
yes
yes

Creació d'instantània optimitzada
no
yes
yes
yes
yes

Transferència d'imatges optimitzada
no
yes
no
yes
yes

Transferència d'instàncies optimitzada
no
yes
no
yes
yes

Còpia en escriptura
no
yes
yes
yes
yes

Basat en blocs
no
no
yes
no
yes

Clonació instantània
no
yes
yes
yes
yes

Controlador d'emmagatzematge utilitzable dins d'un contenidor
yes
yes
no
no
no

Restaura des d'instantànies anteriors (no les darreres)
yes
yes
yes
no
yes

Quotes d'emmagatzematge
sí (*)
yes
yes
yes
no

Inicialització de la xarxa i l'agrupació d'emmagatzematge mitjançant l'assistent ^

La següent comanda que veurem suggereix configurar els components principals de LXD responent preguntes senzilles mitjançant l'assistent d'inicialització.

Executar l'ordre lxc init i introduïu les respostes a les preguntes després dels dos punts tal com es mostra a l'exemple següent o canvieu-les segons les vostres condicions:

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

Creació d'una agrupació d'emmagatzematge addicional ^

En el pas anterior vam crear Piscina d'emmagatzematge que va rebre el nom ssdpool i el fitxer del qual es troba al meu sistema a /var/lib/lxd/disks/ssdpool.img. Aquesta adreça del sistema de fitxers correspon a la unitat SSD física del meu PC.

Les següents accions, per ampliar la comprensió del paper que juga Piscina d'emmagatzematge al repositori, en crearem un segon Piscina d'emmagatzematge que s'ubicarà físicament en un altre tipus de disc, HDD. El problema és que LXD no et permet crear Piscina d'emmagatzematge fora de domicili /var/lib/lxd/disks/ i fins i tot els enllaços simbòlics no funcionaran, veure la resposta del desenvolupador. Podem obviar aquesta limitació durant la inicialització/format Piscina d'emmagatzematge especificant el valor com a dispositiu de bloc en comptes de la ruta al fitxer de bucle en retorn, especificant-ho a la clau source.

Per tant, abans de crear Piscina d'emmagatzematge heu de definir un fitxer de bucle inversa o una partició existent al vostre sistema de fitxers que utilitzarà. Per fer-ho, crearem i utilitzarem un fitxer que limitarem de mida a 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

Connectem el fitxer de loopback a un dispositiu de loopback gratuït:

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

/dev/loop1

Gràcies a la clau --show executant l'ordre torna a la pantalla el nom del dispositiu al qual està connectat el nostre fitxer de loopback. Si cal, podem mostrar una llista de tots els dispositius ocupats d'aquest tipus per assegurar-nos que les nostres accions són correctes:

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

A la llista podeu trobar que el dispositiu té /dev/loop1 fitxer de loopback inclòs /mnt/work/lxd/hddpool.img, i al dispositiu /dev/loop0 fitxer de loopback inclòs /var/lib/lxd/disks/ssdpool.img que correspon al valor predeterminat Piscina d'emmagatzematge.

La següent comanda en crea una de nova Piscina d'emmagatzematge en LXD basat en el fitxer de bucle que acabem de preparar. LXD formatearà el fitxer de loopback /mnt/work/lxd/hddpool.img al dispositiu /dev/loop1 per al sistema de fitxers BTRFS:

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

Mostrem una llista de tots Piscina d'emmagatzematge a la pantalla:

lxc storage list

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

Augment de la mida de l'agrupació d'emmagatzematge ^

Després de la creació Piscina d'emmagatzematge, si cal, es pot ampliar. Per Piscina d'emmagatzematge basat en el sistema de fitxers BTRFS, executeu les ordres següents:

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

Inserció automàtica d'un fitxer de loopback a una ranura de dispositiu de loopback ^

Tenim un petit problema, quan reiniciem el sistema amfitrió, el fitxer /mnt/work/lxd/hddpool.img "volarà" fora del dispositiu /dev/loop1 i el servei LXD es bloquejarà en carregar perquè no el veurà en aquest dispositiu. Per resoldre aquest problema, heu de crear un servei del sistema que inserirà aquest fitxer al dispositiu /dev/loop1 quan arrenca el sistema amfitrió.

Anem a crear unitat tipus d'arxiu servei в /etc/systemd/system/ per al sistema d'inicialització 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 el servei:

sudo systemctl enable lxd-hddpool

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

Després de reiniciar el sistema amfitrió, comprovem l'estat del servei:

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

Des de la sortida podem comprovar que l'estat del servei és activi, malgrat que l'execució del nostre script des d'una ordre es va completar, l'opció ens va permetre fer-ho RemainAfterExit=true.

Seguretat. Privilegis del contenidor ^

Com que tots els processos del contenidor s'executen realment de manera aïllada al sistema amfitrió mitjançant el seu nucli, per protegir encara més l'accés dels processos del contenidor al sistema amfitrió, LXD ofereix privilegis de procés, on:

• Contenidors privilegiats - Són contenidors en què els processos amb UID i GID corresponen al mateix propietari que al sistema host. Per exemple, un procés que s'executa en un contenidor amb un UID de 0 té tots els mateixos drets d'accés que un procés del sistema amfitrió amb un UID de 0. En altres paraules, l'usuari root del contenidor té tots els drets no només en el contenidor, però també al sistema host si pot sortir fora de l'espai de noms aïllat del contenidor.

• Contenidors sense privilegis - Es tracta de contenidors en què els processos pertanyen al propietari de l'UID i el GID amb un número del 0 al 65535, però per al sistema amfitrió el propietari s'emmascara mitjançant els bits SubUID i SubGID afegits, respectivament. Per exemple, un usuari amb UID=0 en un contenidor es veurà al sistema amfitrió com SubUID + UID. Això protegeix el sistema amfitrió perquè si algun procés del contenidor és capaç d'escapar del seu espai de noms aïllat, només es pot comunicar amb el sistema amfitrió com un procés amb un UID/GID molt alt desconegut.

Per defecte, els contenidors de nova creació tenen un estat sense privilegis i, per tant, hem de definir un SubUID i un SubGID.

Creem dos fitxers de configuració en els quals establirem la màscara per a SubUID i SubGID, respectivament:

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

Per aplicar els canvis, cal reiniciar el servei LXD:

sudo systemctl restart lxd

Creació d'un commutador de xarxa virtual ^

Com que prèviament vam inicialitzar la xarxa mitjançant l'assistent d'inicialització lxd init i va crear un dispositiu de xarxa lxdbr0, llavors en aquesta secció simplement ens familiaritzarem amb les xarxes a LXD i com crear un commutador virtual (pont) mitjançant l'ordre del client.

El diagrama següent mostra com un commutador (pont) connecta l'amfitrió i els contenidors a una xarxa:

Els contenidors poden comunicar-se a través d'una xarxa amb altres contenidors o amb l'amfitrió on es serveixen aquests contenidors. Per fer-ho, cal enllaçar les targetes de xarxa virtual dels contenidors amb un commutador virtual. Primer crearem un commutador i les interfícies de xarxa del contenidor s'enllaçaran en capítols posteriors, un cop creat el propi contenidor.

L'ordre següent crea un commutador amb una subxarxa 10.0.5.0/24 i adreça IPv4 10.0.5.1/24, i també inclou ipv4.nat perquè els contenidors puguin accedir a Internet a través de l'amfitrió mitjançant el servei NAT:

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

Comprovació de la llista de dispositius de xarxa disponibles a LXD:

lxc network list

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

També podeu verificar que s'ha creat un dispositiu de xarxa mitjançant l'eina estàndard de la distribució Linux - ip link o 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

Perfil de configuració ^

Cada contenidor de LXD té la seva pròpia configuració i la pot ampliar amb configuracions declarades globalment anomenades perfils de configuració. L'aplicació de perfils de configuració a un contenidor té un model en cascada, l'exemple següent ho demostra:

En aquest exemple, s'han creat tres perfils al sistema LXD: default, hddpool и hostfs. Els tres perfils s'apliquen a un contenidor que té una configuració local (àrea grisa). Perfil default té un dispositiu root que té un paràmetre pool és igual a ssdpool, però gràcies al model d'aplicació de configuració en cascada, podem aplicar un perfil al contenidor hddpool que té un paràmetre pool anul·larà el mateix paràmetre del perfil default i el contenidor rebrà la configuració del dispositiu root amb paràmetre pool igual hddpool, i el perfil hostfs simplement afegeix un dispositiu nou al contenidor.

Per veure la llista de perfils de configuració disponibles, utilitzeu l'ordre següent:

lxc profile list

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

Es pot obtenir una llista completa d'ordres disponibles per treballar amb un perfil afegint la clau --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

Editant el teu perfil ^

Perfil de configuració predeterminat default no té una configuració de targeta de xarxa per al contenidor i tots els contenidors de nova creació no tenen xarxa, per a ells cal crear dispositius de xarxa locals (dedicats) amb una ordre independent, però podem crear un dispositiu de xarxa global a la configuració perfil que es compartirà entre tots els contenidors que utilitzen aquest perfil. D'aquesta manera, immediatament després de l'ordre de crear un nou contenidor, tindran una xarxa amb accés a la xarxa. Al mateix temps, no hi ha restriccions; sempre podem crear un dispositiu de xarxa local més tard si cal.

L'ordre següent afegirà el dispositiu al perfil de configuració eth0 типа nic connectat a la xarxa lxdbr0:

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

És important tenir en compte que, com que realment hem afegit el dispositiu al perfil de configuració, si hem especificat una adreça IP estàtica al dispositiu, tots els contenidors que utilitzaran aquest perfil compartiran la mateixa adreça IP. Si cal crear un contenidor amb una adreça IP estàtica assignada per al contenidor, hauríeu de crear una configuració de dispositiu de xarxa a nivell de contenidor (configuració local) amb el paràmetre d'adreça IP i no a nivell de perfil.

Comprovem el perfil:

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

En aquest perfil podem veure que per a tots els contenidors de nova creació es crearan dos dispositius:

• eth0 - Tipus de dispositiu nic connectat a un commutador (pont de xarxa) lxdbr0
• root - Tipus de dispositiu disk que utilitza un grup d'emmagatzematge ssdpool

Creació de nous perfils ^

Per utilitzar prèviament creat Piscina d'emmagatzematge contenidors, creeu un perfil de configuració ssdroot en què afegirem un dispositiu com disk amb punt de muntatge / (arrel) utilitzant el creat anteriorment Piscina d'emmagatzematge - ssdpool:

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

De la mateixa manera, creem un dispositiu com disk, però en aquest cas utilitzant Piscina d'emmagatzematge - hddpool:

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

Comprovació dels perfils de configuració:

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

Repositori d'imatges ^

Els contenidors es creen a partir d'imatges que són distribucions especialment muntades que no tenen un nucli Linux. Per tant, abans d'executar el contenidor, s'ha de desplegar a partir d'aquesta imatge. La font de les imatges és un dipòsit local al qual es descarreguen imatges des de dipòsits externs.

Repositoris d'imatges remots ^

Per defecte, LXD està configurat per rebre imatges de tres fonts remotes:

• ubuntu: (per a imatges estables d'Ubuntu)
• ubuntu-diari: (per a imatges diàries d'Ubuntu)
• imatges: (per a un munt d'altres distribucions)

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

Per exemple, repositori ubuntu: té les següents imatges:

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

Per mostrar un nombre limitat de columnes hem utilitzat l'opció -c amb paràmetres dasut, i també va limitar la longitud de la llista amb l'ordre head.

El filtratge està disponible per mostrar una llista d'imatges. L'ordre següent enumerarà totes les arquitectures de distribució disponibles 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        |
+------------------------------+--------------------------------------+--------------+

Repositori local d'imatges ^

Per començar a utilitzar el contenidor, cal afegir una imatge del repositori global al local local:. Ara el dipòsit local està buit, l'ordre s'assegurarà d'això lxc image list. Si el mètode list no especifiqueu un dipòsit, llavors el dipòsit local s'utilitzarà per defecte - local:

lxc image list local:

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

Les imatges del repositori es gestionen mitjançant els mètodes següents:

Equip
Descripció

imatge lxc àlies
Gestioneu els àlies d'imatges

imatge lxc copy
Copia imatges entre servidors

imatge lxc esborrar
Eliminar imatges

imatge lxc edita
Edita les propietats de la imatge

imatge lxc exportar
Exporta i baixa imatges

imatge lxc importar
Importa imatges a la botiga d'imatges

imatge lxc info
Mostra informació útil sobre imatges

imatge lxc llista
Llista d'imatges

imatge lxc refresh
Actualitzar imatges

imatge lxc Mostra
Mostra les propietats de la imatge

Copieu la imatge al repositori local des del global images::

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

Image copied successfully!

Mostrem una llista de totes les imatges disponibles actualment al repositori local local::

lxc image -c lfdatsu list local:

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

Configuració LXD ^

A més del mode interactiu, LXD també admet un mode d'instal·lació de configuració no interactiu, és quan la configuració s'especifica en forma d'arxiu YAML, un format especial que permet instal·lar tota la configuració alhora, evitant l'execució. de moltes ordres interactives que es van comentar anteriorment en aquest article, inclosa la configuració de la xarxa, la creació de perfils de configuració, etc. No cobrirem aquesta àrea aquí, podeu comprovar-ho pel vostre compte. en la documentació.

Següent comandament interactiu lxc config que veurem us permet establir la configuració. Per exemple, per assegurar-nos que les imatges baixades al dipòsit local no s'actualitzen automàticament des dels dipòsits globals, podem activar aquest comportament amb l'ordre següent:

lxc config set images.auto_update_cached=false

Creació i gestió d'un contenidor ^

Per crear un contenidor, utilitzeu l'ordre lxc init al qual es transmeten valors репозиторий:образ i després l'identificador desitjat per al contenidor. El repositori es pot especificar com a local local: també ho és qualsevol global. Si no s'especifica el dipòsit, de manera predeterminada s'utilitza el dipòsit local per cercar la imatge. Si la imatge s'especifica des del dipòsit global, la imatge es baixarà primer al dipòsit local i després es farà servir per crear el contenidor.

Executem la següent comanda per crear el nostre primer contenidor:

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

Vegem les tecles d'ordres que fem servir aquí en ordre:

• alpine3 — S'especifica un àlies (àlies) per a la imatge que es va penjar prèviament al repositori local. Si l'àlies no s'ha creat per a aquesta imatge, sempre podeu fer referència a la imatge per la seva Empremta digital que es mostra a la taula.
• alp — Estableix l'identificador del contenidor
• --storage — Aquesta clau indica en quin Piscina d'emmagatzematge es crearà un contenidor
• --profile — Aquestes claus apliquen en cascada la configuració dels perfils de configuració creats anteriorment al contenidor

Llancem el contenidor, que comença a llançar el sistema init de la distribució:

lxc start alp

També podeu utilitzar l'ordre lxc launch que permet combinar equips lxc init и lxc start en una operació.

Comprovació de l'estat del contenidor:

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

Comprovació de la configuració del contenidor:

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

A la secció profiles podem assegurar-nos que aquest contenidor utilitza dos perfils de configuració − default и hddroot. En secció devices només podem detectar un dispositiu perquè el dispositiu de xarxa es va crear a nivell de perfil default. Per veure tots els dispositius utilitzats pel contenidor, cal afegir una clau --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: ""

Configuració d'una adreça IP estàtica ^

Si intentem establir una adreça IP per a un dispositiu de xarxa eth0 equip lxc config device set alp destinat a la configuració del contenidor, aleshores rebrem un error que informarà que el dispositiu no existeix perquè el dispositiu eth0 que fa servir el contenidor pertany al perfil default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Per descomptat, podem establir una adreça IP estàtica eth0 dispositius del perfil, però serà el mateix per a tots els contenidors que utilitzaran aquest perfil. Per tant, afegim un dispositiu dedicat al contenidor:

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

Aleshores, heu de reiniciar el contenidor:

lxc restart alp

Si mirem la configuració del contenidor ara, no cal que utilitzem l'opció --expanded per veure el dispositiu de xarxa eth0, ja que el vam crear a nivell de contenidor i es va en cascada sobre el mateix dispositiu des del perfil 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: ""

Retirada d'un contenidor ^

Per eliminar un contenidor, utilitzeu l'ordre lxc delete, però abans de treure el contenidor, s'ha d'aturar mitjançant l'ordre lxc stop:

lxc stop alp

lxc list

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

Després d'haver comprovat que s'ha convertit en l'estat del contenidor DETERMINAT, es pot treure de Piscina d'emmagatzematge:

lxc delete alp

Accés al contenidor ^

Per executar ordres en un contenidor directament, sense passar les connexions de xarxa, utilitzeu l'ordre lxc exec que executa ordres al contenidor sense llançar l'intèrpret d'ordres del sistema. Si necessiteu executar una ordre en un intèrpret d'ordres mitjançant patrons d'intèrpret d'ordres com ara variables, redireccions de fitxers (pipe), etc., haureu d'executar l'intèrpret d'ordres explícitament i passar l'ordre com a clau, per exemple:

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

L'ordre utilitzava un caràcter d'escapada especial per caràcter especial $ de manera que la variable $HOME no es va interpretar a la màquina host, sinó que només es va interpretar dins del contenidor.

També és possible iniciar el mode d'intèrpret d'ordres interactiu i, a continuació, finalitzar la sessió executant la tecla d'accés ràpid CTRL+D:

lxc exec alp -- /bin/sh

Gestió de recursos de contenidors ^

A LXD, podeu gestionar els recursos del contenidor mitjançant un conjunt especial de configuració. Es pot trobar una llista completa dels paràmetres de configuració del contenidor en la documentació.

Limitació de recursos RAM ^

Paràmetre limits.memory limita la quantitat de RAM disponible per al contenidor. El valor és un número i un de sufixos disponibles.

Establim el límit de RAM del contenidor a 256 MB:

lxc config set alp limits.memory 256MB

A més, hi ha altres paràmetres per limitar la memòria:

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

Equip lxc config show us permet mostrar tota la configuració del contenidor, inclòs el límit de recursos aplicat que s'ha establert:

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

Límit de recursos de la CPU ^

Hi ha diverses maneres de limitar els recursos de la CPU. tipus de restriccions:

• limit.cpu - enllaça un contenidor a un o més nuclis de CPU
• limits.cpu.allowance - gestiona les quotes del programador CFS quan ha passat el límit de temps, o el mecanisme universal de compartició de recursos de la CPU quan el percentatge ha passat
• limits.cpu.priority - prioritat del planificador quan se'ls assigna el mateix percentatge de processadors a diverses instàncies que comparteixen un conjunt de processadors

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

Limitació d'espai en disc ^

A més de restriccions com limits.read, limits.write també podem limitar la quantitat d'espai de disc consumit pel contenidor (només funciona amb ZFS o BTRFS):

lxc config device set alp root size=2GB

Després de la instal·lació, al paràmetre devices.root.size Podem comprovar el límit establert:

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

Per veure les quotes de disc utilitzades podem obtenir des de l'ordre 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

Malgrat que hem establert un límit per al dispositiu arrel del contenidor a 2 GB, utilitats del sistema com ara df no veurà aquesta restricció. Per fer-ho, farem una petita prova i descobrirem com funciona.

Creem 2 nous contenidors idèntics al mateix Piscina d'emmagatzematge (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         |
+------+---------+------------------+------+-----------+-----------+

Creem un fitxer d'1 GB en un dels contenidors:

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

Assegurem-nos que el fitxer està creat:

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

Si mirem al segon contenidor, comprovem l'existència d'un fitxer a la mateixa ubicació, aleshores aquest fitxer no hi serà, cosa que és d'esperar, ja que els contenidors es creen pel seu compte. Volum d'emmagatzematge al mateix Piscina d'emmagatzematge:

lxc exec alp2 -- ls -lh
total 0

Però comparem els valors que produeix df a un i a l'altre contenidor:

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

Dispositiu /dev/loop1 muntat com la partició arrel Piscina d'emmagatzematge que utilitzen aquests contenidors, de manera que en comparteixen el volum entre dos.

Estadístiques de consum de recursos ^

Podeu veure les estadístiques de consum de recursos d'un contenidor mitjançant l'ordre:

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

Treballant amb instantànies ^

LXD té la capacitat de crear instantànies i restaurar-ne l'estat del contenidor.

Per crear una instantània, executeu l'ordre següent:

lxc snapshot alp snapshot1

L'equip lxc snapshot no hi ha cap clau disponible list, per tant, per veure la llista d'instantànies cal utilitzar l'ordre que mostra informació general sobre el contenidor:

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

Podeu restaurar un contenidor des d'una instantània mitjançant l'ordre lxc restore especificant el contenidor per al qual es realitzarà la restauració i l'àlies de la instantània:

lxc restore alp snapshot1

L'ordre següent s'utilitza per eliminar una instantània. Tingueu en compte que la sintaxi de l'ordre no és semblant a totes les altres; aquí heu d'especificar una barra inclinada després del nom del contenidor. Si s'omet la barra inclinada, l'ordre per suprimir una instantània s'interpreta com una ordre per eliminar un contenidor.

lxc delete alp/snapshot1

A l'exemple anterior, vam analitzar les anomenades instantànies sense estat. LXD té un altre tipus d'instantànies: amb estat, que desa l'estat actual de tots els processos del contenidor. Hi ha una sèrie de funcions interessants i útils associades a les instantànies amb estat.

Què més? ^

• Hi ha un mòdul disponible per als desenvolupadors de Python PyLXD que proporciona una API a LXD

ACTUALITZACIÓ 10.04.2020/15/00 XNUMX:XNUMX: Navegació afegit

Font: www.habr.com