imagina pictogramaImagina Formación

Cómo crear Imágenes Personalizadas en Docker

Escrito por Equipo de Imagina• Actualizado el 23/04/2025• Duración: 30 min
¡Bienvenido al tutorial de creación de imágenes personalizadas de Docker! En este tutorial, aprenderemos cómo crear nuestras propias imágenes personalizadas para Docker, lo que nos permitirá desplegar nuestras aplicaciones de manera más eficiente y reproducible.
Joven Creando una Imagen Personalizada en Docker

¿Qué es una Imagen Personalizada en Docker?

Antes de sumergirnos en la creación de imágenes personalizadas, es importante comprender qué es una imagen en Docker. Una imagen es un paquete ligero y autónomo que contiene todo lo necesario para ejecutar una aplicación, incluidas bibliotecas, dependencias, configuraciones y el propio código de la aplicación.
Una imagen personalizada en Docker es una imagen que creamos a partir de una imagen base existente. La imagen base puede ser proporcionada por la comunidad de Docker o incluso puede ser una imagen oficial proporcionada por los desarrolladores. Al crear una imagen personalizada, podemos agregar nuestras propias configuraciones, dependencias y archivos específicos de la aplicación.
Con una imagen personalizada, podemos asegurarnos de que todas las dependencias y configuraciones necesarias estén presentes en el entorno de ejecución, lo que garantiza que la aplicación funcione de manera consistente en cualquier entorno donde se despliegue.

Preparación del entorno

Antes de comenzar a crear imágenes personalizadas, necesitaremos asegurarnos de tener Docker instalado y configurado correctamente en nuestro sistema. Asegúrate de que tengas una versión de Docker adecuada para este tutorial y que cuentes con permisos de administrador para ejecutar comandos relacionados con Docker.
Para verificar si Docker está instalado en tu sistema, abre una terminal y ejecuta el siguiente comando:
docker --version
Si Docker está instalado, verás la versión instalada en tu sistema. Si no lo tienes instalado, visita nuestro tutorial de primeros pasos en Docker para ver el proceso de intalación correcto.

Entendiendo el archivo Dockerfile

El archivo 
Dockerfile
 es un componente fundamental para construir imágenes personalizadas en Docker. Es un archivo de texto plano que contiene una serie de instrucciones que Docker utilizará para crear la imagen.
Una imagen Docker es una representación estática de un contenedor, y estas instrucciones en el 
Dockerfile
definen cómo se construirá esta imagen. Cada instrucción en el 
Dockerfile
representa una capa en la imagen resultante.
Algunas de las instrucciones más comunes en un 
Dockerfile
son:
  • FROM: Esta instrucción especifica la imagen base que utilizaremos como punto de partida para nuestra imagen personalizada. Por ejemplo, podemos usar una imagen base de Ubuntu o Alpine Linux.
  • RUN: Con esta instrucción, podemos ejecutar comandos dentro del contenedor durante el proceso de construcción de la imagen. Por ejemplo, instalar paquetes o configurar dependencias.
  • COPY y ADD: Ambas instrucciones permiten copiar archivos o directorios desde el sistema de archivos del host a la imagen. La diferencia principal es que 
    ADD
    también puede trabajar con URLs o desempaquetar archivos tar.
  • EXPOSE: Esta instrucción especifica los puertos en los que el contenedor escuchará durante el tiempo de ejecución. Es importante tener en cuenta que esto no publica los puertos en el host, solo los expone en el contenedor.
  • CMD y ENTRYPOINT: Ambas instrucciones se utilizan para definir el comando predeterminado que se ejecutará cuando el contenedor se inicie. Existen variasdiferencias entre Entrypoint y CMD, aunque la principal radica en cómo se manejan los argumentos pasados al contenedor.
En el siguiente apartado, nos sumergiremos en los detalles de cada instrucción y veremos cómo usarlas adecuadamente para crear nuestras imágenes personalizadas de Docker. ¡Vamos a ello!
En la próxima sección, profundizaremos en el uso de las instrucciones del 
Dockerfile
y veremos cómo combinarlas para crear imágenes personalizadas de manera efectiva y eficiente. ¡Continúa con el tutorial para convertirte en un experto en la creación de imágenes Docker personalizadas!

Creando una imagen personalizada

Ahora que comprendemos los conceptos básicos de Docker y su archivo 
Dockerfile
, es hora de sumergirnos en la creación de nuestra imagen personalizada. Este proceso se divide en varios pasos clave que cubriremos a continuación.

Paso 1: Selección de la imagen base

