Virtualización de Linux: Contenedores de Linux (lxc)

Requisitos previos: 
 

• Anteriormente hablé sobre chroot jails y limitación de recursos usando cgroups . 
  Si aún no los ha leído, le sugiero encarecidamente que los revise antes de continuar.
• https://www.youtube.com/watch?v=sK5i-N34im8 
  Una muy buena presentación del equipo de Docker. 
  Esto refrescará algunos de los conceptos aprendidos anteriormente. Este video actúa como puente entre este artículo y el tema discutido en artículos anteriores mencionados anteriormente. Esto explica cómo los contenedores son útiles y cómo chroots y cgroups se usan internamente.

Introducción a la virtualización 
La virtualización a nivel de sistema operativo es un método de virtualización de servidores en el que el núcleo de un sistema operativo permite la existencia de varias instancias de espacio de usuario aisladas, en lugar de una sola. Tales instancias, que a veces se denominan contenedores, contenedores de software, motores de virtualización (VE) o cárceles (FreeBSD jail o chroot jail), pueden verse y sentirse como un servidor real desde el punto de vista de sus propietarios y usuarios. 

La definición anterior resume la idea general sobre los contenedores, pero para ser más precisos, las máquinas virtuales tradicionales usaban algo llamado hipervisor que se ejecuta sobre el kernel. Este hipervisor proporciona virtualización a las aplicaciones que se ejecutan en él al monitorear su uso de recursos y patrones de acceso. Esto provoca una gran sobrecarga que resulta en una pérdida innecesaria de rendimiento. Por otro lado, la virtualización a nivel del sistema operativo funciona de manera diferente. Utiliza espacios de nombres y cgroups para restringir las capacidades de la aplicación, incluido el uso de recursos. Esta es una característica proporcionada por el kernel de Linux. Esto casi no tiene gastos generales. 
 

Este método es tan efectivo que Docker está utilizando estos contenedores internamente para proporcionar ese entorno aislado que es muy útil para implementar múltiples sistemas integrados. Incluso están obligados a crear su propia biblioteca de contenedores. Google tiene sus propios servicios ejecutándose en contenedores en hardware compartido. 

Instalación:

Para instalar lxc en Ubuntu, 
 

$ sudo apt-get install lxc lxctl lxc-templates

Este paquete instala los requisitos de LXC, algunas plantillas y también configura la estructura de red para los contenedores. 
Ejecute lxc-checkconfig para verificar si la configuración del kernel está lista. 

$ sudo lxc-checkconfig
    Kernel configuration not found at /proc/config.gz; searching...
    Kernel configuration found at /boot/config-4.4.0-24-generic
    --- Namespaces ---
    Namespaces: enabled
    Utsname namespace: enabled
    Ipc namespace: enabled
    Pid namespace: enabled
    User namespace: enabled
    Network namespace: enabled
    Multiple /dev/pts instances: enabled

    --- Control groups ---
    Cgroup: enabled
    Cgroup clone_children flag: enabled
    Cgroup device: enabled
    Cgroup sched: enabled
    Cgroup cpu account: enabled
    Cgroup memory controller: enabled
    Cgroup cpuset: enabled

    --- Misc ---
    Veth pair device: enabled
    Macvlan: enabled
    Vlan: enabled
    Bridges: enabled
    Advanced netfilter: enabled
    CONFIG_NF_NAT_IPV4: enabled
    CONFIG_NF_NAT_IPV6: enabled
    CONFIG_IP_NF_TARGET_MASQUERADE: enabled
    CONFIG_IP6_NF_TARGET_MASQUERADE: enabled
    CONFIG_NETFILTER_XT_TARGET_CHECKSUM: enabled
    FUSE (for use with lxcfs): enabled

    --- Checkpoint/Restore ---
    checkpoint restore: enabled
    CONFIG_FHANDLE: enabled
    CONFIG_EVENTFD: enabled
    CONFIG_EPOLL: enabled
    CONFIG_UNIX_DIAG: enabled
    CONFIG_INET_DIAG: enabled
    CONFIG_PACKET_DIAG: enabled
    CONFIG_NETLINK_DIAG: enabled
    File capabilities: enabled

Nota: antes de iniciar un kernel nuevo, puede verificar su uso de configuración: CONFIG=/path/to/config /usr/bin/lxc-checkconfig 

También debería ver el resultado algo similar al anterior. 
lxc proporciona muchas plantillas listas, que son realmente útiles para una implementación rápida. 

