LXD é o xestor de contedores do sistema de próxima xeración, polo que di fonte. Ofrece unha interface de usuario similar ás máquinas virtuais, pero no seu lugar usa contedores Linux.

Núcleo LXD é un daemon privilexiado (un servizo que se executa con dereitos de root) que proporciona unha API REST a través dun socket Unix local, así como a través da rede se está instalada a configuración adecuada. Os clientes, como a ferramenta de liña de comandos proporcionada con LXD, realizan solicitudes a través desta API REST. Isto significa que tanto se accede a un host local como a un host remoto, todo funciona igual.

Neste artigo, non nos detendremos en detalle nos conceptos de LXD; non consideraremos todas as capacidades dispoñibles descritas na documentación, incluída a recente implementación nas últimas versións de LXD de soporte para máquinas virtuais QEMU en paralelo con contedores. Pola contra, aprenderemos só os conceptos básicos da xestión de contedores: configurar agrupacións de almacenamento, establecer redes, executar un contedor, aplicar límites de recursos e como usar instantáneas para que poidas ter unha comprensión básica de LXD e usar os contedores en Linux.

Para obter información completa, consulte a fonte oficial:

• Páxina web do programador
• Documentación
• Foro

Navegación

• Instalación LXD
  • Instalación de LXD en distribucións de Ubuntu
  • Instalación de LXD en distribucións de Arch Linux
• Almacenamento LXD (almacenamento)
• Iniciando LXD
  • Selección dun sistema de ficheiros para a agrupación de almacenamento
  • Inicializando a rede e a agrupación de almacenamento mediante o asistente
  • Creando un grupo de almacenamento adicional
    • Aumentando o tamaño da agrupación de almacenamento
    • Inserción automática dun ficheiro de loopback nunha ranura do dispositivo de loopback
  • Seguridade. Privilexios de contedores
  • Creando un interruptor de rede virtual
  • Perfil de configuración
    • Editando o teu perfil
    • Creando novos perfís
  • Repositorio de imaxes
    • Repositorios de imaxes remotos
    • Repositorio local de imaxes
  • Configuración LXD
• Creación e xestión dun contedor
  • Establecer un enderezo IP estático
  • Retirada dun recipiente
  • Acceso a contedores
  • Xestión de recursos de contedores
    • Limitación de recursos RAM
    • Límite de recursos da CPU
    • Limitación de espazo no disco
    • Estatística de consumo de recursos
  • Traballando con instantáneas

Instalación LXD ^

Instalación de LXD en distribucións de Ubuntu ^

No paquete de distribución de Ubuntu 19.10 lxd ten unha emisión activada paquete a presión:

apt search lxd

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

Isto significa que se instalarán dous paquetes á vez, un como paquete do sistema e outro como paquete instantáneo. A instalación de dous paquetes nun sistema pode xerar algún problema no que o paquete do sistema pode quedar orfo se o paquete snap é eliminado polo xestor de paquetes snap.

Buscar paquete lxd no repositorio de snap pode usar o seguinte comando:

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

Ao executar o comando list pode asegurarse de que o paquete lxd aínda non instalado:

snap list

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

A pesar de que LXD é un paquete instantáneo, debe instalarse a través do paquete do sistema lxd, que creará o grupo correspondente no sistema, as utilidades necesarias en /usr/bin etc

sudo apt update
sudo apt install lxd

Asegurémonos de que o paquete está instalado como un paquete instantáneo:

snap list

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

Instalación de LXD en distribucións de Arch Linux ^

Para instalar o paquete LXD no sistema, cómpre executar os seguintes comandos, o primeiro actualizará a lista de paquetes do sistema dispoñible no repositorio, o segundo instalará directamente o paquete:

sudo pacman -Syyu && sudo pacman -S lxd

Despois de instalar o paquete, para xestionar LXD por un usuario normal, debe engadirse ao grupo do sistema lxd:

sudo usermod -a -G lxd user1

Asegurémonos de que o usuario user1 engadido ao grupo lxd:

