Cómo crear imágenes Dockerfile personalizadas paso a paso

Cuando trabajamos con contenedores Docker, utilizar imágenes prediseñadas puede ser un buen punto de partida. Sin embargo, llega un momento en casi todos los proyectos donde necesitas un mayor control, ajustes específicos o simplemente incluir tu propia configuración. Es aquí donde entran en juego las imágenes Dockerfile personalizadas.

En este artículo te proporcionamos una guía detallada, clara y exhaustiva para que aprendas a crear tus propias imágenes Docker personalizadas. Desde conceptos básicos como qué es un Dockerfile y cómo funciona hasta técnicas avanzadas como la optimización del Dockerfile, el uso de variables, caché o gestión de registros.

¿Qué es un Dockerfile y por qué necesitas uno?

Un Dockerfile es simplemente un archivo de texto plano que contiene instrucciones para que Docker sepa cómo construir una imagen. Cada instrucción en el Dockerfile indica un paso concreto, y Docker lo interpreta como una capa en la imagen final que se genera.

Las imágenes en Docker están compuestas por capas inmutables. Los Dockerfile definen paso a paso cómo deben crearse estas capas, desde la selección de una imagen base hasta la copia de archivos, la instalación de paquetes o la configuración de servicios. Al ser reproducibles, los Dockerfile permiten automatizar completamente la generación de entornos personalizados de forma sencilla.

Este enfoque tiene múltiples ventajas: reproducibilidad, facilidad para compartir, mejor mantenimiento y seguridad. Además, utilizar Dockerfile te permite evitar tener que hacer manualmente configuraciones cada vez que lanzas un contenedor. Todo queda automatizado y documentado.

Cómo funciona un Dockerfile: las instrucciones básicas

Para crear imágenes Dockerfile personalizadas, lo primero es definir desde qué imagen base partiremos. Esto se hace con la directiva FROM. Por ejemplo:

FROM ubuntu:20.04

A partir de ahí, se incluyen otras instrucciones que permiten construir y personalizar la imagen:

• COPY: copia archivos desde tu máquina local al sistema de archivos del contenedor.
• RUN: ejecuta comandos dentro de la imagen en construcción (por ejemplo, instalar paquetes).
• CMD: define qué comando se ejecutará por defecto al lanzar un contenedor desde esa imagen.
• ENTRYPOINT: establece el proceso principal del contenedor, similar a CMD pero más controlado.
• ENV: establece variables de entorno dentro del contenedor.
• USER y WORKDIR: indica qué usuario ejecutará los comandos y cuál será el directorio de trabajo.

Un ejemplo práctico de Dockerfile podría ser el siguiente:

FROM ubuntu:20.04
RUN apt-get update && apt-get install -y sudo nano curl nmap
COPY script.sh /usr/local/bin/script.sh
RUN chmod +x /usr/local/bin/script.sh
ENV direcIP=127.0.0.1
CMD ["/usr/local/bin/script.sh"]

Este ejemplo instala herramientas necesarias y configura un script de análisis personalizado con la IP como variable, lo que permite modificarlo fácilmente al lanzar el contenedor.

Organización del contexto de construcción

Cuando Docker construye una imagen, lo hace desde un directorio conocido como contexto de construcción. Este directorio debe contener:

• El archivo Dockerfile.
• Todos los archivos que quieras copiar dentro del contenedor (código fuente, scripts, configuraciones…).
• Un archivo .dockerignore para evitar incluir archivos innecesarios.

Por ejemplo, si vas a construir una imagen con una aplicación Python, tu contexto de construcción debería incluir:

• Dockerfile
• app.py
• requirements.txt

Esto es vital para que Docker pueda copiar correctamente los elementos necesarios dentro del contenedor durante el proceso de construcción.

Compilar la imagen personalizada

Una vez que tienes tu Dockerfile y el contexto preparado, puedes construir la imagen con el comando:

docker build -t nombreimagen:versión .

Por ejemplo:

docker build -t miimagenpython:1.0 .

El punto final («.») indica que el contexto de construcción es el directorio actual. Al terminar, Docker te mostrará el ID de la imagen y podrás verla con:

docker images

Probar y ejecutar tu imagen personalizada

