Esta vez vamos a emprender el viaje a la virtualización de entornos. Hasta ahora nuestra experiencia se reducía a algunos contactos con VirtualBox. Así lograbas una completa máquina virtual en la que correr otros sistemas operativos y/o entornos, que podrían ser diferentes al tuyo (Host).

La experiencia fue agridulce, pues si bien es un adelanto poder disponer de ‘entornos virtuales’ en tu computadora, se hacía bastante pesado, el proceso de creación de la máquina virtual (consumiendo muchos recursos), por no hablar del proceso de exportar luego el trabajo realizado en ello.

Últimamente se habla mucho en la red de redes de Docker, que como reza la entrada correspondiente en Wikipedia es un proyecto de código abierto que automatiza el despliegue de aplicaciones dentro de contenedores software, proveyendo de una capa adicional de abstracción y automatización de virtualización del sistema operativo en Linux

Mmh… what? Pues que ahora podemos fácilmente empaquetar en contenedores nuestros entornos de desarrollo (virtualizados) e intercambiarlos sencillamente como cromos entre servidor-PC- portátil etc, crearlos, clonarlos, destruirlos con una línea de comando… ? Veamos…

El caso es que Docker basa su potencia en LXC :LinuX Containers. Así que … principiemos por el principio.

Mi agradable sorpresa ha sido el comprobar como sencillamente puedo crear una máquina (pseudo) virtual , con unos pocos comandos, en mi computadora. Esa (pseudo) máquina hábilmente, gracias a LXC reutiliza el mismo Kernel de la máquina que la alberga (Host). Ecología de recursos. De ahí lo de pseudo .

El caso es que uno de los pocos contras del proceso con LXC es que el nuevo sistema (pseudo) virtualizado (obviamente) debe basarse en el mismo Kernel de la máquina Host.

El primero que me habó de LXC fue mi amigo hk … compartiendo conmigo el concepto de como uno puede usar esta técnica para correr diferentes servicios interconectados entre sí via IP (paralelamente en el mismo Host).

Seguiré los pasos de Stéphane Graber para, este vez desde Ubuntu 14.04 (el hijo díscolo ) en vez de Debian Jessie (su padre), por comodidad.

En un alarde de originalidad, copio y pego los comandos, y los adapto a mi gusto, traduciendo los comentarios que clarifican los pasos a dar .

Inspiramos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# Crear "p1" : container usando el template "ubuntu" y la version de Ubuntu
# and architecture as the Host (mi compu _real- ). Con "-- --help" listamos todas las opciones all available options.

$ sudo lxc-create -t ubuntu -n p1

# Iniciar el container (en background)
$ sudo lxc-start -n p1 -d

# Entrar al container en una de los siguientes formas

##  'Attach' a la consola del container' (ctrl-a + q para detach)
$ sudo lxc-console -n p1

## Bash directamente en el container (cortocircuitando el login de consola), requiere >= 3.8 kernel
$ sudo lxc-attach -n p1

## via SSH
$ sudo lxc-info -n p1
$ ssh ubuntu@<ip según lxc-info>

# Stop container, de una de las siguientes formas
## Stop desde él mismo
$ sudo poweroff

## Stop limpiamente desde 'fuera'
$ sudo lxc-stop -n p1

## Kill desde 'fuera'
$ sudo lxc-stop -n p1 -k

Bien..
Expiramos.
Ya armamos nuestro primer, simple y ligero contenedor Linux – LXC .

Como dice Stéphane, “habrás notado que habiualmente todo funciona tal cual en Ubuntu (en Debian GNU/Linux hay que usar algunos comandos más… parece, para los cgroups y la parte de red… )”
“los kernels Ubuntu soportan todas las facilidades que requiere LXC , y los paquetes configuran un bridge y servidor DHCP que los containers usan por defecto” … Todo ello, obvio, configurable y bla,bla…

Parece que trabaja en Canonical… ;–)
(más adelante trataremos de repetir el proceso en Debian GNU / Linux (!), pero eso será en otro post … )

Vayamos por segundo container que albergue querido Debian. Básicamente lo que haremos será usar otro template de container.
Es decir :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

## creamos el container debian, forzando la arquitectura 
$ sudo lxc-create -t debian -n p2 -- -a i386

## iniciamos el container debian 32bits
$ sudo lxc-start -n p2 -d

## lo chequeamos,

$ sudo lxc-info -n p2
Name:           p2
State:          RUNNING
PID:            5828
IP:             10.0.3.118
CPU use:        1.88 seconds
BlkIO use:      49.66 MiB
Memory use:     85.56 MiB
KMem use:       0 bytes
Link:           vethV01VLC
 TX bytes:      1.79 KiB
 RX bytes:      5.69 KiB
 Total bytes:   7.48 KiB

## notar que, para acceder a él si es necesario por esta via, obtenemos su dirección IP

NOTA: los diferentes containers , dijimos, tendrán siempre de base el mismo Kernel, que comparte con el Host que los alberga. En nuestro caso

1
2
3

## Verificamos el sistema y Kernel del Host (común a los containers)
$ uname --all
Linux RainbowWarrior 3.13.0-37-generic #64 [...]

Bla,bla … para mi uso y propósito personal, instalaré la pila – stack LAMP (Linux+Apache+MySQL+Php). Voilà.
Ya tengo mi servidor Web personal de bolsillo ultraligero…

NOTA2: en línea lo siguiente más simple probablemente sea la Raspberry Pi con Raspbian ;–)

Es por ello que nos viene como un guante el siguiente comando para procesar un clon.

1
2
3
4
5
6
7
8

## pre-condición al clonar : el _container_ a clonar deber estar en stop
$ sudo lxc-stop -n p2

## clonamos 'p2' , nuestro 2º container Debian mínimo con LAMP
$ sudo lxc-clone -o <container original: 'p2'> -n <nombre del nuevo container>

## en nuestro caso, parametrizando lo anterior ..., y lo llamamos lamp1
$ sudo lxc-clone -o p2 -n lamp2

A estas alturas del partido… tenemos 3 instancias LXC en juego

1.– p1 : Ubuntu clon del sistema Host común

2.– p2 : Debian GNU/Linux

3.– lamp2 : Debian GNU/Linux + LAMPhp + phpMyAdmin …

1
2

##podemos comprobar el estado operativo de cada container LXC
$ lxc-ls --fancy

… al que, por ejemplo, puedo acceder en

1

http://10.0.3.85/phpmyadmin/

Voilà.

:–)

BONUS : LXC Web Panel para Ubuntu desde el que poder cómodamente gestionar todos los containers LXC …

Actualización

NOTA1: gracias a @drymer que nos comenta que Docker evolucionó, más allá de LinuxContainers, con sus propias librerías

NOTA2: por otro lado Ubuntu Linux promueve con la base de los LXCs, los LXD (relacionados con OpenStack ), como hypervisor de los contenedores Linux … para “mejorar la experiencia del usario”

jordila 02/05/2017

Posted In: softwareLibre

Etiquetas: abundancia, debian, lxc, ubuntu

Leave a Comment