Qué es Docker y para qué sirve

Noviembre 2016


Qué es Docker

Docker no es más que una plataforma de código abierto para que administradores y desarrolladores puedan crear, empaquetar y distribuir sus aplicaciones rápidamente.

Para qué sirve Docker

Docker sirve para ejecutar máquinas virtuales ligeras que están compuestas por módulos. La característica principal del sistema es que esos módulos se pueden agregar o quitar dependiendo de tus necesidades.

Cómo instalar Docker

Para instalar Docker, crea este script o simplemente ejecuta manualmente cada una de sus instrucciones

#!bin/sh
#instalación de docker
sudo apt-get install -y --force-yes lxc-docker
sudo gpasswd -a ${USER} docker
sudo service docker restart

#sintaxis de docker
docker [command] [flags] [container] [arguments]
docker run -i -t ubuntu /bin/bash

Lo primero que tenemos que hacer con docker es importar una imagen de un contenedor, esta la podemos obtener de la página de docker o por otra vía
#importar imagen
cat imagen | docker import - nombre contenedor
cat centos-6-20150304_1234-docker.tar.xz | docker import - centos-6

Luego de importar un contenedor debemos comprobar que la imagen se importó correctamente
#listar contenedores
docker images

Para iniciar la imagen lo hacemos de la siguiente forma
#iniciar pc
docker start contenedor_a_iniciar
docker start -P centos-6

En este caso creo la pc pero le indico 2 rutas locales para carpetas del sistema y le digo que se comunique por el puerto 80 y accediendo a la consola de esta
docker run -v carpeta_local:carpeta_virtual -v carpeta_local:carpeta_virtual -p 80:80 -name centos-6 -i -t centos6 /bin/bash
docker run -v /home/alex/docker/repositorio:/home/repositorio -v /home/alex/docker/etc/mrepo.conf.d -p 80:80 --name centos-6 -i -t centos-6 /bin/bash
##-p nos permite utilizar la red de nuestro Host :D

Memoria compartida

En este caso inicio un contenedor con un programa para crear un segmento de memoria compartida

docker run -it shm bash
$ sudo shm/shm_server &
$ sudo ipcs -m

------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x0000162e 0 root 666 27 1

Cuando creo un 2do contenedor no muestra un segmento de me memoria compartida con el 1mer contenedor

docker run shm ipcs -m

------ Shared Memory Segments --------
key shmid owner perms bytes nattch status

Pero cuando creo un 3cer contenedor con la opción -ipc=container:CONTAINERID muestra la memoria compartida del 1mer contenedor

$ sudo docker run -it --ipc=container:ed735b2264ac shm ipcs -m
$ sudo ipcs -m

------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x0000162e 0 root 666 27 1

Enlace entre contenedores

También contamos con la opción link(enlazar), esta permite que los contenedores puedan comunicarse entre si. Al iniciar por primera vez la pc se le dio por defecto el puerto 80 para compartir:

docker run --name=link-test -d -i -t fedora/httpd

Un segundo contenedor llamado liker, puede comunicarse con el contenedor fedora/http con el alias link-test al correrlo con la opción --link=:

docker run -t -i --link=link-test:lt --name=linker fedora /bin/bash

Ahora el contenedor linker está enlazado con el contenedor lt que tiene el alias link-test. Al correr el comando ¨env¨ se nos muestran las variables de entorno
with the LT (alias) context (LT_)

# env
HOSTNAME=668231cb0978
TERM=xterm
LT_PORT_80_TCP=tcp://172.17.0.3:80
LT_PORT_80_TCP_PORT=80
LT_PORT_80_TCP_PROTO=tcp
LT_PORT=tcp://172.17.0.3:80
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
PWD=/
LT_NAME=/linker/lt
SHLVL=1
HOME=/
LT_PORT_80_TCP_ADDR=172.17.0.3
_=/usr/bin/env

La ventaja que tiene este procedimiento es que se crea una comunicación segura entre los distintos contenedores ya que esta conección se realiza por canales virtuales

#para salir de la pc solo debemos usar el comando exit
una vez fuera queremos saber si el contenedor aún continua activo

#listar contenedores activos
docker ps -a

#detener el contenedor
docker stop contenedor
docker stop centos-6


en ocasiones necesitaremos utilizar un contenedor como un demonio
#demonizar un contenedor
docker run -d contenedor_a_utilizar /bin/sh -c comando_a_utilizar ""
docker run -d centos-6 /bin/sh -c "while true; do echo hello world; sleep 1; done"

el contenedor irá resgistrando cambios
#revisar los log de un contenedor
docker logs contenedor_a_utilizar
docker logs centos-6

#eliminar un contenedor
docker rm contenedor_a_borrar
docker rm centos-6

#para borrar un contenedor primero hay que listar los contenedores con los que contamos, para eso usamos
docker images

luego con el comando
#eliminamos las imágenes
docker-rmi -f yes

Crear una imagen desde 0


Para crear un contenedor desde 0 primero debemos crear un ¨docker file¨ y usamos el siguiente comando
#touch Dockerfile
touch /home/alex/docker/contenedores/ejemplo

¿Qué es un Dockerfile y cómo se crea?

Un Dockerfile no es más que un archivo que reconoce Docker y que contiene una serie de instrucciones para automatizar el proceso de creación de un contenedor. En pocas palabras en este archivo vamos a agregar todo lo que necesitemos en nuestro contenedor para que cada vez que queramos correr el script de construcción obtengamos un contenedor completamente fresco y actualizado.

Aquí les dejo dos ejemplo de cómo contruir un dockerflie