id -Gn user1

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

Se o grupo lxd non está visible na lista, entón cómpre activar de novo a sesión de usuario. Para iso, cómpre pechar a sesión e iniciar sesión co mesmo usuario.

Activar en systemd cargando o servizo LXD ao iniciar o sistema:

sudo systemctl enable lxd

Comezamos o servizo:

sudo systemctl start lxd

Comprobando o estado do servizo:

sudo systemctl status lxd

Almacenamento LXD (almacenamento) ^

Antes de comezar a inicialización, necesitamos entender como se organiza loxicamente o almacenamento en LXD.

Almacenamento (almacenamento) consiste en dun ou máis Piscina de almacenamento que usa un dos sistemas de ficheiros compatibles como ZFS, BTRFS, LVM ou directorios normais. Cada Piscina de almacenamento divídese en volumes (Volume de almacenamento) que conteñan imaxes, contedores ou datos para outros fins.

• As imaxes - son distribucións especialmente ensambladas sen o núcleo de Linux e dispoñibles en fontes externas
• Contenedores - son distribucións despregadas a partir de imaxes, listas para o seu uso
• Instantáneas - Son instantáneas do estado dos contedores aos que podes volver

Para xestionar o almacenamento en LXD, use o comando lxc storage un certificado para o que pode obter especificando a clave - lxc storage --help

O seguinte comando mostra unha lista de todos Piscina de almacenamento en almacenamento LXD:

lxc storage list

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

Para ver unha lista de todos Volume de almacenamento no seleccionado Piscina de almacenamento serve ao equipo 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       |
+-----------+----------------------------------+-------------+---------+

Ademais, se para Piscina de almacenamento Ao crear, seleccionouse o sistema de ficheiros BTRFS e, a continuación, obtén unha lista Volume de almacenamento ou subvolumes na interpretación BTRFS, pode usar o conxunto de ferramentas deste sistema de ficheiros:

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

Iniciando LXD ^

Antes de crear e utilizar contedores, debe realizar unha inicialización LXD xeral que cree e configure a rede e o almacenamento. Isto pódese facer manualmente usando comandos de cliente estándar que están dispoñibles na lista chamando ao comando lxc --help ou usando o asistente de inicialización lxd init respondendo unhas cantas preguntas.

Selección dun sistema de ficheiros para a agrupación de almacenamento ^

Durante a inicialización, LXD fai varias preguntas, incluíndo a determinación do tipo de sistema de ficheiros por defecto Piscina de almacenamento. Por defecto, o sistema de ficheiros BTRFS está seleccionado para el. Será imposible cambiar a outro FS despois da creación. Para seleccionar un FS suxírese táboa de comparación de características:

característica
guía
btrfs
LVM
ZFS
CEPH

Almacenamento de imaxes optimizado
non
Si
Si
Si
Si

Creación de instancias optimizada
non
Si
Si
Si
Si

Creación de instantáneas optimizada
non
Si
Si
Si
Si

Transferencia de imaxes optimizada
non
Si
non
Si
Si

Transferencia de instancias optimizada
non
Si
non
Si
Si

Copiar en escritura
non
Si
Si
Si
Si

Baseado en bloques
non
non
Si
non
Si

Clonación instantánea
non
Si
Si
Si
Si

Controlador de almacenamento utilizable dentro dun contedor
Si
Si
non
non
non

Restaurar desde instantáneas máis antigas (non as máis recentes)
Si
Si
Si
non
Si

Cotas de almacenamento
si (*)
Si
Si
Si
non

Inicializando a rede e a agrupación de almacenamento mediante o asistente ^

O seguinte comando que veremos suxire configurar os compoñentes principais de LXD respondendo preguntas sinxelas mediante o asistente de inicialización.

Executar comando lxc init e introduza as respostas ás preguntas despois dos dous puntos como se mostra no seguinte exemplo ou cámbiaas segundo as túas condicións:

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

Creando un grupo de almacenamento adicional ^