$ ls -l /usr/share/lxc/templates/
    total 404
    -rwxr-xr-x 1 root root 12973 May 18 14:48 lxc-alpine
    -rwxr-xr-x 1 root root 13713 May 18 14:48 lxc-altlinux
    -rwxr-xr-x 1 root root 11090 May 18 14:48 lxc-archlinux
    -rwxr-xr-x 1 root root 12159 May 18 14:48 lxc-busybox
    -rwxr-xr-x 1 root root 29503 May 18 14:48 lxc-centos
    -rwxr-xr-x 1 root root 10374 May 18 14:48 lxc-cirros
    -rwxr-xr-x 1 root root 19732 May 18 14:48 lxc-debian
    -rwxr-xr-x 1 root root 17890 May 18 14:48 lxc-download
    -rwxr-xr-x 1 root root 49600 May 18 14:48 lxc-fedora
    -rwxr-xr-x 1 root root 28384 May 18 14:48 lxc-gentoo
    -rwxr-xr-x 1 root root 13868 May 18 14:48 lxc-openmandriva
    -rwxr-xr-x 1 root root 15932 May 18 14:48 lxc-opensuse
    -rwxr-xr-x 1 root root 41720 May 18 14:48 lxc-oracle
    -rwxr-xr-x 1 root root 11205 May 18 14:48 lxc-plamo
    -rwxr-xr-x 1 root root 19250 May 18 14:48 lxc-slackware
    -rwxr-xr-x 1 root root 26862 May 18 14:48 lxc-sparclinux
    -rwxr-xr-x 1 root root  6862 May 18 14:48 lxc-sshd
    -rwxr-xr-x 1 root root 25602 May 18 14:48 lxc-ubuntu
    -rwxr-xr-x 1 root root 11439 May 18 14:48 lxc-ubuntu-cloud

Comenzaremos creando un nuevo contenedor con el nombre “ mi_contenedor ” con la plantilla “ ubuntu ”. 
Esto llevará algún tiempo y terminará de crear un contenedor para usted. ¡Sí! Es así de simple. 
Una vez completado, las últimas líneas muestran la contraseña para el usuario raíz del contenedor. Se vería algo similar a esto, 

$ sudo lxc-create -n my_container -t ubuntu
    .....
    .....
    ##
    # The default user is 'ubuntu' with password 'ubuntu'!
    # Use the 'sudo' command to run tasks as root in the container.
    ##

Podemos verificar el estado del contenedor usando lxc-ls. Esto mostrará que el contenedor está en estado detenido. 

$ sudo lxc-ls --fancy
    NAME            STATE    IPV4  IPV6  AUTOSTART
    ----------------------------------------------
    my_container    STOPPED  -     -     NO

Ahora, para iniciar el contenedor, ejecute lxc-start. El argumento -d lo crea un demonio. 
 

$ sudo lxc-start -n my_container -d

Verifique el estado del contenedor usando lxc-ls para verificar que se está ejecutando. Podemos acceder a la consola usando lxc-console. Utilice las credenciales que recibimos anteriormente para obtener acceso a la consola. 

 $ sudo lxc-console -n my_container

Después de iniciar sesión, ejecute el siguiente comando en el contenedor, 

$ top

Y en la PC host, ejecute el siguiente comando para ver la lista de procesos en ejecución. 

$ ps auxf

y en algún lugar encontrará un árbol de procesos similar a este, 
 

Sería sorprendente, pero todo el proceso en el contenedor es solo un proceso simple en la PC host. La parte importante es que todos están aislados y monitoreados por kernel. Por lo tanto, puede pensar en estos como procesos simples en la PC host e incluso puede eliminarlos (solo si tiene suficientes privilegios) 

Puede salir de la consola y volver al host escribiendo Ctrl-A seguido de  Q.

Para obtener más información sobre el uso del contenedor en ejecución, 

 $ sudo lxc-info -n my_container

Puede acceder al sistema de archivos raíz de este contenedor directamente desde la máquina host accediendo. Necesitará permiso de root para hacerlo. 

    $ sudo su
    $ cd /var/lib/lxc/my_container/rootfs

Eso es todo. Ahora bien, esto es como un nuevo sistema operativo. Puede ejecutar cualquier servicio en este contenedor. 
Piense en los contenedores como sistemas operativos separados, donde puede ejecutar lo que quiera. Lo único que lo hace especial es que todos los contenedores se ejecutan en el mismo hardware. Entonces, prácticamente, las empresas/instituciones compran una máquina compartida pesada y luego implementan contenedores con límites de recursos de acuerdo con los múltiples servicios que desean. Esto hace que sea escalable y más fácil de administrar. 

Para detener la ejecución del contenedor, 

    $ sudo lxc-stop -n my_container

Para eliminar el uso del contenedor, 
 

    $ sudo lxc-destroy -n my_container

NOTA: lxc proporciona un contenedor y una API fácil de usar para usar las funciones del kernel. No es equivalente a contenedores en ningún sentido. 
Lea la documentación para obtener más detalles sobre el funcionamiento de los contenedores. Hay muchos comandos que son realmente útiles y facilitan la configuración de contenedores. 

Referencias:

https://www.youtube.com/watch?v=sK5i-N34im8 
https://wiki.archlinux.org/index.php/Linux_Containers  
https://linuxcontainers.org/lxc/introduction/  
http://www. ubuntu.com/cloud/lxd 

Este artículo es una contribución de Pinkesh Badjatiya . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. 

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.