# Ejemplo 1 DockerFile
FROM ubuntu:14.04
MAINTAINER Koldo Hernández <info@koldohernandez.com>
RUN apt-get update && apt-get install -y git
RUN sudo mkdir carpeta_prueba
# Ejemplo 2
#Origen: Ubuntu 14.04 LTS
FROM ubuntu:14.04

#Creador:
MAINTAINER Jesus Marin <jam@jam.net.ve>

#Actualizar el repositorio Ubuntu, luego descarga e instala paquetes que
#requieren actualizacion.
RUN apt-get -qq update && apt-get -qqy upgrade

#Instalar algunos paquetes bases, utiles para mi y algunas dependencias.
RUN apt-get -qqy install wget git curl dnsutils tmux zsh openssh-server pwgen vim

#Configurar SSHD y crear una contraseña para ROOT
RUN mkdir -p /var/run/sshd && sed -i "s/UsePrivilegeSeparation.*/UsePrivilegeSeparation no/g" /etc/ssh/sshd_config && sed -i "s/UsePAM.*/UsePAM no/g" /etc/ssh/sshd_config && sed -i "s/PermitRootLogin.*/PermitRootLogin yes/g" /etc/ssh/sshd_config
ADD set_root_pw.sh /set_root_pw.sh
ADD run.sh /run.sh
RUN chmod +x /*.sh

EXPOSE 22
CMD ["/run.sh"]


Un dockerfile por dentro.

Notese que el archivo esta compuesto principalmente por conjuntos de INSTRUCCION en mayusculas segido de una sentencia en minuscula.

El texto que esta despues de un # es simplemente un comentario.
La instruccion FROM.

En la primeras lineas podemos ver la palabra FROM, esta nos indica que Imagen Base vamos a tomar para crear nuestra imagen personalizada, en este caso usamos ubuntu:14.04. Docker toma esta imagen desde el Docker Registry el cual contiene nuestra imagen base Ubuntu 14.04 LTS.

Notese que despues del nombre de la imagen indicamos la version de Ubuntu a usar, bueno esto en Docker se llama TAG y es la forma en que podemos usar una version especifica de esa imagen, si vemos las tags disponibles de dicha imagen en su repositorio podemos ver que tambien disponemos de otras versiones de Ubuntu como la 13.10 o la 12.04.

Si por ejemplo no queremos usar como imagen base a Ubuntu sino que queremos crear una imagen Debian o CentOS podriamos decir:

FROM debian:stable

FROM centos:6.4

La instruccion MAINTAINER

Esta instruccion no tiene mucha ciencia, tan solo especificamos quien es el autor de dicho dockerfile y su correo.
La instruccion RUN

Esta instruccion la veras en casi cualquier dockerfile ya que con ella especificas los comandos que quieras ejecutar. En este caso indicamos que se ejecutara el comando:

apt-get -qq update && apt-get -qqy upgrade

El cual ejecuta a apt-get para que actualice el listado de repositorios e inmediatamente actualice los paquetes que dispongan de actualización.

Mas abajo puedes ver que se ejecuta nuevamente apt-get pero esta vez para instalar algunos paquetes básicos que no están en la imagen base y que podrías requerir para tu imagen personalizada.

También puedes ver que ejecuta una serie de comandos concatenados que crean carpetas en ciertas ubicaciones de la imagen base y realiza configuraciones en archivos. En esta parte se realiza una configuración de el servidor OpenSSH.

La instrucción ADD

Con esta instrucción podemos hacer que se agregue a la imagen base un archivo que nosotros queremos que contenga, indicando la ubicación actual de dicho archivo en nuestro sistema y la ubicación donde dentro de la imagen donde queremos que se aloje dicho archivo.

En este caso set_root_pw.sh es el archivo a agregar, no especificamos una ruta ya que el archivo esta en la misma carpeta en la que esta el archivo dockerfile. Esta instrucción es seguida de /set_root_pw.sh notese el / delante del nombre del archivo, aquí si estamos especificando una ruta y es la ruta de destino dentro de la imagen en donde ubicaremos dicho archivo a agregar.
La instrucción EXPOSE

Con esta instrucción le decimos a Docker que los contenedores de esta imagen escucharan en el puerto especificado una vez que dichos contenedores se estén ejecutando. Docker también puede usar esta información para interconectar contenedores usando enlaces.

En nuestro caso exponemos el puerto 22 ya que usaremos un servidor OpenSSH para poder conectarnos al contenedor vía SSH. Si por ejemplo estuviésemos creando un contenedor que alberga un servidor Web como por ejemplo Nginx o Apache, necesitaríamos exponer su puerto de escucha el cual es típicamente el puerto 80, lo mismo va si queremos usar cualquier otro servicio.
La instrucción CMD

Esta instrucción es un tanto similar a la instrucción RUN solo que CMD ejecuta el comando indicado únicamente cuando arranque el contenedor y no cuando se este construyendo el mismo, esto puede servirnos para ejecutar servicios que ya estén instalados o para correr archivos ejecutables especificando su ubicación. No son todas las instrucciones, existen algunas otras mas en la Dockerfile Reference.

una vez creado el docker file
#docker build -t nombre/nombre-de-contenedor
docker build -t /home/alex/docker/contenedores/ejemplo/debian

la opción -t nos permite nombrar el contenedor y ubicarlo de manera sencilla

Consulta también :
El documento «Qué es Docker y para qué sirve» de CCM (es.ccm.net) se encuentra disponible bajo una licencia Creative Commons. Puedes copiarlo o modificarlo siempre y cuando respetes las condiciones de dicha licencia y des crédito a CCM.