Gestionar Contenedores de Linux con Docker en Ubuntu

Versión: 1.0
Autores: Srijan Kishore
Última edición: 02 /Jul/2014

Esta guía explica cómo instalar Docker y gestionar máquinas virtuales de manera efectiva. Docker es una plataforma de virtualización de Linux de código abierto para desarrolladores y administradores de sistemas para construir, desplegar y ejecutar aplicaciones distribuidas fácilmente. Docker consiste en el Docker Engine, una capa de ejecución y virtualización ligera, herramientas para empaquetar y versionar máquinas virtuales similar a un repositorio de código fuente y Docker Hub, un servicio en la nube para compartir aplicaciones y automatizar flujos de trabajo. Docker permite que las aplicaciones se ensamblen rápidamente a partir de componentes y elimina la fricción entre entornos de desarrollo, control de calidad y producción.

1 Nota Preliminar

En mi caso tengo Ubuntu 14.04 en el que voy a instalar docker. En el mercado de software de virtualización tenemos varias tecnologías de virtualización de hardware completo disponibles como KVM, Xen o Hyper-V. Pero las visualizaciones completas son demasiado pesadas para virtualizar aplicaciones individuales en Linux. Podemos superar esta situación utilizando Contenedores de Linux, que es una buena alternativa para la visualización a nivel de sistema operativo. Los Contenedores de Linux son muy útiles para tener un entorno de desarrollo/prueba en un conjunto seguro de contenedores. Docker proporciona un entorno de Contenedor de Linux para este propósito.

2 Instalación

Como mencioné anteriormente, tengo Ubuntu en el que voy a instalar docker. En este capítulo te mostraré 2 opciones para instalar docker, en 2a utilizo la versión de docker del repositorio de Ubuntu, esta versión es mantenida por Ubuntu durante los 5 años completos de soporte LTS, pero no es la última versión. En 2b usaré la última versión del repositorio ppa de Ubuntu. Dado que docker está en un desarrollo intenso, la última versión de Docker de 2b) probablemente se adapte a la mayoría de los usuarios. ¡Por favor, utiliza el método 2a o 2b pero no ambos al mismo tiempo!

2a Instalar desde el repositorio oficial de Ubuntu

Para instalar usa:

sudo apt-get update  
sudo apt-get install docker.io

y crea un enlace simbólico para facilitar su uso en la terminal.

sudo ln -sf /usr/bin/docker.io /usr/local/bin/docker  
sudo sed -i '$acomplete -F _docker docker' /etc/bash_completion.d/docker.io

2b Instalar la última versión de docker

Para instalar la última versión de docker desde el repositorio docker.io, ejecuta este comando

curl -s https://get.docker.io/ubuntu/ | sudo sh

3 Preparar el entorno de la terminal

Ahora agregaré mi usuario=srijan al grupo docker

sudo usermod -a -G docker srijan

O usa:

sudo usermod -a -G docker $USER

Aquí cerraré mi sesión actual y volveré a iniciar sesión. Ahora agregaré el archivo de configuración de docker para notificar al sistema sobre su ubicación.

sudo vi /etc/default/docker.io

| DOCKER="/usr/bin/docker.io" |

Ahora reinicia el servicio de la siguiente manera:

sudo service docker.io restart

4 Gestión de Contenedores

Voy a iniciar un contenedor con el sistema operativo Ubuntu. Descargaré la imagen de docker de la siguiente manera:

docker pull ubuntu

 Nota: pull se utiliza para obtener una imagen o un repositorio del registro

Ahora iniciaré sesión en la terminal bash del contenedor ubuntu usando:

docker run -i -t ubuntu /bin/bash

Solo para confirmar, verificaré mi IP de contenedor de la siguiente manera:

root@fd98ee950252:/# ifconfig 
eth0      Link encap:Ethernet  HWaddr 5a:a6:c6:88:f2:48  
          inet addr:172.17.0.3  Bcast:0.0.0.0  Mask:255.255.0.0
          inet6 addr: fe80::58a6:c6ff:fe88:f248/64 Scope:Link
          UP BROADCAST RUNNING  MTU:1500  Metric:1
          RX packets:7 errors:0 dropped:2 overruns:0 frame:0
          TX packets:8 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:558 (558.0 B)  TX bytes:648 (648.0 B)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

root@fd98ee950252:/#

Tengo una IP de 172.17.0.3 en mi contenedor. De manera similar, también puedo usar otros contenedores. Para salir del contenedor, simplemente escribe:

exit

De manera similar, puedes tener otros contenedores de SO, por ejemplo.

Quiero usar un contenedor Debian, usaré el código:

docker run -i -t debian /bin/bash

Si deseas tener una distribución particular, entonces usa:

docker run -i -t ubuntu:12.04 /bin/bash