No paso anterior creamos Piscina de almacenamento que recibiu o nome ssdpool e cuxo ficheiro se atopa no meu sistema en /var/lib/lxd/disks/ssdpool.img. Este enderezo do sistema de ficheiros corresponde á unidade SSD física do meu PC.

As seguintes accións, para ampliar a comprensión do papel desempeñado por Piscina de almacenamento no repositorio, crearemos un segundo Piscina de almacenamento que estará fisicamente situado nun tipo de disco diferente, o HDD. O problema é que LXD non che permite crear Piscina de almacenamento fóra de enderezo /var/lib/lxd/disks/ e ata as ligazóns simbólicas non funcionarán, ver a resposta do programador. Podemos evitar esta limitación durante a inicialización/formateo Piscina de almacenamento especificando o valor como dispositivo de bloque en lugar da ruta ao ficheiro de loopback, especificando isto na clave source.

Entón, antes de crear Piscina de almacenamento cómpre definir un ficheiro de loopback ou unha partición existente no seu sistema de ficheiros que utilizará. Para iso, crearemos e utilizaremos un ficheiro que limitaremos en tamaño 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

Conectemos o ficheiro de loopback a un dispositivo de loopback gratuíto:

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

/dev/loop1

Grazas á chave --show ao executar o comando volve á pantalla o nome do dispositivo ao que está conectado o noso ficheiro de loopback. Se é necesario, podemos mostrar unha lista de todos os dispositivos ocupados deste tipo para asegurarnos de que as nosas accións son correctas:

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

Na lista podes atopar que o dispositivo ten /dev/loop1 ficheiro de loopback incluído /mnt/work/lxd/hddpool.img, e no dispositivo /dev/loop0 ficheiro de loopback incluído /var/lib/lxd/disks/ssdpool.img que se corresponde co predeterminado Piscina de almacenamento.

O seguinte comando crea un novo Piscina de almacenamento en LXD baseado no ficheiro de loopback que acabamos de preparar. LXD formateará o ficheiro de loopback /mnt/work/lxd/hddpool.img no dispositivo /dev/loop1 para o sistema de ficheiros BTRFS:

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

Imos amosar unha lista de todos Piscina de almacenamento para pantalla:

lxc storage list

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

Aumentando o tamaño da agrupación de almacenamento ^

Despois da creación Piscina de almacenamento, se é necesario, pódese ampliar. Para Piscina de almacenamento baseado no sistema de ficheiros BTRFS, execute os seguintes comandos:

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ón automática dun ficheiro de loopback nunha ranura do dispositivo de loopback ^

Temos un pequeno problema, ao reiniciar o sistema host, o ficheiro /mnt/work/lxd/hddpool.img "voará" do dispositivo /dev/loop1 e o servizo LXD fallará ao cargar porque non o verá neste dispositivo. Para resolver este problema, cómpre crear un servizo do sistema que inserirá este ficheiro no dispositivo /dev/loop1 cando se inicia o sistema host.

Imos crear unidade tipo de ficheiro servizo в /etc/systemd/system/ para o sistema de inicialización 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 o servizo:

sudo systemctl enable lxd-hddpool

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

Despois de reiniciar o sistema host, comprobamos o estado do servizo:

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

Desde a saída podemos verificar que o estado do servizo é activo, a pesar de que se completou a execución do noso script desde un comando, a opción permitiunos facelo RemainAfterExit=true.

Seguridade. Privilexios de contedores ^

Dado que todos os procesos do contedor se executan de xeito illado no sistema host usando o seu núcleo, para protexer aínda máis o acceso dos procesos do contedor ao sistema host, LXD ofrece privilexios de proceso, onde:

• Contenedores privilexiados - son contedores nos que os procesos con UID e GID corresponden ao mesmo propietario que no sistema host. Por exemplo, un proceso que se executa nun contedor cun UID de 0 ten todos os mesmos dereitos de acceso que un proceso no sistema host cun UID de 0. Noutras palabras, o usuario root do contedor ten todos os dereitos non só en o contedor, pero tamén no sistema host se pode saír fóra do espazo de nomes illado do contenedor.

