Características básicas dos sistemas de contedores LXD - Linux
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:
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:
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
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]:
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:
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:
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:
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:
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.
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:
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:
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
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
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:
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.
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:
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::
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:
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 |
+------+---------+------------------+------+-----------+--------------+
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:
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:
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:
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.
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
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 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.
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.