LXD es el administrador de contenedores del sistema de próxima generación, por lo que dice fuente. Ofrece una interfaz de usuario similar a la de las máquinas virtuales, pero en su lugar utiliza contenedores de Linux.

Núcleo LXD es un demonio privilegiado (un servicio que se ejecuta con derechos de root) que proporciona una API REST a través de un socket Unix local, así como a través de la red si está instalada la configuración adecuada. Los clientes, como la herramienta de línea de comandos proporcionada con LXD, realizan solicitudes a través de esta API REST. Esto significa que ya sea que acceda a un host local o remoto, todo funciona igual.

En este artículo no nos detendremos en los conceptos de LXD, no consideraremos todas las capacidades disponibles descritas en la documentación, incluida la reciente implementación en las últimas versiones de LXD de soporte para máquinas virtuales QEMU en paralelo con contenedores. En cambio, aprenderemos solo los conceptos básicos de la administración de contenedores: configurar grupos de almacenamiento, redes, ejecutar un contenedor, aplicar límites de recursos y cómo usar instantáneas para que pueda obtener una comprensión básica de LXD y usar contenedores en Linux.

Para obtener información completa, consulte la fuente oficial:

• Sitio web del desarrollador
• Документация
• Foro

Navegación

• Instalación LXD
  • Instalación de LXD en distribuciones de Ubuntu
  • Instalación de LXD en distribuciones Arch Linux
• Almacenamiento LXD (Almacenamiento)
• Inicializando LXD
  • Seleccionar un sistema de archivos para el grupo de almacenamiento
  • Inicializando la red y el grupo de almacenamiento usando el asistente
  • Crear un grupo de almacenamiento adicional
    • Aumentar el tamaño del grupo de almacenamiento
    • Inserción automática de un archivo loopback en la ranura de un dispositivo loopback
  • Seguridad. Privilegios de contenedor
  • Crear un conmutador de red virtual
  • Perfil de configuración
    • Editando tu perfil
    • Creando nuevos perfiles
  • Repositorio de imágenes
    • Repositorios de imágenes remotos
    • Repositorio de imágenes local
  • Configuración LXD
• Crear y gestionar un contenedor
  • Configurar una dirección IP estática
  • Quitar un contenedor
  • Acceso a contenedores
  • Gestión de recursos de contenedores
    • Limitación de recursos de RAM
    • límite de recursos de CPU
    • Limitación de espacio en disco
    • Estadísticas de consumo de recursos
  • Trabajar con instantáneas

Instalación LXD ^

Instalación de LXD en distribuciones de Ubuntu ^

En el paquete de distribución Ubuntu 19.10 lxd tiene una transmisión en paquete rápido:

apt search lxd

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

Esto significa que se instalarán dos paquetes a la vez, uno como paquete del sistema y el otro como paquete instantáneo. La instalación de dos paquetes en un sistema puede crear algún problema en el que el paquete del sistema puede quedar huérfano si el administrador de paquetes snap elimina el paquete snap.

encontrar paquete lxd en el repositorio snap puedes usar el siguiente 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

Al ejecutar el comando list Puedes asegurarte de que el paquete lxd aún no instalado:

snap list

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

A pesar de que LXD es un paquete instantáneo, debe instalarse a través del paquete del sistema. lxd, que creará el grupo correspondiente en el sistema, las utilidades necesarias en /usr/bin etcétera

sudo apt update
sudo apt install lxd

Asegurémonos de que el 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 distribuciones Arch Linux ^

Para instalar el paquete LXD en el sistema, necesita ejecutar los siguientes comandos, el primero actualizará la lista de paquetes en el sistema disponibles en el repositorio, el segundo instalará directamente el paquete:

sudo pacman -Syyu && sudo pacman -S lxd

Después de instalar el paquete, para que un usuario normal pueda administrar LXD, debe agregarlo al grupo del sistema. lxd:

sudo usermod -a -G lxd user1

Asegurémonos de que el usuario user1 añadido al grupo lxd:

