Docker es una de las herramientas más populares en el mundo del desarrollo de software, especialmente en el ámbito de la virtualización y la gestión de aplicaciones. Empecemos por lo básico, partiendo con las definiciones y avanzamos en aspectos particulares más adelante.

¿Qué es Docker?

Docker es una plataforma de código abierto que permite a los desarrolladores crear, implementar y ejecutar aplicaciones en contenedores, ¿pero qué es un contenedor?

Un contenedor es una unidad ligera y portátil que incluye todo lo necesario para que una aplicación funcione: código, bibliotecas, dependencias y configuraciones. Más adelante encontrarás una definición formal tanto de imagen como de contenedor.

Esto asegura que las aplicaciones se ejecuten de manera consistente en cualquier entorno, ya sea en tu máquina local, en un servidor o en la nube.

Aspectos importantes de usar Docker

Docker ha revolucionado la forma en que se desarrollan y despliegan aplicaciones debido a sus múltiples beneficios:

• Portabilidad: Los contenedores Docker funcionan de la misma manera en cualquier sistema operativo que soporte Docker, eliminando problemas de compatibilidad.
• Eficiencia: Los contenedores son más ligeros que las máquinas virtuales, ya que comparten el kernel del sistema operativo, lo que reduce el uso de recursos.
• Escalabilidad: Facilita la creación de entornos replicables, lo que permite escalar aplicaciones rápidamente.
• Aislamiento: Cada contenedor es independiente, lo que evita conflictos entre aplicaciones o dependencias.
• Automatización: Docker simplifica los procesos de integración y entrega continua (CI/CD).

Guía rápida de instalación

Para instalar Docker en tu sistema, sigue estos pasos básicos:

1. Linux (Ubuntu): bashCopy Codesudo apt update sudo apt install docker.io sudo systemctl start docker sudo systemctl enable docker
2. Windows/Mac:

• Descarga Docker Desktop desde docker.com.
• Sigue las instrucciones del instalador.
• Asegúrate de habilitar la integración con WSL 2 (en Windows).

Verifica la instalación:
Ejecuta el siguiente comando para confirmar que Docker está instalado correctamente: bashCopy Codedocker --version

Quieres un paso a paso de instalar Docker, acá te comparto un contenido donde mostramos la instalación en Windows usando WSL2, así que funciona también para Linux.

¿Qué es una imagen?

Una imagen en Docker es una plantilla inmutable que contiene todo lo necesario para ejecutar una aplicación, incluyendo el sistema operativo base, las dependencias y el código de la aplicación. Las imágenes son la base para crear contenedores y se almacenan en repositorios como Docker Hub.

¿Qué es un contenedor?

Un contenedor es una instancia en ejecución de una imagen. Es un entorno aislado que ejecuta una aplicación de manera independiente. Los contenedores son ligeros, rápidos y desechables, lo que significa que puedes detenerlos, eliminarlos y recrearlos fácilmente.

¿Cómo correr un contenedor de una imagen?

Para ejecutar un contenedor a partir de una imagen, utiliza el siguiente comando:

docker run -d --name nombre_del_contenedor imagen

Por ejemplo, para ejecutar un servidor web Nginx:

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

Este comando ejecuta un contenedor en segundo plano (-d), lo nombra como mi_nginx y mapea el puerto 80 del contenedor al puerto 8080 de tu máquina.

Con esto tendras un servidor web en tu máquina ejecutandose en el puerto 8080.

¿Qué es dockerizar una aplicación?

Dockerizar una aplicación significa empaquetarla en un contenedor Docker para que pueda ejecutarse de manera consistente en cualquier entorno. Esto incluye agregar todas las dependencias, configuraciones y scripts necesarios en una imagen Docker.

¿Qué es el Dockerfile?

El Dockerfile es un archivo de texto que contiene una serie de instrucciones para construir una imagen Docker. Cada instrucción en el Dockerfile define una capa en la imagen, lo que permite que Docker reutilice capas anteriores para optimizar el proceso de construcción.

Comandos básicos del Dockerfile

Algunos comandos comunes en un Dockerfile son:

• FROM: Define la imagen base. dockerfileCopy CodeFROM node:16
• WORKDIR: Establece el directorio de trabajo dentro del contenedor. dockerfileCopy CodeWORKDIR /app
• COPY: Copia archivos desde el sistema host al contenedor. dockerfileCopy CodeCOPY . .
• RUN: Ejecuta comandos durante la construcción de la imagen. dockerfileCopy CodeRUN npm install
• CMD: Define el comando que se ejecutará cuando el contenedor inicie. dockerfileCopy CodeCMD ["npm", "start"]

¿Cómo dockerizar una aplicación Node.js?

Para dockerizar una aplicación Node.js, sigue estos pasos:

Crea un archivo Dockerfile:
Este archivo define cómo se construirá la imagen Docker. Un ejemplo básico para una aplicación Node.js sería:

# Usa una imagen base de Node.js 
FROM node:16 

# Establece el directorio de trabajo 
WORKDIR /app 

# Copia la definición del proyecto 
COPY package*.json ./ 

#Carga las dependencias
RUN npm install 

# Copia los archivos de la aplicación 
COPY . . 

# Expone el puerto de la aplicación 
EXPOSE 3000 

# Comando para ejecutar la aplicación 
CMD ["npm", "start"]

Crea un archivo .dockerignore:
Este archivo especifica qué archivos o carpetas deben excluirse al construir la imagen. Por ejemplo:

node_modules  
npm-debug.log  

Construye la imagen:

docker build -t mi_app_node .

Ejecuta el contenedor:

docker run -d -p 3000:3000 mi_app_node

Importancia del archivo .dockerignore

El archivo .dockerignore es crucial para optimizar el proceso de construcción de imágenes Docker. Este archivo especifica qué archivos o carpetas deben excluirse al construir la imagen, lo que reduce el tamaño de la imagen y mejora la seguridad al evitar incluir archivos sensibles o innecesarios, como:

• Archivos de configuración locales.
• Dependencias ya instaladas (como node_modules).
• Archivos temporales o de depuración.

Un ejemplo de .dockerignore sería:

node_modules  
*.log  
.env  

Veamos un ejemplo práctico de como dockerizar una aplicación Node.

En este post aprenderás cómo configurar un entorno de desarrollo con recarga en vivo habilitada (live reload). Esto te permitirá convertir una aplicación legacy (código anticuado u obsoleto) para que use Docker, volúmenes de Docker y docker-compose.

Algunos desarrolladores levantan sus narices cuando hablan sobre usar Docker para su entorno de desarrollo. Dicen que Docker no es bueno para el desarrollo porque siempre necesita reconstruir toda la imagen para reflejar todas las nuevas modificaciones. Esto lo hace improductivo y lento.

En este artículo, nuestro objetivo es cambiar esta manera de pensar demostrando cómo las configuraciones simples pueden resultar en muchos beneficios como un entorno confiable sobre entornos de producción y desarrollo.  

Al final de este post habrás aprendido a cómo:

• Convertir una aplicación "legacy" para que se ejecute dentro de un contenedor de Docker.
• Permitir el cacheo de dependencias en módulos de Node.js.
• Permitir la recarga en vivo usando volúmenes de Docker.
• Agregar todos los servicios dentro de docker-compose.

Requerimientos

En los próximos pasos, clonarás un proyecto existente para ejecutar todos los ejemplos en este artículo. Antes de empezar a codificar asegúrate de tener las siguientes herramientas instaladas en tu máquina:

• Docker and Docker compose
• Node.js 10+
• Git

