Compartir comentarios
Las respuestas se generan en base a la documentación.

Escribir un Dockerfile

Tabla de contenidos

Explicación

Un Dockerfile es un documento basado en texto que se utiliza para crear una imagen de contenedor. Proporciona instrucciones al constructor de imágenes sobre los comandos a ejecutar, los archivos a copiar, el comando de inicio y más.

Como ejemplo, el siguiente Dockerfile produciría una aplicación de Python lista para ejecutarse:

FROM python:3.13
WORKDIR /usr/local/app

# Instalar las dependencias de la aplicación
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

# Copiar el código fuente
COPY src ./src
EXPOSE 8080

# Configurar un usuario de aplicación para que el contenedor no se ejecute como el usuario root
RUN useradd app
USER app

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]

Instrucciones comunes

Algunas de las instrucciones más comunes en un Dockerfile incluyen:

  • FROM <image>: especifica la imagen base que extenderá la compilación.
  • WORKDIR <path>: esta instrucción especifica el "directorio de trabajo" o la ruta en la imagen donde se copiarán los archivos y se ejecutarán los comandos.
  • COPY <host-path> <image-path>: esta instrucción indica al constructor que copie archivos desde el host y los coloque en la imagen del contenedor.
  • RUN <command>: esta instrucción indica al constructor que ejecute el comando especificado.
  • ENV <name> <value>: esta instrucción establece una variable de entorno que utilizará un contenedor en ejecución.
  • EXPOSE <port-number>: esta instrucción establece la configuración en la imagen para indicar un puerto que la imagen desea exponer.
  • USER <user-or-uid>: esta instrucción establece el usuario predeterminado para todas las instrucciones siguientes.
  • CMD ["<command>", "<arg1>"]: esta instrucción establece el comando predeterminado que ejecutará un contenedor que use esta imagen.

Para leer todas las instrucciones o entrar en mayor detalle, consulta la referencia de Dockerfile.

Pruébalo

Tal como viste con el ejemplo anterior, un Dockerfile normalmente sigue estos pasos:

  1. Determinar tu imagen base
  2. Instalar las dependencias de la aplicación
  3. Copiar cualquier código fuente y/o binarios relevantes
  4. Configurar la imagen final

En esta rápida guía práctica, escribirás un Dockerfile que compila una aplicación simple de Node.js. Si no estás familiarizado con las aplicaciones basadas en JavaScript, no te preocupes. No es necesario para seguir esta guía.

Configuración

Descarga este archivo ZIP y extrae su contenido en un directorio de tu máquina.

Si prefieres no descargar un archivo ZIP, clona el proyecto https://github.com/docker/getting-started-todo-app y realiza un checkout de la rama build-image-from-scratch.

Crear el Dockerfile

Ahora que tienes el proyecto, estás listo para crear el Dockerfile.

  1. Descarga e instala Docker Desktop.

  2. Examina el proyecto.

    Explora el contenido de getting-started-todo-app/app/. Notarás que ya existe un Dockerfile. Es un archivo de texto simple que puedes abrir en cualquier editor de texto o de código.

  3. Elimina el Dockerfile existente.

    Para este ejercicio, simularás que estás empezando desde cero y crearás un nuevo Dockerfile.

  4. Crea un archivo llamado Dockerfile en la carpeta getting-started-todo-app/app/.

    Extensiones de archivo del Dockerfile

    Es importante tener en cuenta que el Dockerfile no tiene extensión de archivo. Algunos editores añadirán automáticamente una extensión al archivo (or complain it doesn't have one).

  5. In el Dockerfile, define tu imagen base añadiendo la siguiente línea:

    FROM node:22-alpine

  6. Ahora, define el directorio de trabajo utilizando la instrucción WORKDIR. Esto especificará dónde se ejecutarán los comandos futuros y la ruta donde se copiarán los archivos dentro de la imagen del contenedor.

    WORKDIR /app

  7. Copia todos los archivos de tu proyecto en tu máquina a la imagen del contenedor utilizando la instrucción COPY:

    COPY . .

  8. Instala las dependencias de la aplicación utilizando la CLI de yarn y su gestor de paquetes. Para hacerlo, ejecuta un comando utilizando la instrucción RUN:

    RUN yarn install --production

  9. Finalmente, especifica el comando predeterminado a ejecutar utilizando la instrucción CMD:

    CMD ["node", "./src/index.js"]

    Y con eso, deberías tener el siguiente Dockerfile:

    FROM node:22-alpine
WORKDIR /app
COPY . .
RUN yarn install --production
CMD ["node", "./src/index.js"]

Este Dockerfile aún no está listo para producción

Es importante tener en cuenta que este Dockerfile no sigue todas las mejores prácticas todavía (por diseño). Compilará la aplicación, pero las compilaciones no serán tan rápidas ni las imágenes tan seguras como podrían serlo.

Sigue leyendo para aprender más sobre cómo hacer que la imagen maximice la caché de compilación, se ejecute como un usuario no root y sobre las compilaciones multietapa.

Contenedoriza nuevos proyectos rápidamente con docker init

El comando docker init analizará tu proyecto y creará rápidamente un Dockerfile, un archivo compose.yaml y un .dockerignore, ayudándote a ponerte en marcha. Dado que aquí estás aprendiendo específicamente sobre Dockerfiles, no lo usarás ahora. Sin embargo, obtén más información al respecto aquí.

Recursos adicionales

Para obtener más información sobre cómo escribir un Dockerfile, visita los siguientes recursos:

Siguientes pasos

Ahora que has creado un Dockerfile y aprendido los conceptos básicos, es hora de aprender a compilar, etiquetar y subir las imágenes.

Compilar, etiquetar y publicar la imagen