• Contenedores non privilexiados - son contedores nos que os procesos pertencen ao propietario do UID e do GID cun número de 0 a 65535, pero para o sistema host o propietario está enmascarado usando os bits SubUID e SubGID engadidos, respectivamente. Por exemplo, un usuario con UID=0 nun contedor verase no sistema host como SubUID + UID. Isto protexe o sistema host porque se algún proceso do contedor é capaz de escapar do seu espazo de nomes illado, só pode comunicarse co sistema host como un proceso cun UID/GID moi alto descoñecido.

Por defecto, os contedores de nova creación teñen un estado sen privilexios e, polo tanto, debemos definir un SubUID e un SubGID.

Imos crear dous ficheiros de configuración nos que estableceremos a máscara para SubUID e SubGID, respectivamente:

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

Para aplicar os cambios, o servizo LXD debe reiniciarse:

sudo systemctl restart lxd

Creando un interruptor de rede virtual ^

Xa que previamente inicializamos a rede mediante o asistente de inicialización lxd init e creou un dispositivo de rede lxdbr0, entón nesta sección simplemente imos familiarizarnos coa rede en LXD e como crear un interruptor virtual (ponte) usando o comando do cliente.

O seguinte diagrama demostra como un interruptor (ponte) conecta o host e os contedores nunha rede:

Os contedores poden comunicarse a través dunha rede con outros contedores ou co host no que se serven estes contedores. Para iso, cómpre vincular as tarxetas de rede virtuais dos contedores cun interruptor virtual. Crearemos primeiro un conmutador e as interfaces de rede do contedor enlazaranse nos capítulos posteriores, despois de que se crease o propio contenedor.

O seguinte comando crea un interruptor cunha subrede 10.0.5.0/24 e enderezo IPv4 10.0.5.1/24, e tamén inclúe ipv4.nat para que os contedores poidan acceder a Internet a través do host mediante o servizo NAT:

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

Comprobando a lista de dispositivos de rede dispoñibles en LXD:

lxc network list

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

Tamén pode verificar que se creou un dispositivo de rede usando a ferramenta estándar da distribución Linux - ip link ou 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ón ^

Cada contedor en LXD ten a súa propia configuración e pode ampliala coas configuracións declaradas globalmente chamadas perfís de configuración. A aplicación de perfís de configuración a un contedor ten un modelo en cascada, o seguinte exemplo móstrao:

Neste exemplo, creáronse tres perfís no sistema LXD: default, hddpool и hostfs. Os tres perfís aplícanse a un contedor que ten unha configuración local (área gris). Perfil default ten un dispositivo root que ten un parámetro pool é igual a ssdpool, pero grazas ao modelo de aplicación de configuración en cascada, podemos aplicar un perfil ao contedor hddpool que ten un parámetro pool anulará o mesmo parámetro do perfil default e o contedor recibirá a configuración do dispositivo root con parámetro pool iguais hddpool, e o perfil hostfs simplemente engade un dispositivo novo ao contedor.

Para ver a lista de perfís de configuración dispoñibles, use o seguinte comando:

lxc profile list

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

Engadindo a chave pódese obter unha lista completa de comandos dispoñibles para traballar cun perfil --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

Editando o teu perfil ^

Perfil de configuración predeterminado default non ten unha configuración de tarxeta de rede para o contedor e todos os contedores de nova creación non teñen rede, para eles é necesario crear dispositivos de rede locais (dedicados) cun comando separado, pero podemos crear un dispositivo de rede global na configuración perfil que se compartirá entre todos os contedores que utilicen este perfil. Deste xeito, inmediatamente despois do comando para crear un novo contedor, terán unha rede con acceso á rede. Ao mesmo tempo, non hai restricións; sempre podemos crear un dispositivo de rede local máis tarde se é necesario.

O seguinte comando engadirá o dispositivo ao perfil de configuración eth0 tipo nic conectado á rede lxdbr0:

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