id -Gn user1

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

Si el grupo lxd no está visible en la lista, entonces necesita activar la sesión de usuario nuevamente. Para hacer esto, debe cerrar sesión e iniciar sesión con el mismo usuario.

Activar en systemd cargando el servicio LXD al iniciar el sistema:

sudo systemctl enable lxd

Comencemos el servicio:

sudo systemctl start lxd

Comprobando el estado del servicio:

sudo systemctl status lxd

Almacenamiento LXD (Almacenamiento) ^

Antes de que comience la inicialización, debemos comprender cómo está organizado lógicamente el almacenamiento en LXD.

Almacenamiento (Almacenamiento) состоит de uno o más Grupo de almacenamiento que utiliza uno de los sistemas de archivos compatibles, como ZFS, BTRFS, LVM o directorios normales. Cada Grupo de almacenamiento se divide en volúmenes (Volumen de almacenamiento) que contienen imágenes, contenedores o datos para otros fines.

• Imágenes - Estas son distribuciones especialmente ensambladas sin el kernel de Linux y disponibles en fuentes externas.
• contenedores - estas son distribuciones implementadas a partir de imágenes, listas para usar
• Instantáneas - estas son instantáneas del estado de los contenedores a los que puede regresar

Para administrar el almacenamiento en LXD, use el comando lxc storage un certificado que puede obtener especificando la clave - lxc storage --help

El siguiente comando muestra una lista de todos Grupo de almacenamiento en almacenamiento 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 una lista de todos Volumen de almacenamiento en el seleccionado Grupo de almacenamiento sirve al 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       |
+-----------+----------------------------------+-------------+---------+

Además, si por Grupo de almacenamiento Al crear, se seleccionó el sistema de archivos BTRFS, luego obtenga una lista Volumen de almacenamiento o subvolúmenes en la interpretación BTRFS, puede utilizar el conjunto de herramientas de este sistema de archivos:

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

Inicializando LXD ^

Antes de crear y utilizar contenedores, debe realizar una inicialización general de LXD que crea y configura la red y el almacenamiento. Esto se puede hacer manualmente usando comandos de cliente estándar que están disponibles en la lista llamando al comando lxc --help o usando el asistente de inicialización lxd init respondiendo algunas preguntas.

Seleccionar un sistema de archivos para el grupo de almacenamiento ^

Durante la inicialización, LXD hace varias preguntas, incluida la determinación del tipo de sistema de archivos predeterminado Grupo de almacenamiento. De forma predeterminada, se selecciona el sistema de archivos BTRFS. Será imposible cambiar a otro FS después de la creación.. Para seleccionar un FS se sugiere tabla de comparación de características:

Feature
Directorio
Btrfs
LVM
ZFS
CEPH

Almacenamiento de imágenes optimizado
no
si
si
si
si

Creación de instancia optimizada
no
si
si
si
si

Creación de instantáneas optimizada
no
si
si
si
si

Transferencia de imágenes optimizada
no
si
no
si
si

Transferencia de instancia optimizada
no
si
no
si
si

Copiar en escrito
no
si
si
si
si

Basado en bloques
no
no
si
no
si

Clonación instantánea
no
si
si
si
si

Controlador de almacenamiento utilizable dentro de un contenedor
si
si
no
no
no

Restaurar desde instantáneas más antiguas (no las más recientes)
si
si
si
no
si

Cuotas de almacenamiento
Sí(*)
si
si
si
no

Inicializando la red y el grupo de almacenamiento usando el asistente ^

El siguiente comando que veremos sugiere configurar los componentes principales de LXD respondiendo preguntas simples usando el asistente de inicialización.

Ejecutar comando lxc init e ingrese las respuestas a las preguntas después de los dos puntos como se muestra en el siguiente ejemplo o cámbielas según sus condiciones:

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

Crear un grupo de almacenamiento adicional ^