Creará el contenedor ubuntu12.04. Lo verificaré de la siguiente manera:

root@44b56100fd1f:/# cat /etc/lsb-release 
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=12.04
DISTRIB_CODENAME=precise
DISTRIB_DESCRIPTION="Ubuntu 12.04.4 LTS"
root@44b56100fd1f:/#

4 Construyendo nuestras propias imágenes

Hay dos formas de crear una imagen de Docker:

A través del comando docker commit
A través del comando docker build con un Dockerfile

El método docker commit no se recomienda actualmente, ya que construir con un Dockerfile es mucho más flexible y poderoso, pero lo demostraremos por el bien de la completitud. Después de eso, me centraré en el método recomendado para construir imágenes de Docker: escribir un Dockerfile y usar el comando docker build.

4.1 Usando Docker commit para crear imágenes

Crearé un contenedor, haré cambios en ese contenedor como lo harías al cambiar código, y luego comprometeré esos cambios a una nueva imagen.

Comencemos creando un contenedor a partir de la imagen de ubuntu que hemos utilizado en el pasado.

docker run -i -t ubuntu /bin/bash  
root@73527b8b4261:/#

Nota: Por favor, observa que arriba root está mostrando el nombre de host 73527b8b4261, es el nombre del contenedor creado y diferirá en tu caso.

Además, instalaré apache en él:

apt-get install apache2

He lanzado el contenedor y luego instalé Apache dentro de él. Ahora voy a usar este contenedor como un servidor web, así que lo guardaré en su estado actual.
Eso nos ahorrará tener que reconstruirlo con Apache cada vez que cree un nuevo contenedor. Para hacer esto, saldré del contenedor, usando el comando exit,
y usaré el comando docker commit.

exit

docker commit 73527b8b4261 srijan/apache2 8ce0ea7a1528

Nota: aquí 73527b8b4261 es el nombre de mi contenedor y estoy usando 8ce0ea7a1528 como etiqueta para el contenedor, puedes dar cualquier nombre de etiqueta o usar el mismo.

Supongamos que olvidaste el id del último contenedor creado, puedes usar:

docker ps -l -q

Te dará 73527b8b4261

Nota: 73527b8b4261 es el nombre de tu último contenedor creado, diferirá en tu caso.*

Veamos nuestra nueva imagen. Se puede lograr de la siguiente manera:

docker images srijan/apache2

srijan@vboxtest:~$ docker images srijan/apache2
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
srijan/apache2      8ce0ea7a1528        741155868ac8        6 minutes ago       207.2 MB
srijan@vboxtest:~$

Nota: Aquí 8ce0ea7a1528 fue el nombre de etiqueta que usé al guardar el contenedor,   
Nota: 741155868ac8 es el ID de la IMAGEN de ese contenedor  
Nota: Todos estos valores diferirán en tu caso, ya que al guardar el contenedor docker genera nombres aleatorios para ellos

Ahora guardaré la imagen personalizada de la siguiente manera:

docker commit -m="Una nueva imagen personalizada" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver

Te dará el resultado como:

srijan@vboxtest:~$ docker commit -m="Una nueva imagen personalizada" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver
f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec

Para ejecutar un contenedor a partir de nuestra nueva imagen, podemos hacerlo usando el comando docker run.

docker run -t -i srijan/apache2:webserver /bin/bash

Podemos verificar nuestra imagen comprometida de la siguiente manera:

docker inspect srijan/apache2:webserver

srijan@vboxtest:~$ docker inspect srijan/apache2:webserver
[{
    "Architecture": "amd64",
    "Author": "Srijan Kishore",
    "Comment": "Una nueva imagen personalizada",
    "Config": {
        "AttachStderr": false,
        "AttachStdin": false,
        "AttachStdout": false,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "",
        "Image": "",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": false,
        "PortSpecs": null,
        "StdinOnce": false,
        "Tty": false,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Container": "73527b8b42614f6ecd83fb5f9822d6086988d3b68fd5e32b4afbc7cd415402fd",
    "ContainerConfig": {
        "AttachStderr": true,
        "AttachStdin": true,
        "AttachStdout": true,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "73527b8b4261",
        "Image": "ubuntu",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": true,
        "PortSpecs": null,
        "StdinOnce": true,
        "Tty": true,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Created": "2014-06-30T12:58:04.973349049Z",
    "DockerVersion": "1.0.1",
    "Id": "f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec",
    "Os": "linux",
    "Parent": "ef83896b7fb99b00b9e0e6ac943826386e7edcef11a3a2f58b42011ab4a4e683",
    "Size": 14463026
}
]srijan@vboxtest:~$

Para ejecutar un contenedor a partir de nuestra nueva imagen, podemos hacerlo usando el comando docker run.

docker run -t -i srijan/apache2:webserver /bin/bash