¿Por qué usar Docker?

Más y más tecnologías innovadoras están siendo lanzadas al internet todo el tiempo. Son estables, y son divertidas para desarrollar y lanzar, pero su comportamiento no es consistente al trabajar sobre diferentes entornos. Así que los desarrolladores crearon Docker para ayudar reducir las probabilidades de posibles errores.

Docker es una de mis herramientas favoritas con la que trabajo todos los días en el escritorio, en la web y con aplicaciones IoT. Me ha dado el poder de no solamente mover aplicaciones a través de diferentes entornos, sino también de mantener mi entorno local lo más limpio posible.

Los desarrolladores que trabajan con tecnologías innovadoras siempre están trabajando con algo nuevo. Pero ¿qué hay de las aplicaciones legacy? ¿Deberíamos sólo reescribir todo con nuevas tecnologías? Sé que esto no es tan simple como parece. Deberíamos trabajar en nuevas cosas, pero también hacer mejoras a las aplicaciones existentes.

Digamos que te has decidido a mover servidores de Windows a servidores de Unix. ¿Cómo lo harías? ¿Conoces la lista completa de cada dependencia que tu aplicación requiere para trabajar?

¿Cómo debería lucir un entorno de desarrollo?

Los desarrolladores siempre han intentado de ser más productivos agregando plugins, boilerplates, y bases de código en sus editores/IDEs/terminales. El mejor entorno en mi opinión debería de ser:

1. Fácil de ejecutar y probar.
2. Ser un entorno agnóstico.
3. Rápido de evaluar modificaciones.
4. Fácil de replicar en cualquier máquina.

Siguiendo estos principios, configuraremos una aplicación a lo largo de las siguientes secciones de este artículo. También, si nunca has oído sobre recarga en vivo (o recarga caliente), es una característica que observa los cambios en tu código y reinicia el servidor si es necesario. Así que no necesitas ir y venir, reiniciando tu aplicación o inclusive reconstruyendo el sistema.

Comenzando

Primero, necesitarás tener una carpeta vacía llamado post-docker-livereload el cual usarás como un espacio de trabajo. Ve al repositorio de Github y clónalo en tu carpeta post-docker-live-reload.

Segundo, analicemos lo que la aplicación requiere. Si miras al archivo README.md, hay algunas instrucciones indicando cómo ejecutar esta aplicación como se muestra en la imagen de abajo:

Se requiere la versión 10 de Node.js o superior y MongoDB. En vez de instalar MongoDB en tu máquina de entorno local, lo instalarás usando Docker. También lo expondrás en localhost:27107 así las aplicaciones que no se ejecutan a través de Docker podrán acceder sin conocer la dirección IP interna de Docker.

Copia el comando de abajo y pégalo en tu terminal:

docker run --name mongodb -p 27017:27017 -d mongo:4

Usando el comando de arriba, descargará y ejecutará la instancia de MongoDB. Fíjate que si ya tienes una instancia con este nombre lanzará un error de nombre inválido.

Si ves el error, ejecuta docker rm mongodb y de esta forma removerá cualquier instancia previa, así podrás ejecutar el comando docker run nuevamente.

Profundizando en la aplicación

El archivo README.md dice que necesitas una instancia de MongoDB ejecutándose antes de comenzar tu aplicación, en conjunto con Node.js.

Si tienes Node.js instalado, ve a la carpeta nodejs-with-mongodb-api-example y ejecuta los siguientes comandos:

npm i 
npm run build 
npm start

Después de ejecutar estos comandos, puedes ir al navegador en http://localhost:3000 y ver la aplicación ejecutándose como se muestra en la imagen de abajo:

Ten en cuenta que la aplicación ya tiene un comando de activar recarga en vivo el cual es npm run dev:watch. El pipeline (flujo o embudo) debería reflejar los siguientes pasos:

1. El desarrollador edita archivos de Typescript.
2. Typescript "transpila" (compilar entre lenguajes) los archivos a JavaScript.
3. El servidor ve los cambios realizados en JavaScript y reinicia el servidor de Node.js.

Así que duplicar los archivos a contenedores de Docker reflejará todos los cambios en el contenedor. El npm run build:watch de la aplicación capturará los cambios y generará archivos de salida en la carpeta lib, de esa forma npm run dev:run reiniciará el servidor cada vez que se haya disparado.

Dockerizando aplicaciones

Si Docker es un mundo completamente nuevo para ti, ¡no temas! Lo configurarás desde cero. Necesitarás crear un par de archivos para empezar:

1. Dockerfile - un archivo de recibo, que enlista instrucciones para instalar y ejecutar tu aplicación.
2. .dockerignore - archivo que enlista cuáles archivos no irán dentro de la instancia del contenedor de Docker.

Creando el archivo Docker

El archivo Docker es el concepto clave aquí. Allí especificas los pasos y dependencias para preparar y ejecutar la aplicación. Siempre y cuando hayas leído el archivo README.md, será fácil de implementar el archivo de recibo.

Voy a poner todo el archivo abajo y lo indagaremos más adelante. En tu carpeta nodejs-with-mongodb-api-example crea un archivo Dockerfile y pega el código de abajo:

FROM node:14-alpine

WORKDIR /src

ADD package.json /src 

RUN npm i --silent

ADD . /src 

RUN npm run build 

CMD npm start

¿Qué está ocurriendo ahí?

• En la línea 1. Usa como su imagen base la versión alpine de Node: Node.js 14.
• De las líneas 2 a 4. Copia e instala dependencias de Node.js del host al contenedor. Fíjate que el orden ahí es importante. Agregar un archivo package.json a la carpeta src antes de restaurar las dependencias los guardará en caché y prevendrá que reinstale los paquetes cada vez que necesites construir tu imagen.
• De las líneas 6 a 7. Ejecuta comandos para el proceso de compilación y luego comienza el programa como se menciona en el archivo README.md.

Ignorando archivos innecesarios con .dockerignore

También, estoy trabajando en un sistema basado en OSX y el contenedor de Docker se ejecutará en un sistema basado en Linux Alpine. Cuando ejecutes npm install restaurará las dependencias para los entornos específicos.

Ahora crearás un archivo para ignorar el código generado desde tu máquina local como node_modules y lib. Así que cuando copies todos los archivos del directorio actual al contenedor este no tendrá versiones de paquetes inválidos.

En la carpeta nodejs-with-mongodb-api-example crea un archivo .dockerignore y copia el código de abajo:

node_modules/
lib/

Construyendo la imagen de docker

Prefiero ejecuta esta aplicación desde la carpeta rootFolder. Regresa a la carpeta post-docker-live-reload y ejecuta los siguientes comandos para preparar una imagen para su posterior uso:

docker build -t app nodejs-with-mongodb-api-example

Fíjate que el comando de arriba usa la bandera -t para especificar el nombre de la imagen y, justo después de eso, la carpeta que contiene el archivo Dockerfile.

Trabajando con volúmenes

Antes de ejecutar la aplicación, hagamos algunos trucos para mejorar nuestra experiencia en los contenedores de Docker.

Los volúmenes de Docker son una característica que permite duplicar archivos a entre tu máquina local y tu entorno de Docker. También puedes compartir volúmenes en los contenedores y reusarlos para cachear dependencias.

Tu objetivo es mirar cualquier cambio en los archivos locales .ts y duplicar esos cambios en el contenedor. Aunque los archivos y la carpeta node_modules están en la misma ruta.