É importante ter en conta que, dado que realmente engadimos o dispositivo ao perfil de configuración, se especificamos un enderezo IP estático no dispositivo, todos os contedores que usarán este perfil compartirán o mesmo enderezo IP. Se é necesario crear un contedor cun enderezo IP estático asignado para o contedor, debes crear unha configuración de dispositivo de rede a nivel de contenedor (configuración local) co parámetro de enderezo IP, e non a nivel de perfil.

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

Neste perfil podemos ver que para todos os contedores de nova creación crearanse dous dispositivos:

• eth0 - Tipo de dispositivo nic conectado a un interruptor (ponte de rede) lxdbr0
• root - Tipo de dispositivo disk que utiliza unha piscina de almacenamento ssdpool

Creando novos perfís ^

Para usar creados previamente Piscina de almacenamento contenedores, cree un perfil de configuración ssdroot no que engadiremos un dispositivo como disk con punto de montaxe / (raíz) usando o creado previamente Piscina de almacenamento - ssdpool:

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

Do mesmo xeito, creamos un dispositivo como disk, pero neste caso usando Piscina de almacenamento - hddpool:

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

Comprobando os perfís de configuración:

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

Repositorio de imaxes ^

Os contedores créanse a partir de imaxes que son distribucións especialmente ensambladas que non teñen un núcleo Linux. Polo tanto, antes de executar o contedor, débese despregar desde esta imaxe. A fonte das imaxes é un repositorio local no que se descargan imaxes de repositorios externos.

Repositorios de imaxes remotos ^

Por defecto, LXD está configurado para recibir imaxes de tres fontes remotas:

• ubuntu: (para imaxes estables de Ubuntu)
• ubuntu-diario: (para imaxes diarias de Ubuntu)
• imaxes: (para un montón de outras distribucións)

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

Por exemplo, repositorio ubuntu: ten as seguintes imaxes:

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

Para mostrar un número limitado de columnas usamos a opción -c con parámetros dasut, e tamén limitou a lonxitude da lista co comando head.

O filtrado está dispoñible para mostrar unha lista de imaxes. O seguinte comando enumerará todas as arquitecturas de distribución dispoñibles 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        |
+------------------------------+--------------------------------------+--------------+

Repositorio local de imaxes ^

Para comezar a usar o contedor, cómpre engadir unha imaxe do repositorio global ao local local:. Agora o repositorio local está baleiro, o comando asegurarase diso lxc image list. Se o método list non especifique un repositorio, entón o repositorio local será usado por defecto - local:

lxc image list local:

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

As imaxes do repositorio xestionanse mediante os seguintes métodos:

Equipo
Descrición

imaxe lxc pseudónimo
Xestionar alias de imaxes

imaxe lxc copia
Copiar imaxes entre servidores

imaxe lxc borrar
Eliminar imaxes

imaxe lxc editar
Editar as propiedades da imaxe

imaxe lxc exportar
Exportar e descargar imaxes

imaxe lxc descargar
Importa imaxes na tenda de imaxes

imaxe lxc información
Mostra información útil sobre imaxes

imaxe lxc lista
Lista de imaxes

imaxe lxc refrescar
Actualizar imaxes

imaxe lxc Amosar
Mostra as propiedades da imaxe

Copia a imaxe no repositorio local desde o global images::

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

Image copied successfully!

Imos amosar unha lista de todas as imaxes dispoñibles actualmente no repositorio local local::

lxc image -c lfdatsu list local:

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

Configuración LXD ^

Ademais do modo interactivo, LXD tamén admite un modo de instalación de configuración non interactivo, é cando a configuración se especifica en forma de ficheiro YAML, un formato especial que permite instalar toda a configuración á vez, evitando a execución. de moitos comandos interactivos que se comentaron anteriormente neste artigo, incluíndo a configuración da rede, a creación de perfís de configuración, etc. Non cubriremos esta área aquí, podes comprobalo pola túa conta. en documentación.