Lanzar un contenedor a partir de tu nueva imagen es tan simple como:

docker run --name miapp -it miimagenpython:1.0

Si lo has configurado correctamente (por ejemplo con Flask o nginx), puedes acceder desde el navegador siempre que hayas mapeado los puertos adecuadamente:

docker run -p 4000:4000 miimagenpython:1.0

Uso de variables de entorno (ENV)

La directiva ENV permite establecer valores por defecto, pero también puedes sobrescribirlos en tiempo de ejecución. Un ejemplo práctico sería establecer una dirección IP para un escaneo con nmap:

ENV direcIP=127.0.0.1

Y luego lanzar el contenedor así:

docker run -e direcIP=192.168.1.1 miimagen

Esto permite tener imágenes más versátiles y reutilizables sin tener que modificarlas constantemente.

Ejecutables por defecto: CMD y ENTRYPOINT

Existen dos formas de indicar qué se ejecutará por defecto al iniciar el contenedor: CMD y ENTRYPOINT. La diferencia entre ambas es que CMD puede ser sobrescrito fácilmente desde la terminal, mientras que ENTRYPOINT convierte al contenedor en una especie de ejecutable “cerrado”.

Una buena práctica es usar ENTRYPOINT para ejecutar scripts de arranque y CMD como valores por defecto. Por ejemplo:

ENTRYPOINT ["/start.sh"]
CMD ["defaultvalue"]

Así puedes pasar argumentos específicos sin alterar la lógica del script incluido.

Buenas prácticas y optimización del Dockerfile

Estas son algunas recomendaciones clave a la hora de crear imágenes Dockerfile personalizadas:

• Usa imágenes base ligeras como Alpine cuando sea posible (ocupan menos espacio y son más rápidas).
• Agrupa instrucciones RUN en un solo bloque para minimizar el número de capas.
• Evita instrucciones interactivas (como prompts de confirmación). Usa siempre -y o --no-prompt en instalaciones.
• Elimina archivos temporales después de sus usos.
• Utiliza .dockerignore como harías con .gitignore para no incluir archivos innecesarios.

Aplicar estas pautas mejora el rendimiento de la imagen y reduce riesgos de seguridad.

Control del caché en la construcción

Docker usa un sistema de caché inteligente para evitar rehacer pasos que no han cambiado. Esto acelera las reconstrucciones. Si editas tus imágenes Dockerfile personalizadas, solo recompilará desde la línea que haya cambiado.

Si deseas forzar la reconstrucción completa, puedes usar:

docker build --no-cache -t nombreimagen .

Esto te garantiza que todo se hará desde cero, útil cuando cambias archivos externos no detectados por el motor de caché.

Compartir imágenes: Docker Hub y registros

Una vez que tienes tu imagen personalizada y comprobada, puedes subirla a un repositorio (como Docker Hub) para compartirla. El flujo sería:

1. Registrarte en Docker Hub y crear un repositorio.
2. Conectar tu cliente con Docker Hub con docker login.
3. Taggear la imagen con tu nombre de usuario:

docker tag miimagen username/miimagen:1.0

4. Subir la imagen con:

docker push username/miimagen:1.0

Una vez hecho esto, cualquier persona podrá descargar y utilizar tu imagen personalizada usando:

docker pull username/miimagen:1.0

Integración con Docker Compose

En proyectos más complejos es habitual necesitar varios contenedores (web, base de datos, balanceador…). Para ello se utiliza docker-compose.yml, donde puedes definir los servicios a ejecutar.

Un ejemplo de uso con una imagen propia sería:

version: '3'
services:
  web:
    image: username/miimagen:1.0
    ports:
      - "4000:4000"
  redis:
    image: redis

Así, docker-compose puede levantar servicios desde imágenes personalizadas y combinarlas con otros estándares de forma coherente.

Al lanzar docker-compose up, se levantan todos los servicios definidos, lo cual es ideal para entornos de desarrollo completos.

Con todas estas herramientas y técnicas, puedes crear entornos robustos, personalizados y eficientes para todos tus proyectos. Ya no estarás limitado a imágenes genéricas y podrás adaptar todo exactamente a tus necesidades.