¿Recuerdas que dije que las dependencias en cada sistema operativo serían diferentes? Pues para asegurarnos de que nuestro entorno local no afectará al entorno de Docker cuando se dupliquen archivos, aislaremos la carpeta node_modules del contenedor en un volumen distinto.

Consecuentemente, cuando se crea la carpeta node_modules en el contenedor, esto no creará la carpeta en el entorno de la máquina local. Ejecuta el comando de abajo en tu terminal para crearla:

docker volume create --name nodemodules

Ejecutar y activa recarga en vivo

Como sabes, el npm run dev:watch especificado en el README.md te muestra cómo activar la recarga en vivo. El problema es que estás codificando en una máquina local y debe reflejarse directamente en tu contenedor.

Ejecutando los siguientes comandos enlazarás tu entorno local con el contenedor de Docker así que cualquier cambio en nodejs-with-mongodb-api-example afectará la carpeta src del contenedor.

docker run \
    --name app \
    --link mongodb \
    -e MONGO_URL=mongodb \
    -e PORT=4000 \
    -p 4000:4000 \
    -v `pwd`/nodejs-with-mongodb-api-example:/src \
    -v nodemodules:/src/node_modules \
    app npm run dev:watch

Indaguemos que está ocurriendo ahí:

• --link da permiso a la aplicación para acceder a la instancia de MongoDB.
• -e son las variables de entorno. Como se mencionó en el archivo README.md puedes especificar la cadena de conexión de MongoDB que quieres conectar sobrescribiendo la variable MONGO_URL. Sobrescribe la variable PORT si quieres ejecutarlo en un puerto distinto. Fíjate que el valor mongodb es el mismo nombre que usamos para crear nuestra instancia de MongoDB en las secciones anteriores. Este valor es también un alias para la IP de la instancia interna de MongoDB.
• -v - vincula el directorio actual al contenedor de Docker usando un volumen virtual. Usando el comando pwd puedes obtener la ruta absoluta hacia tu directorio de trabajo actual y luego la carpeta que quieres duplicar en el contenedor de Docker. Está el :/src. La ruta src es la instrucción WORKDIR definida en el Dockerfile por lo tanto duplicamos la carpeta local en la carpeta src del contenedor de Docker.
• -v el segundo volumen ahí duplicará el volumen individual que creamos en la carpeta node_modules del contenedor.
• app el nombre de la imagen.
• npm run dev:watch este último comando sobrescribirá la instrucción CMD desde el archivo Dockerfile.

Después de ejecutar el comando de abajo, puedes lanzar el navegador después de cambiar el archivo index.ts para ver los resultados. El video de abajo demuestra estos pasos en la práctica:

Resumiendo

Sabes que trabajar con los comandos del shell funciona. Pero no es tan común para usarlos en este caso, y no es productivo ejecutar todos esos comandos; construyendo imágenes y gestionando instancias manualmente. ¡Así que usa compose!

Docker compose es una forma de simplificar la agregación y enlazamientos de servicios. Puedes especificar las bases de datos, logs, aplicación, volúmenes, redes, y así sucesivamente.

Primero, necesitas quitar todas las instancias activas para evitar conflictos en puertos expuestos. Ejecuta los siguientes comandos en tu terminal para remover volúmenes, servicios y contenedores:

docker rm app 
docker volume rm nodemodules
docker stop $(docker ps -aq)
docker rm $(docker ps -aq)

El archivo docker-compose

Crea un archivo docker-compose.yml en tu carpeta post-docker-livereload usando los datos de abajo:

version: '3'
services:
    mongodb:
        image: mongo:4
        ports:
            - 27017:27017
    app:
        build: nodejs-with-mongodb-api-example
        command: npm run dev:watch
        ports:
            - 4000:4000
        environment: 
            MONGO_URL: mongodb
            PORT: 4000
        volumes:
            - ./nodejs-with-mongodb-api-example:/src/
            - nodemodules:/src/node_modules
        links:
            - mongodb
        depends_on: 
            - mongodb

volumes:
    nodemodules: {}

El archivo de arriba especifica los recursos por secciones. Fíjate que tienes las secciones links y depends_on allí. El campo links es la misma bandera que has usado en tu comando de shell. El depends_on se asegurará que el MongoDB es una dependencia para ejecutar tu aplicación. Ejecutará el MongoDB antes de tu aplicación, ¡como si fuera magia!

Volviendo a tu terminal, para iniciar todos los servicios y construir la imagen de Docker, crear volúmenes y enlazar servicios, ejecuta el siguiente comando:

docker-compose up --build

Si necesitas remover todos los servicios creados antes por el Dockerfile también puedes ejecutar docker-compose down.

¡Docker es tu amigo!

Así es, mi amigo. Docker te puede ayudar para prevenir muchos posibles errores antes de que ocurran. Puedes usarlos para aplicaciones front y back end. Inclusive para IoT cuando necesites controlar el hardware, puedes especificar políticas para usarlo.

Para tus próximos pasos, recomiendo mucho que mires a orquestadores de contenedores tales como Kubernetes y Docker swarm. Podrían mejorar mucho más tus aplicaciones existentes y ayudarte a ir al siguiente nivel.

Gracias por leer

Aprecio mucho el tiempo que pasamos juntos. Espero que este contenido sea más que solo texto. Espero que te ayude a pensar mejor y programar mejor. Sígueme en Twitter y mira my blog personal donde comparto todo mi contenido de valor.

¡Nos vemos!

Docker ha sido ampliamente adoptado y se utiliza para ejecutar y escalar aplicaciones en producción. Además, se puede usar para iniciar aplicaciones rápidamente ejecutando un solo comando de Docker.

Las empresas también están invirtiendo cada vez más esfuerzos para mejorar el desarrollo en contenedores Docker locales y remotos, lo que también tiene muchas ventajas.

Puedes obtener la información básica sobre la configuración de su Docker ejecutando:

$ docker info

...
 Storage Driver: overlay2
 Docker Root Dir: /var/lib/docker
...

El resultado contiene información sobre su controlador de almacenamiento, así como del directorio raíz de Docker.

La ubicación de almacenamiento de imágenes y contenedores de Docker

Un contenedor de Docker consta de configuraciones de red, volúmenes e imágenes. La ubicación de los archivos de Docker depende de su sistema operativo. Aquí hay una descripción general de los sistemas operativos más utilizados:

• Ubuntu: /var/lib/docker/
• Fedora: /var/lib/docker/
• Debian: /var/lib/docker/
• Windows: C:\ProgramData\DockerDesktop
• MacOS: ~/Library/Containers/com.docker.docker/Data/vms/0/

En macOS y Windows, Docker ejecuta contenedores de Linux en un entorno virtual. Por lo tanto, hay algunas cosas adicionales que debe saber.

Docker para Mac

Docker no es compatible de forma nativa con macOS, de allí que Hyperkit es usado para correr una imagen virtual. Esta imagen virtual está localizada en:

~/Library/Containers/com.docker.docker/Data/vms/0

Dentro de la imagen virtual, la ruta es la que presenta Docker por default: /var/lib/docker.

Podemos investigar la dirección de nuestro directorio de Docker mediante el shell en el entorno virtual:

$ screen ~/Library/Containers/com.docker.docker/Data/vms/0/tty 

Puedes cerrar esta sesión presionando Ctrl+a, seguido de k e y.

Docker para Windows

En Windows, Docker está un poco fraccionado. Hay contenedores nativos de Windows que funcionan de manera similar a los contenedores de Linux. Los contenedores de Linux se ejecutan en un entorno virtual mínimo basado en Hyper-V.
La configuración y la imagen virtual para ejecutar las imágenes de Linux se guardan en la carpeta raíz predeterminada de Docker.