Seguinte comando interactivo lxc config que veremos permítelle configurar a configuración. Por exemplo, para garantir que as imaxes descargadas ao repositorio local non se actualicen automaticamente desde os depósitos globais, podemos activar este comportamento co seguinte comando:

lxc config set images.auto_update_cached=false

Creación e xestión dun contedor ^

Para crear un contedor use o comando lxc init aos que se pasan valores репозиторий:образ e despois o ID desexado para o recipiente. O repositorio pódese especificar como local local: tamén o é calquera global. Se non se especifica o repositorio, por defecto utilízase o repositorio local para buscar a imaxe. Se a imaxe se especifica desde o repositorio global, entón a imaxe descargarase primeiro no repositorio local e despois usarase para crear o contedor.

Imos executar o seguinte comando para crear o noso primeiro contedor:

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

Vexamos as teclas de comando que usamos aquí en orde:

• alpine3 — Especifícase un alias (alias) para a imaxe que se subiu previamente ao repositorio local. Se non se creou o alias para esta imaxe, sempre podes facer referencia á imaxe pola súa Impresión dixital que se mostra na táboa.
• alp — Establece o identificador do contedor
• --storage — Esta tecla indica en cal Piscina de almacenamento crearase un contedor
• --profile — Estas chaves aplican en cascada a configuración dos perfís de configuración creados previamente ao contedor

Lanzamos o contedor, que comeza a lanzar o sistema init da distribución:

lxc start alp

Tamén podes usar o comando lxc launch que permite combinar equipos lxc init и lxc start nunha operación.

Comprobación do estado do recipiente:

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

Comprobando a configuración do contedor:

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

Na sección profiles podemos asegurarnos de que este contedor utiliza dous perfís de configuración − default и hddroot. En sección devices só podemos detectar un dispositivo xa que o dispositivo de rede foi creado a nivel de perfil default. Para ver todos os dispositivos utilizados polo contedor, cómpre engadir unha chave --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: ""

Establecer un enderezo IP estático ^

Se tentamos establecer un enderezo IP para un dispositivo de rede eth0 o equipo lxc config device set alp destinado á configuración do contedor, entón recibiremos un erro que indicará que o dispositivo non existe porque o dispositivo eth0 que é utilizado polo contedor pertence ao perfil default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Por suposto, podemos establecer un enderezo IP estático para eth0 dispositivos no perfil, pero será o mesmo para todos os contedores que utilizarán este perfil. Polo tanto, imos engadir un dispositivo dedicado ao contedor:

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

A continuación, cómpre reiniciar o recipiente:

lxc restart alp

Se observamos a configuración do contedor agora, non necesitamos usar a opción --expanded para ver o dispositivo de rede eth0, xa que o creamos a nivel de contedores e caeu en cascada sobre o mesmo dispositivo desde o 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 dun recipiente ^

Para eliminar un contedor, use o comando lxc delete, pero antes de eliminar o contedor, débese deter mediante o comando lxc stop:

lxc stop alp

lxc list

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

Despois de comprobar que o estado do recipiente se fixo PARADA, pódese eliminar de Piscina de almacenamento:

lxc delete alp

Acceso a contedores ^

Para executar comandos nun contedor directamente, evitando as conexións de rede, use o comando lxc exec que executa comandos no contedor sen iniciar o shell do sistema. Se precisa executar un comando nun shell usando patróns de shell como variables, redireccións de ficheiros (pipe), etc., entón cómpre lanzar o shell de forma explícita e pasar o comando como clave, por exemplo:

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

O comando utilizou un carácter de escape especial por carácter especial $ de xeito que a variable $HOME non se interpretou na máquina host, senón que só se interpretou dentro do contedor.

Tamén é posible iniciar o modo shell interactivo e, a continuación, finalizar a sesión executando a tecla de acceso rápido CTRL+D:

lxc exec alp -- /bin/sh

Xestión de recursos de contedores ^

En LXD, pode xestionar os recursos do contedor mediante un conxunto especial de configuración. Pódese atopar unha lista completa de parámetros de configuración do contedor en documentación.

