Creación de imágenes de Docker personalizadas

¿Por qué crear imágenes personalizadas? Le permiten empaquetar su aplicación específica, sus dependencias y su configuración en una sola unidad portátil. Esto es fundamental para mantener la coherencia y facilitar la implementación.

Usted define cómo crear esta imagen mediante un archivo llamado Dockerfile.

Contenedorizaremos una aplicación web muy sencilla de Python Flask. Solo devuelve «Hello from Docker!» cuando visita su dirección web.

Imagine que tenemos estos archivos en un directorio:

• app.py: el código de la aplicación Python
• requirements.txt: enumera las dependencias de Python
• Dockerfile: instrucciones para crear la imagen

Esta es nuestra aplicación básica de Python con Flask. Escucha en el puerto 5000 y responde con "Hello from Docker!".

Puede ejecutarla localmente (después de instalar Flask) para verla en acción.

Nuestra aplicación necesita la biblioteca Flask. La incluimos en requirements.txt. Este archivo indica a Docker (y al gestor de paquetes de Python, pip) qué debe instalar.

Esto garantiza que nuestra imagen tenga todas las bibliotecas necesarias para ejecutar la aplicación.

Un Dockerfile es un archivo de texto con instrucciones para crear una imagen. Cada instrucción crea una capa. Esto es lo que utilizaremos:

• FROM: especifica la imagen base (por ejemplo, Python).
• WORKDIR: establece el directorio de trabajo dentro del contenedor.
• COPY: copia archivos de su máquina local a la imagen.
• RUN: ejecuta comandos (por ejemplo, para instalar dependencias).
• EXPOSE: informa a Docker sobre los puertos en los que escucha el contenedor.
• CMD: define el comando predeterminado que se ejecutará cuando se inicie el contenedor.

Este es el Dockerfile completo de nuestra aplicación Flask. Coloque este archivo en el mismo directorio que app.py y requirements.txt.

Ahora vamos a crear nuestra imagen. Abra la terminal en el directorio donde se encuentran el Dockerfile y los archivos de la aplicación.

La opción -t etiqueta nuestra imagen con un nombre (my-flask-app) y una versión (1.0). El punto . indica a Docker que utilice el directorio actual como contexto de compilación.

docker build -t my-flask-app:1.0 .

Cuando finalice la compilación, puede verificar que la nueva imagen existe mostrando una lista de todas las imágenes locales de Docker.

Busque my-flask-app con la etiqueta 1.0 en la salida.

docker images

Es hora de ver la aplicación en acción. Utilice docker run para crear e iniciar un contenedor a partir de la imagen.

-p 5000:5000 asigna el puerto 5000 de la máquina host al puerto 5000 dentro del contenedor. -d lo ejecuta en modo desacoplado (en segundo plano).

docker run -d -p 5000:5000 my-flask-app:1.0

Visite http://localhost:5000 en el navegador para ver "Hello from Docker!".

Las etiquetas son fundamentales para gestionar distintas versiones de sus imágenes. Una práctica habitual consiste en utilizar versionado semántico (por ejemplo, 1.0.0, 2.1.5) y también una etiqueta latest.

Puede añadir varias etiquetas a una imagen mediante docker tag:

docker tag my-flask-app:1.0 my-flask-app:latest

Esto permite hacer referencia a la misma imagen con distintos nombres, lo que aporta flexibilidad en las implementaciones.

Considere el siguiente Dockerfile y comando de compilación:

# Dockerfile content
FROM alpine:latest
WORKDIR /app
COPY . .
CMD ["echo", "Hello"]

docker build -t my-app:v1 .

¿Cuál de las siguientes afirmaciones es VERDADERA sobre el comando docker build -t my-app:v1 .?

¡Excelente trabajo! Ha aprendido a:

• Preparar una aplicación sencilla para contenerizarla.
• Escribir un Dockerfile básico utilizando instrucciones clave (FROM, WORKDIR, COPY, RUN, EXPOSE, CMD).
• Crear una imagen personalizada de Docker mediante docker build -t.
• Verificar la imagen con docker images.
• Ejecutar un contenedor a partir de la imagen personalizada mediante docker run -p.
• Comprender la importancia de etiquetar y versionar las imágenes.

A continuación, profundizaremos en la estructura de las imágenes de Docker mediante capas y en las técnicas para optimizar su tamaño y los tiempos de compilación.