Docker Desde los Cimientos: Trabajando Con Contenedores, Parte 2

Spanish (Español) translation by Rafael Chavarría (you can also view the original English article)

Esta es la parte dos de una serie de dos partes sobre trabajar con contenedores Docker. En la parte uno, nos enfocamos a las muchas maneras y opciones de ejecutar una imagen y cómo el anfitrión puede interactuar con un contenedor Docker.

En esta parte, cubriremos listar, inicia, detener y reiniciar contenedores así como ejecutar comandos sobre contenedores en ejecución. En particular, aprenderás la diferencia entre contenedores en ejecución y detenidos (salidos), y cómo controlar precisamente la información y mostrar cuando listas tus contenedores filtrando y formateando.

Después, tendrás experiencia de primera mano deteniendo, iniciando, reiniciando y adjuntando a tus contenedores. Por último, ejecutarás comandos de una sola vez así como tendrás acceso de consola interactiva para un contenedor en ejecución.

Antes de que comencemos, asegúrate de que Docker está instalado apropiadamente en tu entorno. Dependiendo de como se instaló y tu usuario, podrías necesitar ejecutarlo como sudo. Yo omitiré el sudo.

Listando Contenedores

Cuando trabajamos con contenedores, frecuentemente quieres listar, ver y filtrar tus contenedores. El comando docker ps es la clave, y tiene muchas opciones interesantes.

Ejecutando Contenedores

El comando más básico es un simple docker ps sin argumentos, que muestra todos los contenedores actualmente en ejecución.

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  
CREATED             STATUS              PORTS                           
NAMES
2f542e1cb88b        nginx               "nginx -g 'daemon ..."   
12 hours ago        Up 12 hours         443/tcp, 0.0.0.0:9000->80/tcp   
nginx

Obtienes mucha información sobre cada contenedor, incluyendo el id de contenedor, la imagen, el comando, cuándo fue creado, su estado actual, sus puertos, y sus nombres. Es un poco difícil analizar debido al envoltorio. Veremos después cómo filtrar y formatear la salida. Nota que el comando está cortado (así como el id de contenedor). Para mostrar el comando completo, agrega --no-trunc:

$ docker ps --no-trunc

IMAGE   COMMAND
nginx   "nginx -g 'daemon off;'"

Ahora, el comando completo es visible: nginx -g 'daemon off;'

Todos los Contenedores

Como recuerdas, Docker mantiene a los contenedores detenidos (a menos que los ejecutes con --rm). Agregar -a muestra todos los contenedores:

$ docker ps -a
CONTAINER ID        IMAGE               STATUS      NAMES
cc797c61dc21        busybox             Exited      busybox
67f3cb5a9647        busybox             Exited      ecstatic_jones
898fb562e535        hello-world         Exited      hopeful_spence
6dd210fda2d8        hello-world         Created     infallible_curie
2f542e1cb88b        nginx               Up 12 hours nginx

Formateando

La salida de docker ps puede ser demasiado verbosa y frecuentemente muestra muchos campos que no son interesantes. Puedes usar formato Go-template para mostrar solo los campos que te interesen. Aquí está mostrando solo el nombre y el comando:

$ docker ps --no-trunc --format '{{.Names}}\t{{.Command}}'
nginx   "nginx -g 'daemon off;'"

Eso funciona, pero para presentarlo con los nombres de campo, agrega "table" al inicio de la cadena de formato:

$ docker ps -a --no-trunc --format 'table {{.Names}}\t{{.Command}}'
NAMES               COMMAND
busybox             "cat /data/1.txt"
ecstatic_jones      "cat /data/1.txt"
hopeful_spence      "/hello"
infallible_curie    "ls -la"
nginx               "nginx -g 'daemon off;'"

El nombre de formato para el id de contenedor (no seleccionado aquí) es {{.ID}} (todas mayúsculas).

Filtrado

El comando docker ps soporta muchos filtros. Son bastante sencillos de usar. La sintaxis es -f "<filtro>=<valor>". Los filtros soportados son id, label, name, exited, status, ancestor, before, since, isolation, network, y health.

Aquí está filtrando por nombre de contenedor y mostrando solo el contenedor busybox:

$ docker ps -a -f "name=busybox" \
               --format 'table {{.ID}}\t{{.Status}}\t{{.Names}}'
CONTAINER ID        STATUS                      NAMES
cc797c61dc21        Exited (0) 11 minutes ago   busybox

La Bandera -q

Si todo lo que quieres es el id de contenedor, usa -q flag (bandera silenciosa). Es más simple que --format 'table {{.ID}}'. Esto es necesario frecuentemente cuando quieres realizar operaciones en múltiples contenedores (verás un ejemplo después).

$ docker ps -aq
cc797c61dc21
67f3cb5a9647
898fb562e535
6dd210fda2d8
2f542e1cb88b

