Coffee bytes

Blog de desarrollo web con Python y Javascript

Eduardo Zepeda

Aprende Docker, curso práctico con ejemplos en GNU/Linux

El martes, 6 de octubre de 2020

por Eduardo Zepeda

Tiempo de lectura: 20 minutos

Si te leíste la entrada anterior donde explico para que sirve Docker ya debes tener una idea bastante simple de Docker, pero no he publicado nada acerca de los comandos. Aquí te explico los comandos más comunes de Docker, el uso de volúmenes y la creación de un Dockerfile de ejemplo.

Las imágenes y los contenedores son diferentes

Antes de empezar hay que aclarar que en Docker trabajamos con contenedores que son creados a partir de imágenes. Una imagen es como una plantilla de solo lectura, mientras que el contenedor es la materialización de esa plantilla, se podría decir que es una imagen instanciada o en ejecución.

Puedes pensar en las imágenes y contenedores como clases y sus instancias, respectivamente.

Comandos básicos de Docker

Correr un contenedor

Para correr un contenedor usaremos el comando run y el nombre de la imagen de la que derivará. Puedes especificar como quieres que se llame tu contenedor con la opción –name.

docker run hello-world
docker run --name mi_nombre hello-world
Hello from Docker!
This message shows that your installation appears to be working correctly.
...

Tras ejecutar el comando anterior, Docker descargará la imagen de hello-world y creará un contenedor, este contenedor se ejecutará, realizará su función y terminará de ejecutarse.

Descargar una imagen

Si solo quieres traer una imagen para que esté disponible, sin ejecutarla puedes usar el comando docker pull, seguido del nombre de la imagen.

docker pull hello-world
Using default tag: latest
latest: Pulling from library/hello-world
Digest: sha256:4cf9c47f86df71d48364001ede3a4fcd85ae80ce02ebad74156906caff5378bc
...

Buscar una imagen

La imagen de hello-world es probablemente la más aburrida que hay y de seguro querrás buscar una imagen que haga algo más que imprimir texto en pantalla.

Para buscar una imagen podemos usar el comando docker search. Lo que hace este comando es conectarse a docker hub y buscar la imagen que le indiquemos.

En Dockerhub existen imágenes de mysql, de nginx, de alpine linux, de python, de django, wordpress, ghost y casi cualquier otra tecnología que puedas nombrar.

docker search nginx
NAME                               DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
nginx                              Official build of Nginx.                        13802               [OK]                
jwilder/nginx-proxy                Automated Nginx reverse proxy for docker con…   1885                                    [OK]
richarvey/nginx-php-fpm            Container running Nginx + PHP-FPM capable of…   787                                     [OK]

Por otro lado, si prefieres hacerlo de una manera más visual puedes visitar Docker hub. Ahí se puede conseguir cualquier tipo de imagen que te imagines, incluso subir las tuyas. Date una vuelta y mira todas las opciones que están disponibles para descargar. Por ahora no descargaremos ninguna otra.

Ver las imágenes

Si ahora ejecutamos docker images va a aparecer nuestra imagen descargada. Mira el bajo tamaño de la imagen, ¡pesa sólo 13.3kB! Asimismo mira la columna IMAGE ID. Cada imagen, incluida las personalizadas, tiene un id único que la representa y un tag.

docker images
REPOSITORY        TAG            IMAGE ID            CREATED             SIZE
hello-world       latest         bf756fb1ae65        8 months ago        13.3kB

Inspeccionar una imagen

Para inspeccionar una imagen basta con usar docker inspect, seguido del nombre o id de la imagen. Docker imprimirá información relacionada con la imagen en formato JSON.