El primer paso para crear una imagen personalizada es seleccionar una imagen base sobre la cual construiremos nuestra aplicación. La imagen base debe contener el sistema operativo y las dependencias necesarias para que nuestra aplicación se ejecute correctamente.
Al seleccionar una imagen base, es recomendable utilizar una que esté optimizada para el tipo de aplicación que estamos desarrollando. Por ejemplo, si estamos creando una aplicación web en Python, podríamos seleccionar una imagen base de Python.
Podemos explorar el registro de Docker para encontrar imágenes base confiables. Para ello, podemos utilizar el siguiente comando:
docker search nombre_imagen_base
Reemplaza 
nombre_imagen_base
con una palabra clave relevante para tu aplicación, como 
python
, 
node
, 
nginx
, etc.
Una vez que hayamos elegido la imagen base, la incluiremos en nuestro archivo 
Dockerfile
 utilizando la instrucción 
FROM
. Por ejemplo:
FROM python:3.9-alpine
En este ejemplo, estamos utilizando la imagen base oficial de Python versión 3.9 en una distribución Alpine de Linux, que es una opción ligera y popular para aplicaciones de Docker.

Paso 2: Preparando el entorno de la aplicación

En este paso, prepararemos el entorno de nuestra aplicación dentro de la imagen personalizada. Esto implica copiar los archivos y directorios necesarios, instalar las dependencias y configurar el entorno para que nuestra aplicación funcione correctamente.
Usaremos las instrucciones 
COPY
o 
ADD
en el archivo 
Dockerfile
 para copiar los archivos y directorios relevantes desde el sistema de archivos del host a la imagen. Por ejemplo:
COPY app /app
En este caso, estamos copiando el contenido del directorio 
app
en el sistema de archivos del host a la ubicación 
/app
dentro de la imagen.
Luego, podemos utilizar la instrucción 
RUN
para ejecutar comandos dentro del contenedor durante el proceso de construcción. Por ejemplo, podemos instalar las dependencias necesarias para nuestra aplicación:
RUN pip install -r requirements.txt

Paso 3: Ejecutando comandos en la imagen

En este paso, podemos ejecutar comandos adicionales dentro del contenedor para preparar nuestra aplicación para su ejecución. Utilizaremos la instrucción 
RUN
para llevar a cabo estas acciones.
Por ejemplo, si nuestra aplicación requiere un proceso de compilación, podemos incluirlo en el archivo 
Dockerfile
:
RUN npm run build

Paso 4: Exponiendo puertos y volúmenes

Una vez que nuestra aplicación esté lista, debemos exponer los puertos necesarios para que los usuarios puedan interactuar con ella. Utilizaremos la instrucción 
EXPOSE
para especificar los puertos en los que el contenedor escuchará durante el tiempo de ejecución.
Por ejemplo, si nuestra aplicación web utiliza el puerto 8000, incluiríamos lo siguiente en el archivo 
Dockerfile
:
EXPOSE 8000
Además, si nuestra aplicación requiere acceso a datos persistentes, podemos utilizar volúmenes de Docker. Los volúmenes son directorios montados desde el sistema de archivos del host al contenedor. Esto permite que los datos persistan incluso después de que el contenedor se detenga o se elimine.
Para definir un volumen en el archivo 
Dockerfile
, utilizaremos la instrucción 
VOLUME
:
VOLUME /data
En este ejemplo, estamos creando un volumen en el directorio 
/data
dentro del contenedor.

Paso 5: Etiquetado y almacenamiento de la imagen

Una vez que hayamos completado la configuración de nuestra imagen personalizada, es hora de construirla. Utilizaremos el comando 
docker build
seguido de una etiqueta para identificar nuestra imagen.
docker build -t nombre_etiqueta .
Reemplaza 
nombre_etiqueta
con un nombre significativo para tu imagen. La etiqueta es útil para identificar y gestionar las imágenes con mayor facilidad.
Al finalizar el proceso de construcción, nuestra imagen personalizada de Docker estará lista para ser utilizada y compartida con otros desarrolladores. En la próxima sección, aprenderemos más sobre optimización y mejores prácticas para garantizar que nuestras imágenes sean seguras y eficientes.
¡Excelente trabajo! Ahora que hemos creado nuestra imagen personalizada de Docker, podemos seguir adelante con la siguiente parte del tutorial para aprender sobre optimización y buenas prácticas para trabajar con Docker de manera más eficiente.

Descubre la formación a tu medida

Rellena el formulario para obtener más información sobre los cursos.

Usaremos los datos personales recopilados a través de este formulario en línea para informarte de las últimas novedades sobre nuestros cursos. Para obtener más información, consulta nuestra política de privacidad.

Optimización y mejores prácticas

Ahora que hemos creado nuestra imagen personalizada de Docker, es importante conocer algunas optimizaciones y mejores prácticas para garantizar que nuestras imágenes sean seguras, eficientes y fáciles de mantener.