En el paso anterior creamos Grupo de almacenamiento que recibió el nombre ssdpool y cuyo archivo se encuentra en mi sistema en /var/lib/lxd/disks/ssdpool.img. Esta dirección del sistema de archivos corresponde a la unidad SSD física de mi PC.

Las siguientes acciones, para ampliar la comprensión del papel desempeñado por Grupo de almacenamiento en el repositorio, crearemos un segundo Grupo de almacenamiento que estará ubicado físicamente en un tipo de disco diferente, HDD. El problema es que LXD no te permite crear Grupo de almacenamiento fuera de dirección /var/lib/lxd/disks/ e incluso los enlaces simbólicos no funcionarán, ver la respuesta del desarrollador. Podemos evitar esta limitación durante la inicialización/formateo. Grupo de almacenamiento especificando el valor como un dispositivo de bloque en lugar de la ruta al archivo de loopback especificando esto en la clave source.

Entonces, antes de crear Grupo de almacenamiento debe definir un archivo de bucle invertido o una partición existente en su sistema de archivos que utilizará. Para ello crearemos y utilizaremos un archivo cuyo tamaño limitaremos a 10GB:

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

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

Conectemos el archivo loopback a un dispositivo loopback gratuito:

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

/dev/loop1

gracias a la llave --show Al ejecutar el comando se devuelve a la pantalla el nombre del dispositivo al que está conectado nuestro archivo loopback. Si es necesario, podemos mostrar una lista de todos los dispositivos ocupados de este tipo para asegurarnos de que nuestras acciones 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

En la lista puede encontrar que el dispositivo tiene /dev/loop1 archivo de bucle invertido incluido /mnt/work/lxd/hddpool.img, y en el dispositivo /dev/loop0 archivo de bucle invertido incluido /var/lib/lxd/disks/ssdpool.img que corresponde al valor predeterminado Grupo de almacenamiento.

El siguiente comando crea uno nuevo. Grupo de almacenamiento en LXD según el archivo loopback que acabamos de preparar. LXD formateará el archivo loopback /mnt/work/lxd/hddpool.img en el dispositivo /dev/loop1 para el sistema de archivos BTRFS:

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

Mostremos una lista de todos Grupo de almacenamiento 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       |
+---------+-------------+--------+--------------------------------+---------+

Aumentar el tamaño del grupo de almacenamiento ^

Después de la creación Grupo de almacenamiento, si es necesario, se puede ampliar. Para Grupo de almacenamiento Según el sistema de archivos BTRFS, ejecute los siguientes 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 de un archivo loopback en la ranura de un dispositivo loopback ^

Tenemos un pequeño problema, al reiniciar el sistema host, el archivo /mnt/work/lxd/hddpool.img "saldrá volando" del dispositivo /dev/loop1 y el servicio LXD fallará al cargar porque no lo verá en este dispositivo. Para resolver este problema, necesita crear un servicio del sistema que insertará este archivo en el dispositivo. /dev/loop1 cuando se inicia el sistema host.

Vamos a crear unidad Tipo de archivo de coches в /etc/systemd/system/ para el 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 el servicio:

sudo systemctl enable lxd-hddpool

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

Después de reiniciar el sistema host, verificamos el estado del servicio:

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

A partir del resultado podemos verificar que el estado del servicio es lector activo, a pesar de que se completó la ejecución de nuestro script desde un comando, la opción nos permitió hacer esto RemainAfterExit=true.

Seguridad. Privilegios de contenedor ^

Dado que todos los procesos del contenedor en realidad se ejecutan de forma aislada en el sistema host utilizando su kernel, para proteger aún más el acceso de los procesos del contenedor al sistema host, LXD ofrece privilegios de proceso, donde:

• Contenedores privilegiados - estos son contenedores en los que los procesos con UID y GID corresponden al mismo propietario que en el sistema host. Por ejemplo, un proceso que se ejecuta en un contenedor con un UID de 0 tiene los mismos derechos de acceso que un proceso en el sistema host con un UID de 0. En otras palabras, el usuario raíz en el contenedor tiene todos los derechos no solo en el contenedor, sino también en el sistema host si puede salir del espacio de nombres aislado del contenedor.