docker inspect hello-world
[
    {
        "Id": "sha256:bf756fb1ae65adf866bd8c456593cd24beb6a0a061dedf42b26a993176745f6b",
        "RepoTags": [
            "hello-world:latest"
        ],
 ...] 

Historial de una imagen

Docker history nos muestra la historia de una imagen.

docker history hello-world
IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
bf756fb1ae65        9 months ago        /bin/sh -c #(nop)  CMD ["/hello"]               0B                  

Borrar una imagen

Para borrar una imagen existe el comando rmi, sí como rm, pero con la i de «image» a continuación, necesitaremos ya sea su id o su repository y su tag separados por dos puntos «:»

docker rmi repository:tag
docker rmi id_de_la_imagen

Si quisieras borrar la imagen de hello-world sería de la siguiente manera. Escribiendo docker rmi, seguido del nombre de la imagen seáradp por dos puntos de su tag.

docker rmi hello-world:latest

Ver los procesos de Docker

Si queremos ver los procesos ejecutados usamos docker ps con la opción -a. Por favor nota que nuestro contenedor tiene un id y, además un nombre, el cual es generado por Docker automáticamente si no lo especificamos, en este caso «lucid_morse».

docker ps -a
CONTAINER ID   IMAGE              COMMAND        CREATED          STATUS                     PORTS     NAMES
0f100ae4a21e   hello-world        "/hello"       10 minutes ago   Exited (0) 10 minutes ago            lucid_morse

Si le quitamos la opción -a mostrará únicamente los procesos activos. Como el contenedor que creamos a partir de la imagen hello-world terminó de ejecutarse no aparecerá en esta lista.

docker ps
CONTAINER ID   IMAGE              COMMAND        CREATED        STATUS                  PORTS     NAMES

Borrar un contenedor al terminar de ejecutarlo

Cada vez que ejecutamos docker run se crea un nuevo contenedor. Para evitar llenarnos de contenedores podemos borrarlos automáticamente cuando estos terminan su ejecución usando la opción –rm después de docker run. Intenta corriendo la imagen hello-world nuevamente.

docker run --rm hello-world

Si ahora vuelves a ejecutar docker ps -a, verás que no se ha creado un contenedor adicional al que ya teníamos.

docker ps -a
CONTAINER ID   IMAGE              COMMAND        CREATED          STATUS                     PORTS     NAMES
0f100ae4a21e   hello-world        "/hello"       10 minutes ago    Exited (0) 10 minutes ago            lucid_morse

Borrar un contenedor

Para borrar los contenedores, puedes usar el comando docker rm, con el nombre o id del contenedor.

docker rm nombre_o_id_del_contenedor

Borrar todos los contenedores en Docker

Es bastante común querer borrar todos los contenedores en Docker. Para hacerlo necesitamos conseguir todos los id de los contenedores. Si ejecutas el siguiente comando verás como se imprime una lista con todos los id de los contenedores. Así es, es el mismo comando que ejecutamos anteriormente para ver todos los procesos de Docker, la opción -q hace que solo nos muestre los id de esos procesos.

docker ps -aq
8344e4d39fbf
42174ad3810d
...

Ahora que tenemos todos los id, podemos usar esta lista con el comando docker rm para eliminar todos los contenedores.

docker rm $(docker ps -aq)

Acceder a la terminal de un contenedor

El siguiente comando nos introducirá en un contenedor creado a partir de una imagen. Técnicamente lo que hace docker run -it es vincular la entrada estándar (STDIN) de nuestro sistema operativo con la entrada estándar (STDIN) de nuestro contenedor. Esto nos permite correr un contenedor con el que podemos interactuar.

docker run -it ubuntu

Nota como el prompt de la terminal cambiará y nos encontraremos en una terminal desde la cual podremos interactuar.

Intenta ejecutar un ls o un pwd. Podrás notar que estás dentro de un sistema operativo GNU/Linux. Puedes crear archivos, modificarlos, crear carpetas, etc.

Si no sabes nada sobre comandos de GNU/Linux puedes revisar mi entrada de los comandos básicos para refrescar tu memoria.

ls
bin  boot  dev  etc  home  lib  lib32  lib64  libx32  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
pwd
/

Correr un contenedor en segundo plano

Cuando queremos que un contenedor permanezca ejecutándose en segundo plano usamos la etiqueta -d, que viene de detach (también puedes recordarlo fácilmente asociándolo con «daemon»).

docker run -d nginx

Si ahora ejecutamos docker ps, para ver los procesos que están corriendo en Docker, podemos notar que el servidor Nginx que pusimos en marcha con el comando anterior se encuentra activo.

docker ps
CONTAINER ID    IMAGE           COMMAND                  CREATED             STATUS              PORTS        NAMES
8c7fbece083b    nginx           "/docker-entrypoint.…"   8 seconds ago       Up 6 seconds        80/tcp       boring_hugle

Ver los logs de un contenedor

Si nuestro contenedor no pudo ejecutarse de la manera en la que esperábamos, examinar los logs sería un buen punto de partida.

Para esta tarea Docker nos provee del comando docker logs, al cual le especificaremos el contenedor a inspeccionar. Al contenedor del paso anterior se le asignó el nombre de «boring_hugle», aunque el tuyo puede tener hombre.

Por ahora no te preocupes por los errores y las advertencias.

docker logs nombre_del_contenedor
/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
...

Ejecutar un comando en un contenedor corriendo

Para ejecutar un comando en un contenedor que está corriendo se usará el comando exec. Es importante hacer notar que aquí se usa el nombre del contenedor, no de la imagen. El comando siguiente ejecutará bash en el contenedor. Recuerda que para ver los contenedores corriendo usamos «docker ps -a«.

docker exec -it nombre_del_contenedor bash

El uso de docker exec no se limita a entrar en un terminal. Mira lo que sucede si ejecutamos el comando curl a localhost en el contendor donde se está ejecutando Nginx.

docker exec -it boring_hugle curl localhost
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
...

Detener un contenedor

Para detener un contenedor que está corriendo basta con ejecutar docker stop, seguido del nombre o id del contenedor.

docker stop nombre_o_id_del_contenedor

Iniciamos un contenedor

Si queremos correr un contenedor que se encuentra detenido usamos ahora docker start.

docker start nombre_o_id_del_contenedor

Reiniciar un contenedor

Si en lugar de eso queremos reiniciar un contenedor que se encuentra corriendo podemos usar docker restart.

docker restart nombre_o_id_del_contenedor

Exponer un contenedor al exterior

Hasta ahora hemos creado contenedores con los cuales no podemos interaccionar desde el exterior. Si intentamos abrir localhost del veremos que nuestro contenedor de Nginx no nos devuelve nada.

Error de Firefox al intentar acceder al contenedor de Nginx

Esto sucede porque cada contenedor tiene su propia red y sus propios puertos. Si queremos redirigir los puertos del contenedor hacia los puertos de nuestra computadora usamos la opción -p, colocando primero el numero de puerto nuestra computadora separado con dos puntos del que corresponde al contenedor.

docker run -d --name servidorNginx -p 8080:80 nginx

El comando anterior creó una instancia del servidor web Nginx, por lo que redireccionaremos lo que sale de SU puerto 80, a NUESTRO puerto 8080. Al terminar de ejecutar este comando puedes abrir tu navegador y comprobar que, ahora sí, está corriendo un servidor en Nginx.

Persistencia de datos con volúmenes en Docker

Los cambios que hacemos dentro de los contenedores de Docker, tales como crear archivos, modificar configuraciones y otros, se quedan ahí, si nosotros borramos el contenedor la información se pierde para siempre.

Los volúmenes almacenan información que se encuentra fuera de los contenedores y que, por lo tanto, permanece aunque los borremos. Docker almacena estos contenedores en la ubicación «/var/lib/docker/volumes/nombre_del_volumen/_data«. Estas carpetas son solo accesibles para docker y el usuario root, por lo que no tenemos los permisos para modificar su contenido directamente, usando nuestro usuario normal. Si tienes dudas sobre los permisos en GNU/Linux tengo una entrada donde los explico.

Vamos a tratar de dejarlo más claro con un ejemplo:

Crear un volúmen al correr una imagen

Para crear un volumen al correr un contenedor lo especificamos con la opción -v, seguido que queremos asignar al volumen, separado por dos puntos de la ubicación a la que queremos asignar el volumen en el contenedor.

docker run -d -it --name nombre_contenedor -v nombre_del_volumen:/var/lib/mysql ubuntu

Si ahora entramos en la terminal de ese contenedor.

docker exec -it nombre_contenedor bash

Una vez en el contenedor entramos en la carpeta /var/lib/mysql y creamos un archivo llamado db.sql

cd /var/lib/mysql
touch db.sql
exit

Ahora, si hacemos un ls en la ubicación donde Docker guarda los volúmenes deberíamos ver el archivo que acabamos de crear.

sudo ls /var/lib/docker/volumes/nombre_del_volumen/_data
db.sql

¡Ahí está! Si ahora detenemos y borramos el contenedor apreciaremos que nuestro volumen sigue existiendo.

docker stop nombre_contenedor
docker rm nombre_contenedor
sudo ls /var/lib/docker/volumes/nombre_del_volumen/_data
db.sql

¡Sobrevivió al borrado de su contenedor! El archivo db.sql forma parte del volumen llamado nombre_del_volumen (o el que tú le hayas puesto) y para tener acceso a él nuevamente basta con montar el volumen en otro contenedor. Más adelante te explico como. Primero veamos otra manera de crear volúmenes.

Crear volúmenes en Docker

Docker también permite crear un volumen sin correr un contenedor usando el comando docker volume create, seguido del nombre que deseemos para nuestro volumen. Como ya mencionamos, Docker creará cada uno de estos volúmenes en la ubicación «/var/lib/docker/volumes/nombre_del_volumen/».

docker volume create nombre_del_volumen

Inspeccionar volumen

Si inspeccionamos un volumen veremos información relacionada con el volumen que creamos, donde está localizado en nuestro sistema, su nombre y la fecha de creación.

docker volume inspect nombre_del_volumen
[
    {
        "CreatedAt": "2020-10-05T21:16:44-05:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/nombre_del_volumen/_data",
        "Name": "nombre_del_volumen",
        "Options": {},
        "Scope": "local"
    }
]

Listar volúmenes

Para listar todos los volúmenes disponibles usaremos el comando docker volume ls.

docker volume ls
DRIVER              VOLUME NAME
local               nombre_del_volumen

Montar volúmenes en Docker

Para montar un volumen, que hemos creado previamente, en un contenedor usamos la opción –mount, seguido del nombre del volumen (src) y de su destino en el contenedor (dst), separados por una coma

docker run -d --name db --mount src=nombre_del_volumen,dst=/data/db mongo

Borrar volúmenes

Para borrar un volumen usamos el comando docker volume rm. Sin embargo, no podemos borrar un volumen que esté en uso por un contenedor, por lo que es necesario detener y borrar primero su contenedor.

docker volume rm nombre_del_volumen

Limpiar volúmenes

Si tenemos volúmenes que no están asociados a ningún contenedor podemos deshacernos de todos ellos con un único comando: docker volume prune.

docker volume prune
WARNING! This will remove all local volumes not used by at least one container.
Are you sure you want to continue? [y/N] y

Volúmenes conectados

Si queremos que una carpeta de nuestro sistema se sincronice con una carpeta de nuestro contenedor podemos hacerlo también usando volúmenes. En lugar de especificar el nombre del volumen usamos la dirección de la carpeta a sincronizar. A diferencia de los volúmenes que gestionaba Docker, que requerían permisos root aquí nosotros decidimos la carpeta que usará Docker como volumen, por lo que, si tenemos los permisos adecuados, seremos capaces de modificar, crear o leer archivos con nuestro usuario actual.

Cualquier cambio que hagamos en nuestro contenedor o en nuestra máquina va a verse reflejado en ambos. Es decir que si creamos o modificamos un archivo, este va a aparecer tanto en nuestro sistema, como dentro del contenedor.

El siguiente ejemplo crea un contenedor llamado mongoDB (–name mongoDB), en modo detach (-d). La opción -v va a vincular la carpeta especificada antes de los dos puntos, con el directorio del contenedor que especifiquemos después de los dos puntos. Al final va el nombre de nuestra imagen, en este caso nuestra base de datos No-sql llamada mongo.

docker run --name mongoDB -d -v /home/usuario/basesDeDatos/miBaseDeDatosEnMongo:/data/db mongo

Si queremos que el volumen sea de solo lectura bastará con agregar «:ro» al final de nuestra sintaxis.

docker run --name mongoDB -d -v /Users/usuario/Dev/database:/data/db:ro mongo

Listo, con esto basta para tener una idea básica de los volúmenes. Por último, siguen los archivos Dockerfile.

Usando un Dockerfile para crear una imagen

Hasta este momento todo se ha hecho de manera manual, a través de la terminal, pero que tal si queremos una manera de guardar nuestro proceso de transformaciones a una imagen para poder compartirlo fácilmente. Los Dockerfile permiten justamente eso y facilitan poder diseñar una imagen acorde a nuestras caprichosas exigencias.

Un Dockerfile es un archivo sin extensión donde especificaremos una serie de transformaciones, ordenadas, que queremos aplicar a una imagen. En un Dockerfile podremos agregar archivos de configuración personalizados, código propio, librerías extras, abrir puertos personalizados o lo que querramos.

Preparación de un Dockerfile

Para este ejemplo vamos a crear una carpeta nueva, donde crearemos el Dockerfile. Recuerda, que un Dockerfile es solo un archivo sin extensión.

mkdir dockerTest
cd dockerTest
touch Dockerfile

Ahora creamos un archivo de requerimientos para pip que incluya a Django y a gunicorn. En caso de que no lo sepas, Django es un framework de desarrollo web y gunicorn un servidor frecuentemente usado en conjunción con Django.

printf "Django==3.0.1\ngunicorn==19.7.1" > requirements.txt

A continuación, vamos a crear un proyecto con django para usarlo como base para nuestro proyecto. Asegúrate de tener instalado pip en tu sistema o no podrás usar django-admin. En caso de que no puedas descargar la versión 3.0.1 puedes usar cualquier otra y también debería funcionar.

sudo pip install Django==3.0.1
django-admin startproject myDjangoDockerApp

Si ahora revisamos nuestra carpeta actual veremos la siguiente estructura de archivos y carpetas. Si no conoces Django ignora los archivos, lo importante por ahora será que sepas que gunicorn únicamente necesita saber donde está el archivo wsgi.py para iniciar el servidor.

.
├── Dockerfile
├── myDockerDjangoApp
│   ├── manage.py
│   └── myDockerDjangoApp
│       ├── __init__.py
│       ├── settings.py
│       ├── urls.py
│       └── wsgi.py
└── requirements.txt

Ejemplo, creación y análisis de un Dockerfile

Con todos estos archivos vamos a crear una imagen personalizada para nuestro Dockerfile. Abre el archivo Dockerfile con tu editor de texto favorito y vamos a escribir el siguiente contenido.

FROM python:3.6
ENV PYTHONUNBUFFERED 1

ADD . /app/

WORKDIR /app/myDockerDjangoApp

RUN pip install -r /app/requirements.txt

EXPOSE 8000
ENV PORT 8000

CMD ["gunicorn", "myDockerDjangoApp.wsgi"]
  • FROM python:3.6: Todos los Dockerfile necesitan una imagen de la cual partir, en este caso esa imagen es python:3.6
  • ENV PYTHONBUFFERED 1: Permite que podamos leer los logs de Python en nuestra terminal
  • ADD . /app/: Agrega todos los archivos en la carpeta actual a la carpeta /app/. También sirve COPY, la diferencia radica en que APP acepta archivos comprimidos o una url.
  • WORKDIR /app/myDockerDjangoApp: Establece la carpeta /app/myDockerDjangoApp como la carpeta base a usar al correr comandos con CMD, RUN, ADD o COPY
  • RUN pip install -r /app/requirements.txt: RUN permite ejecutar comandos, los cuales se ejecutan al momento de compilar la imagen y quedan grabados como una capa nueva en la imagen. Usaremos RUN para instalar todas las dependencias que especificamos en el archivo requirments.txt (solo Django y Gunicorn).
  • EXPOSE 8000: Expone el puerto 8000 al exterior.
  • ENV PORT 8000: Crea una variable de entorno llamada PORT con el valor de 8000. Esto nos servirá para poder acceder al puerto.
  • CMD [«gunicorn», «myDockerDjangoApp.wsgi»]: CMD ejecuta un comando al momento de poner en marcha un contenedor a partir de una imagen, los comandos y los argumentos se separan como si fueran una lista de Python. En este caso, como mencioné arriba, gunicorn solo necesita saber donde está el archivo wsgi que generó django automáticamente.

El orden es importante en un Dockerfile

La compilación de un Dockerfile es un proceso secuencial, cada paso crea una imagen intermediaria que Docker puede guardar en cache. Docker usa esa cache para evitar tener que repetir pasos innecesarios cuando ocurre un cambio en un Dockerfile, es decir que si tú realizas un cambio en uno de los pasos, Docker tratará de usar sus datos en cache para no repetir todos los pasos anteriores. Ten en cuenta el orden en el que realizas tus instrucciones para evitarte compilaciones de imágenes costosas en tiempo y recursos.

Sending build context to Docker daemon   12.8kB
Step 1/8 : FROM python:3.6
 ---> 46ff56815c7c
Step 2/8 : ENV PYTHONUNBUFFERED 1
 ---> Using cache
 ---> c55438b3c6a0
Step 3/8 : ADD . /app/
 ---> Using cache
 ---> ecedebf26f36
Step 4/8 : WORKDIR /app/myDockerDjangoApp
 ---> Using cache
 ---> 83b5ccaa1cc6
Step 5/8 : RUN pip install -r /app/requirements.txt
 ---> Using cache
 ---> 6cb2683c8fa8
Step 6/8 : EXPOSE 8000
 ---> Using cache
 ---> 744b46577c43
Step 7/8 : ENV PORT 8000
 ---> Using cache
 ---> 03111761fb54
Step 8/8 : CMD ["gunicorn", "myDockerDjangoApp.wsgi"]
 ---> Using cache
 ---> 6e3ffe358338
Successfully built 6e3ffe358338
Successfully tagged djangocontainer:0.1

Compilación de un Dockerfile

Para compilar un Dockerfile y crear una imagen personalizada creada a partir del contenido de nuestro archivo, basta con ejecutar el comando docker build y establecer la localización del Dockerfile. Docker build nos permite especificar un tagname y una versión, separados por dos puntos «:», usando la etiqueta –tag. Nota que el punto de al final no es una mancha en tu pantalla o un error, sino que hace referencia a la carpeta en la que nos encontramos.

docker build --tag djangocontainer:0.1 .

Puedes ver que nuestra imagen ha sido creada ejecutando el comando docker images

docker images
REPOSITORY                                      TAG                 IMAGE ID            CREATED              SIZE
djangocontainer                                 0.1                 6e3ffe358338        About a minute ago   912MB

Ahora que ya contamos con la imagen basta con ejecutarla. Para este ejemplo vincularemos nuestro puerto 8000 con el puerto 8000 de nuestro contenedor, ejecutaremos nuestro contenedor en segundo plano y lo nombraremos test_container.

docker run -p 8000:8000 -d --name test_container djangocontainer:0.1

¡Ahora viene la mejor parte! El momento donde averiguamos si nuestro código funciona o hicimos un desastre completo.

curl localhost:8000
<!doctype html>
<html>
    <head>
        <meta charset="utf-8">
...

Si abrimos nuestro navegador y entramos a nuestro localhost en el puerto 8000 veremos el cohete de Django indicando que todo funcionó perfectamente. Gunicorn está sirviendo nuestra aplicación de Django en el puerto 8000, al que podemos acceder a través de nuestro puerto del mismo número.

Este tutorial cubrió solo lo básico sobre Docker. Entra en la siguiente entrada que tratará sobre docker compose, una herramienta para crear aplicaciones con multiples contenedores.

Presume lo que aprendiste en redes

Únete a mi comunidad de lectores

Recibe contenido como este por correo electrónico, una vez por semana, de manera totalmente gratuita.

* Campo obligatorio