Limitación de recursos RAM ^

Parámetro limits.memory limita a cantidade de RAM dispoñible para o contedor. O valor é un número e un de sufixos dispoñibles.

Imos establecer o límite de RAM do contedor en 256 MB:

lxc config set alp limits.memory 256MB

Ademais, hai outros parámetros para limitar a memoria:

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

Equipo lxc config show permítelle mostrar toda a configuración do contedor, incluído o límite de recursos aplicado que se estableceu:

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ímite de recursos da CPU ^

Hai varias formas de limitar os recursos da CPU. tipos de restricións:

• limit.cpu - vincula un contenedor a un ou máis núcleos de CPU
• limits.cpu.allowance - xestiona as cotas do planificador CFS cando transcorreu o límite de tempo ou o mecanismo universal de compartición de recursos da CPU cando superou a porcentaxe
• limits.cpu.priority - Prioridade do planificador cando se lles asigna a mesma porcentaxe de procesadores a varias instancias que comparten un conxunto de procesadores

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ón de espazo no disco ^

Ademais de restricións tales limits.read, limits.write tamén podemos limitar a cantidade de espazo en disco consumido polo contedor (só funciona con ZFS ou BTRFS):

lxc config device set alp root size=2GB

Despois da instalación, no parámetro devices.root.size Podemos verificar o límite establecido:

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

Para ver as cotas de disco usados ​​podemos obter desde o comando 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

A pesar de que establecemos un límite para o dispositivo raíz do contedor a 2 GB, as utilidades do sistema como df non verá esta restrición. Para iso, faremos unha pequena proba e descubriremos como funciona.

Imos crear 2 novos recipientes idénticos no mesmo Piscina de almacenamento (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         |
+------+---------+------------------+------+-----------+-----------+

Imos crear un ficheiro de 1 GB nun dos contedores:

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

Asegurémonos de que o ficheiro está creado:

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

Se buscamos no segundo contedor, comprobamos a existencia dun ficheiro na mesma localización, entón este ficheiro non estará alí, o que é de esperar, xa que os contedores créanse no seu propio. Volume de almacenamento no mesmo Piscina de almacenamento:

lxc exec alp2 -- ls -lh
total 0

Pero comparemos os valores que produce df nun e outro recipiente:

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

Dispositivo /dev/loop1 montado como a partición raíz Piscina de almacenamento que utilizan estes recipientes, polo que reparten o seu volume entre dous.

Estatística de consumo de recursos ^

Podes ver as estatísticas de consumo de recursos dun contedor usando o comando:

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

Traballando con instantáneas ^

LXD ten a capacidade de crear instantáneas e restaurar a partir delas o estado do contedor.

Para crear unha instantánea, execute o seguinte comando:

lxc snapshot alp snapshot1

O equipo lxc snapshot ningunha chave dispoñible list, polo tanto, para ver a lista de instantáneas cómpre utilizar o comando que mostra información xeral sobre o contedor:

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

Podes restaurar un contedor desde unha instantánea usando o comando lxc restore especificando o contedor para o que se realizará a restauración e o alias da instantánea:

lxc restore alp snapshot1

O seguinte comando úsase para eliminar unha instantánea. Ten en conta que a sintaxe do comando non é semellante a todas as demais; aquí tes que especificar unha barra inclinada despois do nome do contedor. Se se omite a barra inclinada, entón o comando para eliminar unha instantánea interprétase como un comando para eliminar un contedor.

lxc delete alp/snapshot1

No exemplo anterior, analizamos as chamadas instantáneas sen estado. LXD ten outro tipo de instantáneas: con estado, que garda o estado actual de todos os procesos do contedor. Hai unha serie de funcións interesantes e útiles asociadas ás instantáneas con estado.

Que máis? ^

• Hai un módulo dispoñible para os desenvolvedores de Python PyLXD que proporciona unha API para LXD

ACTUALIZACIÓN 10.04.2020/15/00 XNUMX:XNUMX: Engadida navegación

Fonte: www.habr.com