• Contenedores sin privilegios - estos son contenedores en los que los procesos pertenecen al propietario del UID y GID con un número de 0 a 65535, pero para el sistema host el propietario está enmascarado utilizando los bits SubUID y SubGID agregados, respectivamente. Por ejemplo, un usuario con UID=0 en un contenedor será visto en el sistema host como SubUID + UID. Esto protege el sistema host porque si algún proceso en el contenedor puede escapar de su espacio de nombres aislado, solo puede comunicarse con el sistema host como un proceso con un UID/GID desconocido y muy alto.

De forma predeterminada, los contenedores recién creados tienen un estado sin privilegios y, por lo tanto, debemos definir un SubUID y un SubGID.

Creemos dos archivos de configuración en los que configuraremos la máscara para SubUID y SubGID, respectivamente:

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

Para aplicar los cambios, se debe reiniciar el servicio LXD:

sudo systemctl restart lxd

Crear un conmutador de red virtual ^

Dado que previamente inicializamos la red usando el asistente de inicialización lxd init y creó un dispositivo de red lxdbr0, luego en esta sección simplemente nos familiarizaremos con las redes en LXD y cómo crear un conmutador virtual (puente) usando el comando del cliente.

El siguiente diagrama demuestra cómo un conmutador (puente) conecta el host y los contenedores en una red:

Los contenedores pueden comunicarse a través de una red con otros contenedores o con el host en el que se sirven estos contenedores. Para hacer esto, necesita vincular las tarjetas de red virtuales de los contenedores con un conmutador virtual. Primero crearemos un conmutador y las interfaces de red del contenedor se vincularán en los capítulos siguientes, después de que se haya creado el contenedor.

El siguiente comando crea un conmutador con una subred 10.0.5.0/24 y dirección IPv4 10.0.5.1/24, y también incluye ipv4.nat para que los contenedores puedan acceder a Internet a través del host utilizando el servicio NAT:

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

Comprobando la lista de dispositivos de red disponibles en LXD:

lxc network list

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

También puede verificar que se haya creado un dispositivo de red utilizando la herramienta estándar de la distribución de 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ón ^

Cada contenedor en LXD tiene su propia configuración y puede extenderla con configuraciones declaradas globalmente llamadas perfiles de configuración. La aplicación de perfiles de configuración a un contenedor tiene un modelo en cascada; el siguiente ejemplo lo demuestra:

En este ejemplo, se han creado tres perfiles en el sistema LXD: default, hddpool и hostfs. Los tres perfiles se aplican a un contenedor que tiene una configuración local (área gris). Perfil default tiene un dispositivo root que tiene un parametro pool es igual a ssdpool, pero gracias al modelo de aplicación de configuración en cascada, podemos aplicar un perfil al contenedor hddpool que tiene un parametro pool anulará el mismo parámetro del perfil default y el contenedor recibirá la configuración del dispositivo root con parámetro pool igual hddpooly el perfil hostfs simplemente agrega un nuevo dispositivo al contenedor.

Para ver la lista de perfiles de configuración disponibles, utilice el siguiente comando:

lxc profile list

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

Se puede obtener una lista completa de comandos disponibles para trabajar con un perfil agregando la clave --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 tu perfil ^

Perfil de configuración predeterminado default no tiene una configuración de tarjeta de red para el contenedor y todos los contenedores recién creados no tienen una red, para ellos es necesario crear dispositivos de red locales (dedicados) con un comando separado, pero podemos crear un dispositivo de red global en la configuración perfil que se compartirá entre todos los contenedores que utilicen este perfil. De esta manera, inmediatamente después del comando de crear un nuevo contenedor, tendrán una red con acceso a la red. Al mismo tiempo, no hay restricciones, siempre podremos crear un dispositivo de red local más adelante si es necesario.

El siguiente comando agregará el dispositivo al perfil de configuración. eth0 типа nic conectado a la red lxdbr0:

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

