Permítanme comenzar explicando qué es un contenedor, es un proceso normal en la máquina host (cualquier m/c basado en Linux) con las siguientes características:
- Se siente como una máquina virtual, pero no lo es.
- Utiliza el kernel del host.
- No se puede iniciar un sistema operativo diferente.
- No puede tener sus propios módulos.
- No necesita «en eso» como PID (ID de proceso) como “1”
LXC (Contenedores Linux) se desarrolló hace mucho tiempo y es una tecnología de virtualización a nivel de sistema operativo. Esto existía desde los días de BSD y System-V Release 4 (sabores populares de Unix durante 1980-90). Pero hasta hace poco, nadie sabía cuánto nos puede ayudar a ahorrar en términos de utilización de recursos. Debido a este cambio tecnológico, todas las empresas se están moviendo hacia la adopción de la virtualización (ya sea en la nube o en contenedores Docker). Esto también ayudó a una mejor gestión de OpEX (gastos operativos) y CaPEX (Gastos de capital) costos Con esta técnica, podemos crear y ejecutar entornos virtuales de Linux múltiples y aislados en una sola máquina host de Linux (llamada host de control). LXC utiliza principalmente las funcionalidades de cgroups y espacios de nombres de Linux, que se introdujeron en la versión 2.6.24 (versión del kernel) en adelante. Paralelamente ocurrieron muchos avances en hipervisores como el de KVM, QEMU, Hiper-V, ESXi etc. Especialmente KVM (Kernel Virtual Machine), que es el núcleo del sistema operativo Linux, ayudó en este tipo de avance.
La diferencia entre LXC y LXD es que LXC es la forma original y más antigua de administrar contenedores, pero aún es compatible, todos los comandos de LXC comienzan con «lxc-“ me gusta «lxc-crear” & “lxc-info“, mientras que LXD es una nueva forma de administrar contenedores y el comando lxc se usa para todas las operaciones y administración de contenedores.
Todos sabemos que “Estibador” utiliza LXC y se desarrolló utilizando el lenguaje Go, cgroups, espacios de nombres y, finalmente, el propio kernel de Linux. Complete Docker se creó y desarrolló utilizando LXC como bloque de base básico. Docker depende completamente de la infraestructura y el hardware subyacentes y del uso del sistema operativo como medio. Sin embargo, Docker es un motor de contenedores portátil y fácil de implementar; todas sus dependencias se ejecutan mediante un contenedor virtual en la mayoría de los servidores basados en Linux. Los grupos y los espacios de nombres son los conceptos básicos para los contenedores LXC y Docker. A continuación se presenta una breve descripción de estos conceptos.
Grupos C (grupos de control)
Con Cgroups cada recurso tendrá su propia jerarquía.
- CPU, memoria, E/S, etc. tendrán su propia jerarquía de grupo de control. Las siguientes son varias características de los grupos C,
- Cada proceso está en cada nodo.
- Cada jerarquía comienza con un nodo.
- Inicialmente, todos los procesos comienzan en el nodo raíz. Por tanto, “cada nodo” equivale a “grupo de procesos”.
- Las jerarquías son independientes, por ejemplo: CPU, bloque de E/S, memoria, etc.
Como se explicó anteriormente, hay varios tipos de Cgroup que se enumeran a continuación,
1) Grupos C de memoria
a) Realiza un seguimiento de las páginas utilizadas por cada grupo.
b) Lectura/escritura/mmap de archivos desde dispositivos de bloque
c) Memoria anónima (pila, montón, etc.)
d) Cada página de memoria se carga a un grupo
e) Las páginas se pueden compartir entre varios grupos
2) Grupos C de CPU
a) Realizar un seguimiento del tiempo de CPU del sistema/usuarios
b) Seguimiento del uso por CPU
c) Permite establecer pesos
d) No se pueden establecer límites de CPU
3) Bloque IO Cgroup
a) Realizar un seguimiento de lectura/escritura (E/S)
b) Establecer acelerador (límites) para cada grupo (por dispositivo de bloque)
c) Establecer pesos reales para cada grupo (por dispositivo de bloque)
4) Grupo C de dispositivos
a) Controla lo que el grupo puede hacer en los nodos del dispositivo
b) El permiso incluye /lectura/escritura/mknode
5) Congelador grupo C
a) Permitir congelar/descongelar un grupo de procesos
b) Similar a SIGSTOP/SIGCONT
c) No puede ser detectado por los procesos.
Espacios de nombres
Los espacios de nombres proporcionan a los procesos su propia vista del sistema. Cada proceso está en el espacio de nombres de cada tipo.
Hay múltiples espacios de nombres como,
- PID: el proceso dentro de un espacio de nombres PID solo ve los procesos en el mismo espacio de nombres PID
- Net: los procesos dentro de un espacio de nombres de red determinado obtienen su propia pila de red privada.
- Mnt: los procesos pueden tener sus propios puntos «raíz» y «montaje» privados.
- Uts: tiene un contenedor con su propio nombre de host
- IPC: permite que los procesos tengan semáforos IPC propios, colas de mensajes IPC y memoria compartida
- USR – Permite mapear UID/GID
Instalación y configuración de contenedores LXD
Para tener LXD instalado en el sistema Ubuntu (18.04 LTS), podemos comenzar con la instalación de LXD usando el siguiente comando apt
[email protected]:~$ sudo apt update [email protected]:~$ sudo apt install lxd -y
Una vez que el LXD está instalado, podemos comenzar con su inicialización como se muestra a continuación (la mayoría de las veces usa las opciones predeterminadas)
[email protected]:~$ sudo lxd init
Una vez que el LXD se inicialice con éxito, ejecute el siguiente comando para verificar la información
[email protected]:~$ sudo lxc info | more
Use el siguiente comando para enumerar si hay algún contenedor descargado en nuestro host,
[email protected]:~$ sudo lxc image list +-------+-------------+--------+-------------+------+------+-------------+ | ALIAS | FINGERPRINT | PUBLIC | DESCRIPTION | ARCH | SIZE | UPLOAD DATE | +-------+-------------+--------+-------------+------+------+-------------+ [email protected]:~$
Una manera rápida y fácil de iniciar el primer contenedor en Ubuntu 18.04 (o cualquier versión de Ubuntu compatible) use el siguiente comando. El nombre del contenedor que hemos proporcionado es «shashi»
[email protected]:~$ sudo lxc launch ubuntu:18.04 shashi Creating shashi Starting shashi [email protected]:~$
Para enumerar cuáles son los contenedores LXC que están en el sistema
[email protected]:~$ sudo lxc list +--------+---------+-----------------------+-----------------------------------------------+------------+-----------+ | NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS | +--------+---------+-----------------------+-----------------------------------------------+------------+-----------+ | shashi | RUNNING | 10.122.140.140 (eth0) | fd42:49da:7c44:cebe:216:3eff:fea4:ea06 (eth0) | PERSISTENT | 0 | +--------+---------+-----------------------+-----------------------------------------------+------------+-----------+ [email protected]:~$
Otros comandos de administración de contenedores para LXD se enumeran a continuación:
Nota: En los ejemplos a continuación, shashi es el nombre de mi contenedor
¿Cómo tomar bash shell de su contenedor LXD?
[email protected]:~$ sudo lxc exec shashi bash [email protected]:~#
¿Cómo detener, iniciar y reiniciar el contenedor LXD?
[email protected]:~$ sudo lxc stop shashi [email protected]:~$ sudo lxc list +--------+---------+------+------+------------+-----------+ | NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS | +--------+---------+------+------+------------+-----------+ | shashi | STOPPED | | | PERSISTENT | 0 | +--------+---------+------+------+------------+-----------+ [email protected]:~$ [email protected]:~$ sudo lxc start shashi [email protected]:~$ sudo lxc restart shashi
¿Cómo eliminar un contenedor LXD?
[email protected]:~$ sudo lxc stop shashi [email protected]:~$ sudo lxc delete shashi [email protected]:~$ sudo lxc list +------+-------+------+------+------+-----------+ | NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS | +------+-------+------+------+------+-----------+ [email protected]:~$
¿Cómo tomar una instantánea del contenedor LXD y luego restaurarlo?
Supongamos que tenemos un contenedor pkumar basado en la imagen de centos7, así que para tomar la instantánea use lo siguiente:
[email protected]:~$ sudo lxc snapshot pkumar pkumar_snap0
Use el siguiente comando para verificar la instantánea
[email protected]:~$ sudo lxc info pkumar | grep -i Snapshots -A2 Snapshots: pkumar_snap0 (taken at 2019/08/02 19:39 UTC) (stateless) [email protected]:~$
Use el siguiente comando para restaurar el contenedor LXD desde su instantánea
Sintaxis:
$ lxc restaurar {container_name} {snapshot_name}
[email protected]:~$ sudo lxc restore pkumar pkumar_snap0 [email protected]:~$
¿Cómo eliminar la instantánea del contenedor LXD?
$ sudo lxc delete <container_name/snapshot_name>
¿Cómo establecer el límite de memoria, CPU y disco en el contenedor LXD?
Sintaxis para establecer el límite de memoria:
# lxc config set
Sintaxis para establecer el límite de CPU:
# lxc config set
Sintaxis para establecer el límite de disco:
# lxc config device set
Nota: Para establecer un límite de disco (requiere sistema de archivos btrfs o ZFS)
Establezcamos un límite de memoria y CPU en el contenedor shashi usando los siguientes comandos,
[email protected]:~$ sudo lxc config set shashi limits.memory 256MB [email protected]:~$ sudo lxc config set shashi limits.cpu 2
Instalar y configurar el contenedor LXC (comandos y operaciones)
Para instalar lxc en su sistema ubuntu, use el siguiente comando apt,
[email protected]:~$ sudo apt install lxc -y
En una versión anterior de LXC, el comando “lxc-clon” fue utilizado y luego quedó en desuso. Ahora, «lxc-copiaEl comando ” es ampliamente utilizado para la operación de clonación.
Nota: Para que funcione el comando «lxc-copy», use los siguientes pasos de instalación,
[email protected]:~$ sudo apt install lxc1 -y
Creación de contenedores de Linux usando las plantillas
LXC proporciona plantillas listas para usar para una fácil instalación de contenedores de Linux. Las plantillas generalmente se encuentran en la ruta del directorio /usr/share/lxc/templates, pero en una instalación nueva no obtendremos las plantillas, así que para descargar las plantillas en su sistema local, ejecute el siguiente comando,
[email protected]:~$ sudo apt install lxc-templates -y
Una vez que las plantillas lxc se hayan instalado correctamente, las plantillas estarán disponibles,
[email protected]:~$ sudo ls /usr/share/lxc/templates/ lxc-alpine lxc-centos lxc-fedora lxc-oci lxc-plamo lxc-sparclinux lxc-voidlinux lxc-altlinux lxc-cirros lxc-fedora-legacy lxc-openmandriva lxc-pld lxc-sshd lxc-archlinux lxc-debian lxc-gentoo lxc-opensuse lxc-sabayon lxc-ubuntu lxc-busybox lxc-download lxc-local lxc-oracle lxc-slackware lxc-ubuntu-cloud [email protected]:~$
Lancemos un contenedor usando una plantilla,
Sintaxis: lxc-create -n
[email protected]:~$ sudo lxc-create -n shashi_lxc -t ubuntu ……………………… invoke-rc.d: could not determine current runlevel invoke-rc.d: policy-rc.d denied execution of start. Current default time zone: 'Etc/UTC' Local time is now: Fri Aug 2 11:46:42 UTC 2019. Universal Time is now: Fri Aug 2 11:46:42 UTC 2019. ## # The default user is 'ubuntu' with password 'ubuntu'! # Use the 'sudo' command to run tasks as root in the container. ## ……………………………………… [email protected]:~$
Una vez que se crea la plantilla completa, podemos iniciar sesión en esta consola siguiendo los siguientes pasos
[email protected]:~$ sudo lxc-start -n shashi_lxc -d [email protected]:~$ sudo lxc-console -n shashi_lxc Connected to tty 1 Type <Ctrl+a q> to exit the console, <Ctrl+a Ctrl+a> to enter Ctrl+a itself Ubuntu 18.04.2 LTS shashi_lxc pts/0 shashi_lxc login: ubuntu Password: Last login: Fri Aug 2 12:00:35 UTC 2019 on pts/0 Welcome to Ubuntu 18.04.2 LTS (GNU/Linux 4.15.0-20-generic x86_64) To run a command as administrator (user "root"), use "sudo <command>". See "man sudo_root" for details. [email protected]_lxc:~$ free -h total used free shared buff/cache available Mem: 3.9G 23M 3.8G 112K 8.7M 3.8G Swap: 1.9G 780K 1.9G [email protected]_lxc:~$ grep -c processor /proc/cpuinfo 1 [email protected]_lxc:~$ df -h / Filesystem Size Used Avail Use% Mounted on /dev/sda1 40G 7.4G 31G 20% / [email protected]_lxc:~$
Ahora cierre sesión o salga del contenedor y regrese a la ventana de inicio de sesión de la máquina host. Con el comando lxc-ls podemos ver que se crea el contenedor shashi-lxc.
[email protected]:~$ sudo lxc-ls shashi_lxc [email protected]:~$
“lxc-ls-fEl comando «proporciona detalles con la dirección IP del contenedor y lo mismo se muestra a continuación,
[email protected]:~$ sudo lxc-ls -f NAME STATE AUTOSTART GROUPS IPV4 IPV6 UNPRIVILEGED shashi_lxc RUNNING 0 - 10.0.3.190 - false [email protected]:~$
“lxc-info -n
[email protected]:~$ sudo lxc-info -n shashi_lxc Name: shashi_lxc State: RUNNING PID: 6732 IP: 10.0.3.190 CPU use: 2.38 seconds BlkIO use: 240.00 KiB Memory use: 27.75 MiB KMem use: 5.04 MiB Link: vethQ7BVGU TX bytes: 2.01 KiB RX bytes: 9.52 KiB Total bytes: 11.53 KiB [email protected]:~$
Cómo iniciar, detener, reiniciar y eliminar contenedores LXC
$ lxc-start -n <container_name> $ lxc-stop -n <container_name> $ lxc-destroy -n <container_name>
Operación de clonación LXC
Ahora la operación de clonación principal se realizará en el contenedor LXC. Se siguen los siguientes pasos
Como se describió anteriormente, LXC ofrece la función de clonar un contenedor desde el contenedor existente, ejecutando el siguiente comando para clonar un contenedor «shashi_lxc» existente en un nuevo contenedor «shashi_lxc_clone».
Nota: Tenemos que asegurarnos de que antes de comenzar la operación de clonación, primero tenemos que detener el contenedor existente usando el «parada lxc” comando.
[email protected]:~$ sudo lxc-stop -n shashi_lxc [email protected]:~$ sudo lxc-copy -n shashi_lxc -N shashi_lxc_clone [email protected]:~$ sudo lxc-ls shashi_lxc shashi_lxc_clone [email protected]:~$
Ahora inicie el contenedor clonado
[email protected]:~$ sudo lxc-start -n shashi_lxc_clone [email protected]:~$ sudo lxc-ls -f NAME STATE AUTOSTART GROUPS IPV4 IPV6 UNPRIVILEGED shashi_lxc STOPPED 0 - - - false shashi_lxc_clone RUNNING 0 - 10.0.3.201 - false [email protected]:~$
Con el conjunto de comandos anterior, se realiza la operación de clonación y se crea el nuevo clon «shashi_lxc_clone». Podemos iniciar sesión en esta consola de contenedores lxc con los pasos a continuación,
[email protected]:~$ sudo lxc-console -n shashi_lxc_clone Connected to tty 1 Type <Ctrl+a q> to exit the console, <Ctrl+a Ctrl+a> to enter Ctrl+a itself Ubuntu 18.04.2 LTS shashi_lxc pts/0 shashi_lxc login:
Configuración y comandos de la red LXC
Podemos adjuntarnos al contenedor recién creado, pero para iniciar sesión de forma remota en este contenedor usando SSH o cualquier otro medio, tenemos que hacer algunos cambios de configuración mínimos como se explica a continuación,
[email protected]:~$ sudo lxc-attach -n shashi_lxc_clone [email protected]_lxc:/# [email protected]_lxc:/# useradd -m shashi [email protected]_lxc:/# passwd shashi Enter new UNIX password: Retype new UNIX password: passwd: password updated successfully [email protected]_lxc:/#
Primero instale el servidor ssh usando el siguiente comando para que se pueda establecer una conexión «ssh» fluida.
[email protected]_lxc:/# apt install openssh-server -y
Ahora obtenga la dirección IP del contenedor lxc existente usando el siguiente comando,
[email protected]_lxc:/# ip addr show eth0|grep inet inet 10.0.3.201/24 brd 10.0.3.255 scope global dynamic eth0 inet6 fe80::216:3eff:fe82:e251/64 scope link [email protected]_lxc:/#
Desde la máquina host con una nueva ventana de consola, use el siguiente comando para conectarse a este contenedor a través de ssh
[email protected]:~$ ssh 10.0.3.201 [email protected]'s password: $
Ahora, hemos iniciado sesión en un contenedor usando la sesión ssh.
Comandos relacionados con el proceso LXC
[email protected]:~$ ps aux|grep lxc|grep -v grep
Operación de instantáneas LXC
La creación de instantáneas es una de las operaciones principales que ayudará a tomar una instantánea de un momento dado de las imágenes del contenedor lxc. Estas mismas imágenes instantáneas se pueden usar más tarde para un uso posterior.
[email protected]:~$ sudo lxc-stop -n shashi_lxc [email protected]:~$ sudo lxc-snapshot -n shashi_lxc [email protected]:~$
La ruta de la instantánea se puede ubicar usando el siguiente comando.
[email protected]:~$ sudo lxc-snapshot -L -n shashi_lxc snap0 (/var/lib/lxc/shashi_lxc/snaps) 2019:08:02 20:28:49 [email protected]:~$
Conclusión:
Los contenedores LXC, LinuX son una de las primeras tecnologías de contenedores. Comprender los conceptos y aprender sobre LXC ayudará a comprender mejor cualquier otro contenedor como Docker Containers. Este artículo ha proporcionado información más profunda sobre Cgroup y los espacios de nombres, que también son conceptos muy necesarios para una mejor comprensión de los contenedores y similares. Muchas de las operaciones de LXC, como clonación, creación de instantáneas, operación de red, etc., están cubiertas con ejemplos de línea de comandos.