Deteniendo, Iniciando y Reiniciando Contenedores

Puedes detener contenedores en ejecución e iniciar un contenedor detenido. Hay muchas diferencias entre iniciar un contenedor detenido y ejecutar una nueva instancia de la misma imagen:

Usas las mismas variables de entorno, volúmenes, puertos y otros argumentos del comando de ejecución original.
No tienes que crear otro contenedor.
Si la instancia detenida modificó su sistema de archivo, el contenedor iniciado usará el mismo.

Detengamos el contenedor nginx e iniciémoslo después. Cuando te refieres a un contenedor, puedes usar su nombre o un prefijo ambiguo de su id. Usualmente nombro mis contenedores más antiguos para tener una palanca significativa y no tener que lidiar con los nombres auto-generados de Docker o prefijos de id del contenedor.

$ docker stop nginx
nginx

$ docker ps -a -f "name=nginx" --format 'table {{.Names}}\t{{.Status}}'
NAMES               STATUS
nginx               Exited (0) 2 minutes ago

OK. Nginx se ha detenido (el estado es "Exited"). Iniciémoslo:

$ docker start nginx
nginx

$ docker ps -a -f "name=nginx" --format 'table {{.Names}}\t{{.Status}}'
NAMES               STATUS
nginx               Up 33 seconds

Reiniciando un contenedor en ejecución es otra opción, que es equivalente a docker stop seguido de docker start.

$ docker restart nginx

nginx
$ docker ps -a -f "name=nginx" --format 'table {{.Names}}\t{{.Status}}'
NAMES               STATUS
nginx               Up 2 seconds

Adjuntando a un Contenedor en Ejecución

Cuando inicias un contenedor detenido, o si ejecutas tu contenedor en modo separado (argumento de linea de comando -d), no puedes ver la salida. Pero puedes adjuntarlo a esta.

$ docker attach nginx
172.17.0.1 - - [19/Mar/2017:08:40:03 +0000] "HEAD / HTTP/1.1" 200 0 "-"
"HTTPie/0.8.0" "-"

Removiendo Contenedores

Puedes remover contenedores detenidos con el comando: docker rm <id de contenedor o nombre>

$ docker rm ecstatic_jones
ecstatic_jones

Si quieres remover un contenedor en ejecución, puedes detenerlo primero o usar el argumento de línea de comando -f (force):

$ docker rm -nginx
Error response from daemon: You cannot remove a running container
3dbffa955f906e427298fbeb3eadfd229d64365dd880c9771a31b0aedb879d6d. 
Stop the container before attempting removal or use -f

$ docker rm -f -nginx
nginx

Si quieres remover todos los contenedores, aquí está un buen código:

docker rm -f $(docker ps -aq)

Si quieres remover solo el contenedor detenido, remueve la bandera -f (force).

Ejecutando un Comando Dentro de un Contenedor en Ejecución

Docker ejecuta un solo proceso dentro de un contenedor, pero puedes ejecutar comandos adicionales contra un contenedor en ejecución. Es muy similar a proporcionar un comando personalizado al comando docker run, excepto que en este caso está ejecutando lado a lado con el comando run.

Comandos Simples

Ejecutar un comando simple es hecho vía docker exec. Proporcionas un id o nombre de contenedor en ejecución y el comando que deseas ejecutar. Revisemos el archivo nginx.conf dentro del contenedor nginx y veamos cuántos procesos trabajadores están configurados.

$ docker exec nginx cat /etc/nginx/nginx.conf | grep worker_processes
worker_processes  1;

Shell Interactivo

Una de las mejores técnicas de solución de problemas con contenedores Docker es conectar a un shell interactivo y solo explorar el sistema interno de archivos. Para poder adjuntar stdin y tener un tty, necesitas proporcionar los argumentos de línea de comando -i -t (pueden ser agrupados como -it) y después el nombre de un ejecutable shell (usualmente bash).

Terminas con acceso shell a tu contenedor. Aquí está un ejemplo de revisar el proceso trabajador de manera interactiva desde "dentro" del contenedor.

$ docker exec -it nginx bash
root@b010e854bb98:/# cat /etc/nginx/nginx.conf | grep worker_processes
worker_processes  1;
root@b010e854bb98:/#

Conclusión

Docker es una plataforma poderosa, y ya que el contenedor es su unidad de trabajo, proporciona muchas herramientas para administrar y trabajar con contenedores. Describí la mayoría de los aspectos importantes de trabajar con contenedores, pero hay muchas características más avanzadas, opciones y matices para los comandos que cubrí, así como comandos adicionales.

Si trabajas de cerca con contenedores Docker, toma el tiempo para sumergirte y aprender todo sobre ellos. Pagará generosamente.