Mantén las imágenes actualizadas

Es fundamental mantener nuestras imágenes y dependencias actualizadas para evitar vulnerabilidades de seguridad y aprovechar las últimas mejoras. Regularmente, actualiza la imagen base y las dependencias en tu archivo 
Dockerfile
 y vuelve a construir la imagen.
FROM python:3.9-alpine

# Actualizar paquetes en la imagen base
RUN apk update && apk upgrade

Utiliza imágenes oficiales y ligeras

Prefiere las imágenes oficiales proporcionadas por Docker y la comunidad, ya que son confiables y mantienen altos estándares de seguridad. Además, considera el uso de imágenes ligeras como Alpine Linux para reducir el tamaño de la imagen y minimizar su superficie de ataque.

Minimiza capas y utiliza 
--no-cache

Cada instrucción en el archivo 
Dockerfile
 crea una nueva capa en la imagen, lo que puede aumentar el tamaño final. Trata de combinar varias instrucciones en una sola para reducir el número de capas. Además, agrega el argumento 
--no-cache
al comando 
docker build
para evitar el uso de la memoria caché durante la construcción y reducir el tamaño de la imagen.
docker build --no-cache -t nombre_etiqueta .

Limpieza después de la construcción

Asegúrate de eliminar archivos y dependencias temporales después de ejecutar las instrucciones en el archivo 
Dockerfile
 para mantener la imagen limpia y pequeña. Usa la instrucción 
RUN
para borrar archivos innecesarios.
RUN apk del .build-dependencies && \
    rm -rf /var/cache/apk/*

Publicación de la imagen personalizada

Una vez que tengas una imagen personalizada lista, puedes publicarla en un registro público de Docker para compartirla con la comunidad o con tu equipo de desarrollo. El registro más utilizado es Docker Hub.
  1. Crea una cuenta en Docker Hub si aún no tienes una.
  2. Inicia sesión en tu cuenta de Docker Hub utilizando el siguiente comando:
   docker login
  1. Etiqueta tu imagen con tu nombre de usuario en Docker Hub y el nombre del repositorio:
   docker tag nombre_etiqueta nombre_usuario/nombre_repositorio:etiqueta
  1. Empuja la imagen etiquetada al registro público de Docker:
   docker push nombre_usuario/nombre_repositorio:etiqueta
Tu imagen personalizada ahora estará disponible en tu cuenta de Docker Hub para que otros la descarguen y utilicen en sus proyectos.
Implementación y uso de la imagen personalizada
Una vez que has publicado tu imagen personalizada, otros desarrolladores pueden utilizarla para implementar y ejecutar la aplicación en diferentes entornos.
Para implementar la imagen en un servidor o en otro equipo, sigue estos pasos:
  1. Instala Docker en el servidor o equipo.
  2. Inicia sesión en tu cuenta de Docker Hub (o del registro donde hayas publicado la imagen):
   docker login
  1. Descarga la imagen desde el registro de Docker:
   docker pull nombre_usuario/nombre_repositorio:etiqueta
  1. Ejecuta el contenedor utilizando la imagen descargada:
   docker run -d -p puerto_host:puerto_contenedor nombre_usuario/nombre_repositorio:etiqueta
Reemplaza 
puerto_host
 con el puerto de tu servidor que deseas mapear al puerto del contenedor.
¡Enhorabuena! Ahora puedes implementar tu aplicación utilizando la imagen personalizada de Docker en cualquier entorno compatible con Docker.
Conclusiones
En este tutorial, hemos aprendido a crear una imagen personalizada de Docker para nuestras aplicaciones, desde la selección de la imagen base, pasando por la preparación del entorno y la ejecución de comandos en la imagen, hasta la publicación y uso de la imagen en diferentes entornos.
Si deseas profundizar aún más en el fascinante mundo de Docker y adquirir habilidades avanzadas en la administración de contenedores, te recomendamos nuestro curso de Docker para empresas. En él, podrás explorar conceptos avanzados, prácticas recomendadas y casos de uso reales, lo que te permitirá destacar como un experto en la tecnología Docker. No pierdas la oportunidad de mejorar tus habilidades en la gestión de contenedores y llevar tus proyectos al siguiente nivel con nuestro curso de Docker.
¡Únete ahora y potencia tu carrera en el mundo del desarrollo de aplicaciones y la infraestructura moderna!
Descubre la formación a tu medida
Rellena el formulario para obtener más información sobre los cursos.
Usaremos los datos personales recopilados a través de este formulario en línea para informarte de las últimas novedades sobre nuestros cursos. Para obtener más información, consulta nuestra política de privacidad.