C:\ProgramData\DockerDesktop

Si inspeccionas imágenes regulares, obtendrá rutas de Linux como:

$ docker inspect nginx

...
"UpperDir": "/var/lib/docker/overlay2/585...9eb/diff"
...

Puedes conectarte con la imagen virtual mediante:

docker run -it --privileged --pid=host debian nsenter -t 1 -m -u -i sh

Luego, puedes ir a la localización referenciada:

$ cd /var/lib/docker/overlay2/585...9eb/
$ ls -lah

drwx------    4 root     root        4.0K Feb  6 06:56 .
drwx------   13 root     root        4.0K Feb  6 09:17 ..
drwxr-xr-x    3 root     root        4.0K Feb  6 06:56 diff
-rw-r--r--    1 root     root          26 Feb  6 06:56 link
-rw-r--r--    1 root     root          57 Feb  6 06:56 lower
drwx------    2 root     root        4.0K Feb  6 06:56 work

La estructura interna de una carpeta de raíz de Docker

En el interior de /var/lib/docker se almacena diferente información. Por ejemplo, datos para contenedor, volúmenes, compilaciones, redes y clústeres.

$ ls -la /var/lib/docker

total 152
drwx--x--x   15 root     root          4096 Feb  1 13:09 .
drwxr-xr-x   13 root     root          4096 Aug  1  2019 ..
drwx------    2 root     root          4096 May 20  2019 builder
drwx------    4 root     root          4096 May 20  2019 buildkit
drwx------    3 root     root          4096 May 20  2019 containerd
drwx------    2 root     root         12288 Feb  3 19:35 containers
drwx------    3 root     root          4096 May 20  2019 image
drwxr-x---    3 root     root          4096 May 20  2019 network
drwx------    6 root     root         77824 Feb  3 19:37 overlay2
drwx------    4 root     root          4096 May 20  2019 plugins
drwx------    2 root     root          4096 Feb  1 13:09 runtimes
drwx------    2 root     root          4096 May 20  2019 swarm
drwx------    2 root     root          4096 Feb  3 19:37 tmp
drwx------    2 root     root          4096 May 20  2019 trust
drwx------   15 root     root         12288 Feb  3 19:35 volumes

Imágenes en Docker

Los contenidos más pesados son, a menudo, las imágenes. Si usas la superposición del controlador de almacenamiento predeterminado, tus imágenes de Docker se almacenarán en /var/lib/docker/overlay2.

Allí, podrás encontrar diferentes archivos que representan capas de solo lectura de una imagen de Docker y una capa superior que contiene sus cambios.
Exploremos el contenido usando un ejemplo:

$ docker image pull nginx
$ docker image inspect nginx