Es importante tener en cuenta que, dado que agregamos el dispositivo al perfil de configuración, si especificamos una dirección IP estática en el dispositivo, todos los contenedores que usarán este perfil compartirán la misma dirección IP. Si es necesario crear un contenedor con una dirección IP estática asignada para el contenedor, entonces debe crear una configuración de dispositivo de red a nivel de contenedor (configuración local) con el parámetro de dirección IP, y no a nivel de perfil.

Comprobemos 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 este perfil podemos ver que para todos los contenedores recién creados se crearán dos dispositivos:

• eth0 - Tipo de dispositivo nic conectado a un conmutador (puente de red) lxdbr0
• root - Tipo de dispositivo disk que utiliza un grupo de almacenamiento ssdpool

Creando nuevos perfiles ^

Para utilizar creado previamente Grupo de almacenamiento contenedores, crear un perfil de configuración ssdroot en el que agregaremos un dispositivo como disk con punto de montaje / (root) usando el creado previamente Grupo de almacenamiento - ssdpool:

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

Del mismo modo, creamos un dispositivo como disk, pero en este caso usando Grupo de almacenamiento - hddpool:

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

Comprobando perfiles 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 imágenes ^

Los contenedores se crean a partir de imágenes que son distribuciones especialmente ensambladas que no tienen un kernel de Linux. Por lo tanto, antes de ejecutar el contenedor, se debe implementar desde esta imagen. La fuente de imágenes es un repositorio local al que se descargan imágenes desde repositorios externos.

Repositorios de imágenes remotos ^

De forma predeterminada, LXD está configurado para recibir imágenes de tres fuentes remotas:

• ubuntu: (para imágenes estables de Ubuntu)
• ubuntu-diario: (para imágenes diarias de Ubuntu)
• imágenes: (para muchas otras distribuciones)

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 ejemplo, repositorio ubuntu: tiene las siguientes imágenes:

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 utilizamos la opción -c con parametros dasut, y también limitó la longitud de la lista con el comando head.

El filtrado está disponible para mostrar una lista de imágenes. El siguiente comando enumerará todas las arquitecturas de distribución disponibles. alpinolinux:

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 de imágenes local ^

Para comenzar a usar el contenedor, debe agregar una imagen del repositorio global al local local:. Ahora el repositorio local está vacío, el comando se asegurará de esto lxc image list. Si el método list Si no especifica un repositorio, se utilizará el repositorio local de forma predeterminada. local:

lxc image list local:

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

Las imágenes del repositorio se gestionan mediante los siguientes métodos:

Equipo
Descripción

imagen lxc alias
Administrar alias de imágenes

imagen lxc copia
Copiar imágenes entre servidores

imagen lxc borrar
Eliminar imágenes

imagen lxc editar
Editar propiedades de imagen

imagen lxc exportar
Exportar y descargar imágenes

imagen lxc importar
Importar imágenes al almacén de imágenes.

imagen lxc info
Mostrar información útil sobre imágenes

imagen lxc lista
Lista de imágenes

imagen lxc refrescar
Actualizar imágenes

imagen lxc Mostrar
Mostrar propiedades de imagen

Copie la imagen al repositorio local desde el global images::

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

Image copied successfully!

Mostremos una lista de todas las imágenes disponibles actualmente en el 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 ^

Además del modo interactivo, LXD también admite un modo de instalación de configuración no interactivo, esto es cuando la configuración se especifica en forma de archivo YAML, un formato especial que le permite instalar toda la configuración a la vez, sin pasar por la ejecución. de muchos comandos interactivos que se discutieron anteriormente en este artículo, incluida la configuración de red, la creación de perfiles de configuración, etc. No cubriremos esta área aquí, puedes comprobarla por tu cuenta. en la documentación.

Siguiente comando interactivo lxc config que veremos le permite establecer la configuración. Por ejemplo, para garantizar que las imágenes descargadas en el repositorio local no se actualicen automáticamente desde los repositorios globales, podemos habilitar este comportamiento con el siguiente comando:

lxc config set images.auto_update_cached=false

Crear y gestionar un contenedor ^

Para crear un contenedor use el comando lxc init a la que se pasan valores репозиторий:образ y luego el ID deseado para el contenedor. El repositorio se puede especificar como local. local: también lo es cualquier global. Si no se especifica el repositorio, de forma predeterminada se utiliza el repositorio local para buscar la imagen. Si la imagen se especifica desde el repositorio global, la imagen primero se descargará al repositorio local y luego se usará para crear el contenedor.

Ejecutemos el siguiente comando para crear nuestro primer contenedor:

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

Veamos las teclas de comando que usamos aquí en orden:

• alpine3 — Se especifica un alias (alias) para la imagen que se cargó previamente en el repositorio local. Si el alias no se creó para esta imagen, siempre puede hacer referencia a la imagen por su Huella dactilar que se muestra en la tabla.
• alp — Establece el identificador del contenedor.
• --storage — Esta clave indica en qué Grupo de almacenamiento se creará un contenedor
• --profile — Estas claves aplican en cascada la configuración de los perfiles de configuración creados previamente al contenedor.

Lanzamos el contenedor, que comienza a lanzar el sistema init de la distribución:

lxc start alp

También puedes usar el comando lxc launch que te permite combinar equipos lxc init и lxc start en una sola operación.

Comprobando el estado del contenedor:

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

Comprobando la configuración del contenedor:

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

En la sección profiles Podemos asegurarnos de que este contenedor utilice dos perfiles de configuración: default и hddroot. En la sección devices solo podemos detectar un dispositivo porque el dispositivo de red se creó en el nivel de perfil default. Para ver todos los dispositivos utilizados por el contenedor, debe agregar una clave --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: ""

Configurar una dirección IP estática ^

Si intentamos establecer una dirección IP para un dispositivo de red eth0 el equipo lxc config device set alp destinado a la configuración del contenedor, entonces recibiremos un error que informará que el dispositivo no existe porque el dispositivo eth0 que es utilizado por el contenedor pertenece al perfil default:

lxc config device set alp eth0 ipv4.address 10.0.5.5

Error: The device doesn't exist

Por supuesto, podemos establecer una dirección IP estática para eth0 dispositivos en el perfil, pero será el mismo para todos los contenedores que usarán este perfil. Por tanto, agreguemos un dispositivo dedicado al contenedor:

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

Luego necesitas reiniciar el contenedor:

lxc restart alp

Si miramos la configuración del contenedor ahora, no necesitamos usar la opción --expanded para ver el dispositivo de red eth0, ya que lo creamos a nivel de contenedor y se puso en cascada sobre el mismo dispositivo desde el 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: ""

Quitar un contenedor ^

Para eliminar un contenedor, use el comando lxc delete, pero antes de retirar el contenedor, se debe detener usando el comando lxc stop:

lxc stop alp

lxc list

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

Después de haber comprobado que el estado del contenedor ha pasado a ser DETENIDO, se puede quitar de Grupo de almacenamiento:

lxc delete alp

Acceso a contenedores ^

Para ejecutar comandos en un contenedor directamente, sin pasar por las conexiones de red, use el comando lxc exec que ejecuta comandos en el contenedor sin iniciar el shell del sistema. Si necesita ejecutar un comando en un shell usando patrones de shell como variables, redirecciones de archivos (tubería), etc., entonces necesita iniciar explícitamente el shell y pasar el comando como una clave, por ejemplo:

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

El comando utilizó un carácter de escape especial. para carácter especial $ para que la variable $HOME no se interpretó en la máquina host, sino que se interpretó solo dentro del contenedor.

También es posible iniciar el modo shell interactivo y luego finalizar la sesión ejecutando la tecla de acceso rápido. CTRL+D:

lxc exec alp -- /bin/sh

Gestión de recursos de contenedores ^