[
    {
        "Id": "sha256:207...6e1",
        "RepoTags": [
            "nginx:latest"
        ],
        "RepoDigests": [
            "nginx@sha256:ad5...c6f"
        ],
        "Parent": "",
 ...
        "Architecture": "amd64",
        "Os": "linux",
        "Size": 126698063,
        "VirtualSize": 126698063,
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/585...9eb/diff:
                             /var/lib/docker/overlay2/585...9eb/diff",
                "MergedDir": "/var/lib/docker/overlay2/585...9eb/merged",
                "UpperDir": "/var/lib/docker/overlay2/585...9eb/diff",
                "WorkDir": "/var/lib/docker/overlay2/585...9eb/work"
            },
...

LowerDir contiene las capas de solo lectura de una imagen. La capa de lectura y escritura que representa los cambios es parte de UpperDir. En este caso, la carpeta NGINX UpperDir contiene los archivos de registro:

$ ls -la /var/lib/docker/overlay2/585...9eb/diff

total 8
drwxr-xr-x    2 root     root    4096 Feb  2 08:06 .
drwxr-xr-x    3 root     root    4096 Feb  2 08:06 ..
lrwxrwxrwx    1 root     root      11 Feb  2 08:06 access.log -> /dev/stdout
lrwxrwxrwx    1 root     root      11 Feb  2 08:06 error.log -> /dev/stderr

MergedDir representa el resultado de UpperDir y LowerDir que utiliza Docker para ejecutar el contenedor. WorkDir es un directorio interno para overlay2 y debe estar vacío.

Volúmenes en Docker

Es posible agregar un almacenamiento persistente a los contenedores para conservar los datos durante más tiempo del que existe en el contenedor o para compartir el volumen con el host o con otros contenedores. Un contenedor se puede iniciar con un volumen usando la opción -v:

$ docker run --name nginx_container -v /var/log nginx

Podemos obtener información sobre la ubicación del volumen conectado mediante:

$ docker inspect nginx_container

...
"Mounts": [
            {
                "Type": "volume",
                "Name": "1e4...d9c",
                "Source": "/var/lib/docker/volumes/1e4...d9c/_data",
                "Destination": "/var/log",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ],
...

El directorio al que se hace referencia contiene archivos de la ubicación /var/log del contenedor NGINX.

$ ls -lah /var/lib/docker/volumes/1e4...d9c/_data

total 88
drwxr-xr-x    4 root     root        4.0K Feb  3 21:02 .
drwxr-xr-x    3 root     root        4.0K Feb  3 21:02 ..
drwxr-xr-x    2 root     root        4.0K Feb  3 21:02 apt
-rw-rw----    1 root     43             0 Jan 30 00:00 btmp
-rw-r--r--    1 root     root       34.7K Feb  2 08:06 dpkg.log
-rw-r--r--    1 root     root        3.2K Feb  2 08:06 faillog
-rw-rw-r--    1 root     43         29.1K Feb  2 08:06 lastlog
drwxr-xr-x    2 root     root        4.0K Feb  3 21:02 nginx
-rw-rw-r--    1 root     43             0 Jan 30 00:00 w

Limpiar el espacio utilizado por Docker

Se recomienda utilizar el comando Docker para limpiar los contenedores no utilizados. El contenedor, las redes, las imágenes y la caché de compilación se pueden limpiar ejecutando:

$ docker system prune -a

Además, también puede eliminar volúmenes no utilizados ejecutando:

$ docker volumes prune

Resumen

Docker es una parte importante de los entornos y herramientas de muchas personas. A veces, Docker se siente un poco mágico al resolver problemas de una manera muy inteligente sin decirle al usuario cómo se hacen las cosas detrás de escena. Aun así, Docker es una herramienta común que almacena sus partes pesadas en ubicaciones que se pueden abrir y cambiar.

A veces, el almacenamiento puede llenarse rápidamente. Por lo tanto, es útil inspeccionar su carpeta raíz, pero no se recomienda eliminar o cambiar ningún archivo manualmente. En su lugar, los comandos de poda se pueden utilizar para liberar espacio en disco.

Espero que hayas disfrutado el artículo. Si te gusta y sientes la necesidad de un aplauso, sígueme en Twitter. Trabajo en eBay Kleinanzeigen, una de las mayores empresas de anuncios clasificados del mundo. Por cierto, ¡estamos contratando!

Feliz exploración de Docker :)

Referencias

Documentación del Storage Diver de Docker:
https://docs.docker.com/storage/storagedriver/

Sistema de archivos de superposición de documentación
https://www.kernel.org/doc/Documentation/filesystems/overlayfs.txt

Docker brinda la capacidad de empaquetar y ejecutar una aplicación en un entorno aislado llamado contenedor.

Sé lo que estás pensando: Venga, no otra publicación que explique qué es Docker, ¡Está en todas partes en estos días!

Pero no se preocupe, nos estamos saltando esa introducción básica. El público objetivo de este artículo ya debería tener una comprensión básica de lo que son Docker y Contenedores.

Pero, ¿Alguna vez se ha preguntado cómo obtener una dirección IP del contenedor Docker?

Explicando redes en Docker

Primero, comprendamos cómo funciona las redes en Docker. Para eso, nos vamos a centrar en la red predeterminada bridge. Cuando usa Docker, si no especifica un controlador, este es el tipo de red que está usando.

La red bridge funciona como una red privada interna del host para que los contenedores puedan comunicarse. El acceso externo se otorga al exponer los puertos de los contenedores.

Las redes bridge se utilizan cuando sus aplicaciones se ejecutan en contenedores independientes que necesitan comunicarse.

En la imagen de arriba, db y web pueden comunicarse entre sí mediante una red bridge creada por el usuario llamada mybridge.

Si nunca ha agregado una red en Docker, debería ver algo similar a esto:

$ docker network ls

NETWORK ID          NAME                  DRIVER              SCOPE
c3cd46f397ce        bridge                bridge              local
ad4e4c24568e        host                  host                local
1c69593fc6ac        none                  null                local

La red bridge predeterminada aparece en la lista, junto con host y none. Ignoraremos los otros dos y usaremos la red bridge cuando lleguemos a los ejemplos.

Dirección IP de un contenedor de Docker

De forma predeterminada, al contenedor se le asigna una dirección IP para cada red de Docker a la que se conecta. Y cada red se crea con una máscara de subred predeterminada, que se usa como un pool para luego proporcionar las direcciones IP.

Por lo general, Docker usa la subred predeterminada 172.17. 0.0/16  para los contenedores.

Ahora, para entenderlo mejor, ejecutaremos un caso de uso real.

Ejemplo Docker

Para ilustrar esto, usaremos un entorno Hive y Hadoop, que contiene 5 contenedores Docker.

Revise el archivo docker-compose.yml  que estamos a punto de ejecutar:

version: "3"

services:
  namenode:
    image: bde2020/hadoop-namenode:2.0.0-hadoop2.7.4-java8
    volumes:
      - namenode:/hadoop/dfs/name
    environment:
      - CLUSTER_NAME=test
    env_file:
      - ./hadoop-hive.env
    ports:
      - "50070:50070"
  datanode:
    image: bde2020/hadoop-datanode:2.0.0-hadoop2.7.4-java8
    volumes:
      - datanode:/hadoop/dfs/data
    env_file:
      - ./hadoop-hive.env
    environment:
      SERVICE_PRECONDITION: "namenode:50070"
    ports:
      - "50075:50075"
  hive-server:
    image: bde2020/hive:2.3.2-postgresql-metastore
    env_file:
      - ./hadoop-hive.env
    environment:
      HIVE_CORE_CONF_javax_jdo_option_ConnectionURL: "jdbc:postgresql://hive-metastore/metastore"
      SERVICE_PRECONDITION: "hive-metastore:9083"
    ports:
      - "10000:10000"
  hive-metastore:
    image: bde2020/hive:2.3.2-postgresql-metastore
    env_file:
      - ./hadoop-hive.env
    command: /opt/hive/bin/hive --service metastore
    environment:
      SERVICE_PRECONDITION: "namenode:50070 datanode:50075 hive-metastore-postgresql:5432"
    ports:
      - "9083:9083"
  hive-metastore-postgresql:
    image: bde2020/hive-metastore-postgresql:2.3.0

volumes:
  namenode:
  datanode:

Desde docker-hive GitHub

Nadie quiere leer un archivo de configuración ENORME, ¿verdad? Así que aquí hay una imagen:

¡Mucho mejor! Ahora vamos a poner en marcha esos contenedores:

docker-compose up -d

Podemos ver 5 contenedores:

$ docker ps --format \
"table {{.ID}}\t{{.Status}}\t{{.Names}}"

CONTAINER ID        STATUS                   NAMES
158741ba0339        Up 1 minutes             dockerhive_hive-metastore-postgresql
607b00c25f29        Up 1 minutes             dockerhive_namenode
2a2247e49046        Up 1 minutes             dockerhive_hive-metastore
7f653d83f5d0        Up 1 minutes (healthy)   dockerhive_hive-server
75000c343eb7        Up 1 minutes (healthy)   dockerhive_datanode

A continuación vamos a comprobar nuestras redes Docker

$ docker network ls

NETWORK ID          NAME                  DRIVER              SCOPE
c3cd46f397ce        bridge                bridge              local
9f6bc3c15568        docker-hive_default   bridge              local
ad4e4c24568e        host                  host                local
1c69593fc6ac        none                  null                local

Un momento... ¡Hay una nueva red llamada docker-hive_default!

Por defecto, docker compose configura una sola red para su aplicación. Y la red de su aplicación recibe un nombre basado en el "nombre del proyecto", que se origina a partir del nombre del directorio en el que se encuentra.

Entonces, dado que nuestro directorio se llama docker-hive, esto explica la nueva red.

A continuación, algunos ejemplos sobre cómo obtener la dirección IP de Docker.

Como obtener la dirección IP de un contenedor Docker - ejemplos

Y ahora que tengo su atención, vamos a develar el misterio.

1. Usando Docker Inspect

docker inspect es una excelente manera de recuperar información de bajo nivel sobre los objetos de Docker. Puede seleccionar cualquier campo del JSON devuelto de una manera bastante sencilla.

Entonces, ¿lo usaremos para obtener la dirección IP de dockerhive_datanode?

$ docker inspect -f \
'{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' \
75000c343eb7

172.18.0.5

¿No dije que Docker usa la subred 172.17.0.0/16 predeterminada para las redes de contenedores? ¿Por qué la dirección IP devuelta: 172.18.0.5 está fuera de ella?

Para responder eso tenemos que mirar nuestra configuración de red:

$ docker network inspect -f \
'{{range .IPAM.Config}}{{.Subnet}}{{end}}'  9f6bc3c15568

172.18.0.0/16

Ejecutamos este ejemplo en una Compute Engine VM y en esta prueba, a la red docker se le asignó una subred diferente: 172.18.0.0/16. ¡Eso lo explica!

Además, también podemos buscar todas las direcciones IP dentro de la red docker-hive_default.

Por lo tanto, no necesitamos buscar la IP de cada contenedor individualmente:

$ docker network inspect -f \
'{{json .Containers}}' 9f6bc3c15568 | \
jq '.[] | .Name + ":" + .IPv4Address'

"dockerhive_hive-metastore-postgresql:172.18.0.6/16"
"dockerhive_hive-metastore:172.18.0.2/16"
"dockerhive_namenode:172.18.0.3/16"
"dockerhive_datanode:172.18.0.5/16"
"dockerhive_hive-server:172.18.0.4/16"

Si no se dio cuenta, usamos la ayuda de jq para analizar el objeto de mapa de los Contenedores.

2. Usando Docker exec

En el siguiente ejemplo trabajaremos con el dockerhive_namenode.

$ docker exec dockerhive_namenode cat /etc/hosts

127.0.0.1       localhost
::1     localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.18.0.3      607b00c25f29

3. Dentro del contenedor Docker

$ docker exec -it dockerhive_namenode /bin/bash

# running inside the dockerhive_namenode container
ip -4 -o address

7: eth0    inet 172.18.0.3/16 brd 172.18.255.255 scope global eth0

Incluso podemos encontrar direcciones IP de otros contenedores que están dentro de la misma red:

Data node

# running inside the dockerhive_namenode container
ping dockerhive_datanode

PING dockerhive_datanode (172.18.0.5): 56 data bytes
64 bytes from 172.18.0.5: icmp_seq=0 ttl=64 time=0.092 ms

Hive mestastore

# running inside the dockerhive_namenode container
ping dockerhive_hive-metastore

PING dockerhive_hive-metastore_1 (172.18.0.2): 56 data bytes
64 bytes from 172.18.0.2: icmp_seq=0 ttl=64 time=0.087 ms

Hive server

# running inside the container
ping dockerhive_hive-server

PING dockerhive_hive-server (172.18.0.4): 56 data bytes
64 bytes from 172.18.0.4: icmp_seq=0 ttl=64 time=0.172 ms

Tener en cuenta

Todos los ejemplos se ejecutaron en una Compute Engine VM de distribución Linux. Si los ejecuta en entornos macOS o Windows, los comandos de muestra pueden cambiar un poco.

También tenga en cuenta que esas direcciones IP en los ejemplos dados son internas a la red de ejemplo docker-hive_default. Entonces, si necesita conectarse a esos contenedores externamente, necesitará usar la IP externa de la máquina host (suponiendo que está exponiendo los puertos de los contenedores correctamente).

O si está utilizando kubernetes, por ejemplo, para administrar sus contenedores Docker, deje que kubernetes maneje las direcciones IP por usted.

* Ilustraciones de icons8.com por Murat Kalkavan.

Docker es un cambio de juego. Pero no es una solución única para todos.

Docker tiene muchas cosas buenas. Empaca, expide, y ejecuta aplicaciones como una herramienta de contenerización con ligera, portable y autosuficiente. Docker es genial para negocios de todos los tamaños. Cuando trabajas un pedazo de código en un equipo pequeño, elimina el problema "pero funciona en mi computador" . Mientras tanto, empresas usan Docker para construir entregas de ductos de software ágil y ductos para enviar nuevas funciones de forma más rápida y segura.

Con su sistema de contenedores incorporado, Docker es una excelente herramienta para la computación en la nube. A su vez, Docker Swarm promueve la agrupación en clústeres y el diseño descentralizado. Suena demasiado bueno para ser verdad, ¿verdad? Bueno, todavía hay varios casos en los que no se debe usar Docker. Aquí hay siete de ellos.

Veámoslos uno por uno.

No uses Docker si necesitas aumentar la velocidad

Los contenedores Docker son más pequeños y requieren menos recursos que una máquina virtual con un servidor y una base de datos. Al mismo tiempo, Docker utilizará tantos recursos del sistema como lo permita el programador del kernel del alojamiento. No esperes que Docker acelere una aplicación de ninguna manera.

Es más, Docker podría incluso hacerlo más lento. Si estás trabajando con él, debes establecer límites sobre la cantidad de memoria, CPU o bloque IO que puede usar el contenedor. De lo contrario, si el kernel detecta que la memoria de la máquina de alojamiento se está agotando para realizar funciones importantes del sistema, podría comenzar a eliminar procesos importantes. Si se elimina el proceso incorrecto (incluido el propio Docker), el sistema será inestable.

Desafortunadamente, los ajustes de memoria de Docker, la prioridad de falta de memoria en el demonio de Docker (Docker daemon) , no resuelven este problema. Por el contrario, una capa adicional entre una aplicación y el sistema operativo también podría resultar en una reducción de la velocidad. Sin embargo, esta disminución será insignificante. Los contenedores Docker no están completamente aislados y no contienen un sistema operativo completo como cualquier máquina virtual.

No uses Docker si priorisas la seguridad

La mayor ventaja de seguridad de Docker es que divide la aplicación en partes más pequeñas. Si la seguridad de una parte se ve comprometida, el resto de ellas no se verá afectada.

Sin embargo, mientras que los procesos aislados en los contenedores prometen una mayor seguridad, todos los contenedores comparten el acceso a un solo sistema operativo de alojamiento. Corres el riesgo de ejecutar contenedores Docker con un aislamiento incompleto. Cualquier código malicioso puede acceder a la memoria de su computadora.

Existe una práctica popular para ejecutar muchos contenedores en un solo entorno. Así es como haces que tu aplicación esté predispuesta al tipo de ataques de abuso de recursos, a menos que limites las capacidades del contenedor de recursos. Para una máxima eficiencia y aislamiento, cada contenedor debes abordar un área específica de interés.

Otro problema es la configuración predeterminada de Docker: los usuarios no tienen espacios de nombres (namespace) . Los espacios de nombres permiten que los recursos de software usen otros recursos solo si pertenecen a un espacio de nombres específico.

Ejecutar aplicaciones con Docker implica ejecutar el demonio de Docker (Docker daemon)  con privilegios de superusuario (root). Cualquier proceso que salga del contenedor Docker tendrá los mismos privilegios en el alojamiento que tenía en el contenedor. Ejecutar sus procesos dentro de los contenedores como un usuario sin privilegios no puede garantizar la seguridad. Depende de las capacidades que agregue o elimine. Para mitigar los riesgos de ruptura de contenedores de Docker, no debes descargar contenedores listos para usar de fuentes no confiables.

No uses Docker si desarrollas una aplicación GUI de escritorio

Docker no se adapta a las aplicaciones que requieren una interfaz de usuario rica. Docker está destinado principalmente a contenedores aislados con aplicaciones basadas en consola. Las aplicaciones basadas en GUI no son una prioridad, su soporte dependerá del caso y la aplicación específicos. Los contenedores de Windows se basan en Nano o Core Server; no permite a los usuarios iniciar una interfaz basada en GUI o un servidor Docker RDP en el contenedor Docker.

Sin embargo, aún puedes ejecutar aplicaciones basadas en GUI desarrolladas con Python y el marco QT en un contenedor de Linux. Además, puedes usar el reenvío X11, pero esta solución es algo incómoda.

No uses Docker si quieres aliviar el desarrollo y la depuración

Docker fue creado por desarrolladores y para desarrolladores. Brinda estabilidad al entorno: un contenedor en la máquina de desarrollo funcionará exactamente igual en el escenario, la producción o cualquier otro entorno. Esto elimina el problema de varias versiones de programas en diferentes entornos.

Con la ayuda de Docker, puedes agregar fácilmente una nueva dependencia a tu aplicación. Ningún desarrollador de tu equipo necesitará repetir esta manipulación en su máquina. Todo estará funcionando en el contenedor y distribuido a todo el equipo.

Al mismo tiempo, debes realizar una configuración adicional para codificar tu aplicación en Docker. Además, con la depuración de Docker, debes configurar la salida de registros y configurar los puertos de depuración. Es posible que también necesites asignar puertos para sus aplicaciones y servicios en contenedores. Entonces, si tienes un proceso de implementación complicado y tedioso, Docker ayudará mucho. Si tienes una aplicación simple, solo agregas una complejidad innecesaria.

No uses Docker si necesitas usar diferentes sistemas operativos o kernels

Con las máquinas virtuales, el hipervisor puede abstraer un dispositivo completo. Puede usar Microsoft Azure para ejecutar ambas instancias de Windows Server y Linux Server al mismo tiempo. Sin embargo, la imagen de Docker requiere el mismo sistema operativo para el que se creó.

Hay una gran base de datos de imágenes de contenedores Docker: Docker Hub. Sin embargo, si se creó una imagen en Linux Ubuntu, solo se ejecutará en el mismo Ubuntu.

Si una aplicación se desarrolla en Windows, pero la producción se ejecuta en Linux, no podrás usar Docker de manera efectiva. A veces, es más fácil configurar un servidor si tiene varias aplicaciones estáticas.

No uses Docker si tienes muchos datos valiosos que almacenar

Por diseño, todos los archivos de Docker se crean dentro de un contenedor y se almacenan en una capa de contenedor de escritura. Puede ser difícil recuperar los datos del contenedor si un proceso diferente los necesita. Además, la capa de escritura de un contenedor está conectada a la máquina host en la que se ejecuta el contenedor. Si necesitas mover los datos a otro lugar, no puedes hacerlo fácilmente. Más que eso, todos los datos almacenados dentro de un contenedor se perderán para siempre una vez que el contenedor se apague.

Primero debes pensar en formas de guardar tus datos en otro lugar. Para mantener los datos seguros en Docker, debes emplear una herramienta adicional: Volúmenes de datos de Docker. Sin embargo, esta solución sigue siendo bastante torpe y necesita ser mejorada.

No uses Docker si estás buscando la tecnología más fácil de administrar

Al ser introducido en 2012, Docker sigue siendo una nueva tecnología. Como desarrollador, es posible que debas actualizar las versiones de Docker con regularidad. Desafortunadamente, la compatibilidad con versiones anteriores no está garantizada. Además, la documentación se está quedando atrás con respecto al avance de la tecnología. Como desarrollador, tendrás que resolver algunas cosas tú mismo.

Además, las opciones de monitorización que ofrece Docker son bastante pobres. Puedes obtener una visión rápida de algunas estadísticas simples. Sin embargo, si deseas ver algunas funciones de monitoreo avanzadas, Docker no tiene nada que ofrecer.

También, en el caso de una aplicación grande y compleja, la implementación de Docker tiene un costo. Crear y mantener la comunicación entre numerosos contenedores en numerosos servidores requerirá mucho tiempo y esfuerzo. Sin embargo, existe una herramienta útil que facilita el trabajo con aplicaciones Docker de varios contenedores: Docker Compose. Docker Compose define servicios, redes y volúmenes en un solo archivo YAML.

No obstante, el ecosistema de Docker está bastante fracturado: no todos los productos de contenedores compatibles funcionan bien entre sí. Cada producto está respaldado por una determinada empresa o comunidad. La competencia acalorada entre ellas produce incompatibilidad.

Para concluir

Los profesionales de KeenEthics disfrutan trabajar con Docker y, a menudo, lo usan para el desarrollo de aplicaciones. A pesar de algunos inconvenientes, puedes usarlo fácilmente para ejecutar y administrar aplicaciones en paralelo en contenedores aislados.

Instalar una aplicación puede ser tan simple como ejecutar un solo comando – <docker run>. Docker también proporciona un entorno de aislamiento limpio y original para cada prueba, lo que lo convierte en una herramienta importante y útil para las pruebas de automatización.

Las características de Docker ofrecen beneficios en términos de administración de dependencias y seguridad. Mejorado con herramientas tan útiles como Docker Hub, Docker Swarm y Docker Compose, Docker es una solución popular y fácil de usar.

A pesar de todos los beneficios de Docker, no debes usarlo para contener todas y cada una de las aplicaciones que desarrolles.

Recuerda: Docker cambia las reglas del juego. Pero no es una solución única para todos.

Docker tampoco es la única herramienta de este tipo en el mercado. Las alternativas de Docker son rkt, pronunciado como 'rocket', Linux Containers u OpenVZ. Cada uno de estos con sus ventajas y desventajas es bastante similar a Docker. La creciente popularidad y las tasas de uso de Docker se deben únicamente a la decisión de las empresas de adoptarlo.

Antes de saltar a conclusiones sobre si debe usar Docker o no, investiga los requisitos del proyecto. Habla con tus compañeros de equipo o compañeros y permítales que te ayuden a decidir cuándo usar Docker,  y cuándo no usar contenedores y si es uno de esos casos de uso de Docker.

Te guste o no, esta tecnología tiene futuro. Hay algunos desarrolladores y agencias de desarrollo que odian a Docker y tratan de eliminarlo de todos sus proyectos en curso. Al mismo tiempo, hay especialistas que contienen todo lo que pueden porque ven a Docker como una panacea. Tal vez, no deberías unirte a ninguno de los campos. Mantente imparcial, mantente objetivo y toma una decisión dependiendo de la situación en particular.

Tienes una idea para un proyecto Docker?

Mi empresa KeenEthics es un equipo de desarrolladores de aplicaciones web experimentados. En caso de que necesites un presupuesto gratuito de un proyecto similar, no dudes en ponerte en contacto.

P.S.

Además, me gustaría decir "gracias" a Alex Pletnov por ser coautor de este artículo, así como a los lectores por leer hasta el final.

¿Eres desarrollador y quieres empezar con Docker? Este artículo es para ti.

Luego de una corta introducción sobre qué es Docker y por qué utilizarlo, podrás crear tu primera aplicación con Docker.

¿Qué es Docker?

Docker es un software gratuito desarrollado por Docker Inc. Se presentó al público general el 13 de marzo del 2013 y desde entonces se ha convertido en un imprescindible en el mundo del desarrollo informático.

Le permite a los usuarios crear entornos independientes y aislados para desplegar sus aplicaciones. Estos entornos se denominan "contenedores".

Esto le permitirá al desarrollador ejecutar un contenedor en cualquier máquina.

Como puedes ver, con Docker ya no hay problemas de dependencia o compilación. Todo lo que tienes que hacer es lanzar tu contenedor y tu aplización se lanzará inmediatamente.

Pero, ¿es Docker una máquina virtual?

Esta es una de las preguntas más frecuentes sobre Docker. La respuesta es: en realidad, no del todo.

Puede parecer una máquina virtual al principio, pero la funcionalidad no es la misma.

A diferencia de Docker, una máquina virtual incluye un sistema operativo completo. Funcionará de forma independiente y actuará como un ordenador.

Docker solo compartirá los recursos de la máquina anfitriona para ejecutar sus entornos.

¿Por qué utilizar Docker como desarrollador?

Esta herramienta realmente puede cambiar la vida diaria del desarrollador. Para responder esta pregunta de la mejor manera, he redactado una lista no exhaustiva de los beneficios que encontrará:

• Docker es rápido. A diferencia de una máquina virtual, tu aplicación puede iniciarse en pocos segundos y detenerse igual de rápido.
• Docker es multi-plataforma. Puedes lanzar tu contenedor en cualquier sistema.
• Los contenedores pueden construirse y destruirse más rápido que en una máquina virtual.
• Se acabaron las dificultades para configurar tu entorno de trabajo. Una vez configurado tu Docker, no tendrás que volver a instalar tus dependencias manualmente. Si cambias de ordenador o si un empleado se incorpora a tu empresa, solo tendrás que darle tu configuración.
• Mantendrás tu espacio de trabajo limpio, ya que cada uno de tus entornos estará aislado y podrás eliminarlo en cualquier momento sin que afecte al resto.
• Será más fácil desplegar tu proyecto en tu servidor para ponerlo en línea.

Ahora vamos a crear tu primera aplicación

Ahora que sabes lo que es Docker, ¡es momento de crear tu primera aplicación!

El propósito de este corto tutorial es crear un programa de Python que muestre una oración. Este programa deberá ser lanzado a través de un Dockerfile.

Verás que no es tan complicado una vez que entiendas el proceso.

Nota: No necesitarás instalar Python en tu ordenador. Será el entorno Docker el que contenga Python para poder ejecutar tu código.

1. Instala Docker en tu máquina

Para Ubuntu:

Primero, actualiza tus paquetes:

$ sudo apt update

Siguiente, instala Docker con apt-get:

$ sudo apt install docker.io

Finalmente, verifica que Docker se ha instalado correctamente:

$ sudo docker run hello-world

• Para MacOSX: puedes seguir este enlace.
• Para Windows: puedes seguir este enlace.

2. Crea tu proyecto

Para crear tu primera aplicación Docker, te invito a crear una carpeta en tu computadora. Debe contener los siguientes dos archivos:

• Un archivo ‘main.py’ (un archivo python que tendrá el código a ejecutar).
• Un archivo ‘Dockerfile’ (un archivo Docker que tendrá las instrucciones necesarias para crear el entorno).

Normalmente, tendrías esta arquitectura de carpeta:

.
├── Dockerfile
└── main.py
0 directories, 2 files

3. Edita el archivo Python

Puedes agregar el siguiente código a tu archivo ‘main.py’:

#!/usr/bin/env python3

print("¡Docker es mágico!")

Nada excepcional, pero una vez que veas en tu terminal "¡Docker es mágico!", sabrás que tu Docker está funcionando.

3. Edita el archivo Docker

Un poco de teoría: lo primero que hay que hacer cuando quieres crear tu Dockerfile es preguntarte qué quieres hacer. Nuestro objetivo aquí es lanzar código Python.

Para ello, nuestro Docker debe contener todas las dependencias necesarias para lanzar Python. Un Linux (Ubuntu) con Python instalado en él debería ser suficiente.

El primer paso para crear un archivo Docker es acceder al sitio web DockerHub. Este sitio contiene muchas imágenes prediseñadas para ahorrarte tiempo (por ejemplo: todas las imágenes para Linux o lenguajes de código).

En nuestro caso, escribiremos ‘Python’ en la barra de búsqueda. El primer resultado es la imagen oficial creada para ejecutar Python. Perfecto, ¡lo usaremos!

# Un archivo docker (dockerfile) comienza siempre importanto la imagen base. 
# Utilizamos la palabra clave 'FROM' para hacerlo.
# En nuestro ejemplo, queremos importar la imagen de python.
# Así que escribimos 'python' para el nombre de la imagen y 'latest' para la versión.
FROM python:latest

# Para lanzar nuestro código python, debemos importarlo a nuestra imagen.
# Utilizamos la palabra clave 'COPY' para hacerlo.
# El primer parámetro 'main.py' es el nombre del archivo en el host.
# El segundo parámetro '/' es la ruta donde poner el archivo en la imagen.
# Aquí ponemos el archivo en la carpeta raíz de la imagen. 
COPY main.py /

# Necesitamos definir el comando a lanzar cuando vayamos a ejecutar la imagen.
# Utilizamos la palabra clave 'CMD' para hacerlo.
# El siguiente comando ejecutará "python ./main.py".
CMD [ "python", "./main.py" ]

4. Crea la imagen Docker

Una vez que tu código esté listo y el Dockerfile está escrito, todo lo que tienes que hacer es crear tu imagen para contener tu aplicación.

$ docker build -t python-test . 

La opción ’-t’ te permite definir el nombre de tu imagen. En nuestro caso hemos elegido ’python-test’ pero le puedes poner lo que quieras.

5. Corre la imagen Docker

Una vez la imagen esté creada, tu código está listo para lanzar.

$ docker run python-test

Tienes que poner el nombre de tu imagen después de un ‘docker run’.

Ya está, eso es todo. Normalmente, deberías ver "¡Docker es mágico!", en tu terminal.

El código está disponible

Si quieres el código completo para encontrarlo fácilmente o ejecutarlo, lo he puesto a tu disposición en mi GitHub.

-> GitHub: Ejemplo de primera aplicación en Docker

Comandos útiles para Docker

Antes de dejarte, he preparado una lista de comandos que te pueden ser útiles en Docker:

• Lista de imágenes

$ docker image ls

• Elimina una imagen específica

$ docker image rm [nombre de la imagen]

• Elimina todas las imágenes existentes

$ docker image rm $(docker images -a -q)

• Lista todos los contenedores existentes (en funcionamiento y no en funcionamiento)

$ docker ps -a

• Detener un contenedor específico

$ docker stop [nombre del contenedor]

• Detener todos los contenedores en funcionamiento

$ docker stop $(docker ps -a -q)

• Elimina un contenedor específico (solo si está detenido)

$ docker rm [nombre del contenedor]

• Elimina todos los contenedores (solo si están detenidos)

$ docker rm $(docker ps -a -q)

• Mostrar los registros de un contenedor

$ docker logs [nombre del contenedor]

Conclusión

Puedes consultar este artículo cada vez que necesites un ejemplo sencillo y concreto sobre cómo crear tu primera aplicación Docker. Si tienes alguna pregunta o comentario, no dudes en preguntar.

Si quieres más contenido como este, puedes seguirme en Twitter, donde tuiteo sobre desarrollo web, superación personal y mi viaje como desarrollador full stack.

Puedes encontrar otros artículos como este en mi website: herewecode.io.

Docker rmi

docker rmi remueve imágenes por su  ID.

Para remover la imagen, primero necesitas una lista de todas las imágenes para obtener las IDs de imagen, nombre de la imagen, y otros detalles. Ejecutando un simple comando docker imagenes -a  o  docker imagenes.

Después de eso asegúrate que imagen quieres remover, para hacer eso ejecuta este simple comando docker rmi <tu-imagen-id>. Luego puedes confirmar que la imagen se ha eliminado o no, enumerando todas las imágenes y verificando.

Eliminar múltiples imágenes

Hay una forma para eliminar más de una imagen al mismo tiempo, cuando quieras eliminar varias imágenes específicas. Entonces para hacer esto primero obtén los IDs de la imagen simplemente enlistando las imágenes y luego ejecutando el simple comando a continuación.

docker rmi <tu-imagen-id> <tu-imagen-id> ...

Escribe los IDs de la imagen en el comando seguido de los espacios entre ellos.

Elimina todas las imágenes de una vez.

Para eliminar todas las imágenes hay un comando simple para hacer eso. docker rmi $(docker imagenes -q)

En el comando de arriba, solo hay dos comandos, el primero se ejecuta en la  $() es la sintaxis de shell y devuelve los resultados independientemente de lo que se ejecute en la sintaxis. Entonces en este -q- es una opción para proporcionar al retunr las unicas IDs, $() regresa los resultados del IDs de la imagen y luego docker rmi remueve todas las imágenes.

Docker rm

docker rm remueve contenedores por su nombre o ID.

Cuando tienes contenedores Docker ejecutándose, primero necesitas detenerlos antes de borrarlos.

• Detén todos los contenedores ejecutándose: docker stop $(docker ps -a -q)
• Elimina todos los contenedores detenidos: docker rm $(docker ps -a -q)

Eliminar múltiples contenedores

Puedes detener y eliminar múltiples contenedores pasando los comando una lista de los contenedores que quieres eliminar. La sintaxis shell $() regresa los resultados de cualquiera que es ejecutado dentro de los corchetes. Entonces puedes crear tu lista de contenedores dentro de estos para pasar a los comandos stop y rm.

Aquí hay un desglose de docker ps -a -q

• docker ps  lista de contenedores
• -a  la opción para enlistar todos los contenedores, inclusive los detenidos. Sin esto, de forma predeterminada solo se numeran los contenedores en ejecución.
• -q la opción silenciosa para proporcionar solo el Id del contenedor, en lugar de toda la tabla de información sobre los contenedores.