En LXD, puede administrar los recursos del contenedor utilizando un conjunto especial de configuración. Puede encontrar una lista completa de los parámetros de configuración del contenedor. en la documentación.

Limitación de recursos de RAM ^

Parámetro limits.memory limita la cantidad de RAM disponible para el contenedor. El valor es un número y uno de sufijos disponibles.

Establezcamos el límite de RAM del contenedor en 256 MB:

lxc config set alp limits.memory 256MB

Además, existen otros parámetros para limitar la memoria:

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

Equipo lxc config show le permite mostrar toda la configuración del contenedor, incluido el límite de recursos aplicado que se estableció:

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 de CPU ^

Hay varias formas de limitar los recursos de la CPU. tipos de restricciones:

• limit.cpu - vincula un contenedor a uno o más núcleos de CPU
• limits.cpu.allowance - gestiona las cuotas del programador CFS cuando ha pasado el límite de tiempo o el mecanismo universal de intercambio de recursos de CPU cuando ha pasado el porcentaje
• limits.cpu.priority - prioridad del programador cuando a varias instancias que comparten un conjunto de procesadores se les asigna el mismo porcentaje 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 espacio en disco ^

Además de restricciones como limits.read, limits.write También podemos limitar la cantidad de espacio en disco consumido por el contenedor (solo funciona con ZFS o BTRFS):

lxc config device set alp root size=2GB

Después de la instalación, en el parámetro devices.root.size Podemos verificar el 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 las cuotas de disco utilizadas podemos obtenerlas desde el 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 hemos establecido un límite de 2 GB para el dispositivo raíz del contenedor, las utilidades del sistema como df No verá esta restricción. Para ello realizaremos una pequeña prueba y descubriremos cómo funciona.

Creemos 2 nuevos contenedores idénticos en el mismo Grupo de almacenamiento (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         |
+------+---------+------------------+------+-----------+-----------+

Creemos un archivo de 1 GB en uno de los contenedores:

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

Asegurémonos de que el archivo esté creado:

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

Si buscamos en el segundo contenedor, comprobamos la existencia de un archivo en la misma ubicación, entonces este archivo no estará allí, lo cual es de esperar, ya que los contenedores se crean por su cuenta. Volumen de almacenamiento en el mismo Grupo de almacenamiento:

lxc exec alp2 -- ls -lh
total 0

Pero comparemos los valores que produce. df en uno y otro contenedor:

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 la partición raíz Grupo de almacenamiento que utilizan estos contenedores, por lo que reparten su volumen entre dos.

Estadísticas de consumo de recursos ^

Puede ver las estadísticas de consumo de recursos para un contenedor usando el 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

Trabajar con instantáneas ^

LXD tiene la capacidad de crear instantáneas y restaurar el estado del contenedor a partir de ellas.

Para crear una instantánea, ejecute el siguiente comando:

lxc snapshot alp snapshot1

Equipo lxc snapshot no hay clave disponible listPor lo tanto, para ver la lista de instantáneas, debe usar el comando que muestra información general sobre el contenedor:

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

Puede restaurar un contenedor desde una instantánea usando el comando lxc restore especificando el contenedor para el cual se realizará la restauración y el alias de la instantánea:

lxc restore alp snapshot1

El siguiente comando se utiliza para eliminar una instantánea. Tenga en cuenta que la sintaxis del comando no es similar a la de todos los demás; aquí debe especificar una barra diagonal después del nombre del contenedor. Si se omite la barra diagonal, entonces el comando para eliminar una instantánea se interpreta como un comando para eliminar un contenedor.

lxc delete alp/snapshot1

En el ejemplo anterior, analizamos las llamadas instantáneas sin estado. LXD tiene otro tipo de instantáneas: con estado, que guarda el estado actual de todos los procesos en el contenedor. Hay una serie de características interesantes y útiles asociadas con las instantáneas con estado.

Que mas ^

• Hay un módulo disponible para desarrolladores de Python PyLXD que proporciona una API para LXD

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

Fuente: habr.com