Ir al contenido
Fundamentos de Docker

Conceptos 02 - Construcción de imágenes con Dockerfile

Referencia de conceptos e instrucciones para construir imágenes Docker de forma automatizada y reproducible. Abra cada instrucción para ver ejemplos de sintaxis y recomendaciones de uso.

  • 4 conceptos
  • 15 instrucciones
  • 3 elementos interactivos
  • Autoevaluación final
Parte 1

Conceptos

Concepto 1 de 6

Qué es un Dockerfile

Archivo de texto plano con instrucciones secuenciales para construir una imagen Docker de forma automatizada y reproducible.

Ventajas

  • Reproducibilidad
  • Versionamiento en Git
  • Automatización CI/CD
  • Documentación del entorno
  • Portabilidad

Concepto 2 de 6

Contenido de una imagen

Una imagen es una plantilla inmutable de solo lectura con todo lo necesario para ejecutar una aplicación.

Sistema operativo base

Alpine, Debian, Ubuntu u otra distribución mínima.

Runtime

Python, Node.js, JVM u otro entorno de ejecución.

Dependencias

Librerías y paquetes requeridos por la aplicación.

Código de la aplicación

El software que se ejecutará dentro del contenedor.

Configuración

Variables de entorno y comandos de inicio.

Concepto 3 de 6

Arquitectura de capas

Cada instrucción del Dockerfile crea una capa inmutable y cacheable en la imagen resultante.

  • Capa 4 → CMD ["python", "app.py"]
  • Capa 3 → COPY app.py /app/
  • Capa 2 → RUN pip install flask
  • Capa 1 → FROM python:3.11

Las capas funcionan así:

  • Cada instrucción crea una nueva capa inmutable.
  • Las capas se cachean y se comparten entre imágenes.
  • Solo la última capa es de escritura cuando se crea un contenedor.

Elija qué cambia antes de reconstruir la imagen y observe qué capas se reutilizan desde la caché. Luego cree un contenedor para ver su capa de escritura.

Antes de reconstruir
  1. CMD ["python", "app.py"]Solo metadatos: no agrega archivos · 0 BCACHED
  2. COPY app.py /app/Capa de sistema de archivos · ~4 KBCACHED
  3. RUN pip install flaskCapa de sistema de archivos · ~10 MBCACHED
  4. FROM python:3.11Capas de la imagen base · ~1 GBCACHED

Concepto 4 de 6

Contexto de construcción

El conjunto de archivos y directorios que Docker puede acceder durante la construcción de la imagen.

Ventana de terminal
$ docker build -t mi-app:1.0 .
                              ↑ contexto (directorio actual)

Active las líneas del .dockerignore y observe cuánto contexto se envía al construir. Los tamaños son ilustrativos.

.dockerignore · active cada línea

Directorio del proyecto

  • Dockerfile1 KB
  • app.py4 KB
  • requirements.txt1 KB
  • src/2 MB
  • node_modules/180 MB
  • .git/45 MB
  • dist/12 MB
  • debug.log8 MB
  • .env1 KB
docker build -t mi-app:1.0 .
=> [internal] load build context
=> => transferring context: 247.0MB

Parte 2

Instrucciones

Concepto 5 de 6

Instrucciones básicas

FROM, RUN, COPY, WORKDIR, ENV, EXPOSE, CMD, ENTRYPOINT y ADD: las instrucciones con las que se escribe la mayoría de los Dockerfile.

FROMImagen base. Define la imagen base desde la cual construir. Siempre es la primera instrucción.
FROM python:3.11-slim
FROM node:18-alpine
FROM ubuntu:22.04


# Multi-stage build
FROM node:18 AS builder
FROM nginx:alpine AS production
RUNEjecutar comandos. Ejecuta comandos durante la construcción. Cada RUN crea una nueva capa.
# Comando único
RUN apt-get update


# Múltiples comandos combinados (reduce capas)
RUN apt-get update && apt-get install -y \
    curl \
    git && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*
COPYCopiar archivos. Copia archivos o directorios del contexto de construcción a la imagen.
COPY app.py /app/app.py
COPY app.py requirements.txt /app/
COPY ./src /app/src
COPY --chown=appuser:appuser app.py /app/
COPY . /app/
WORKDIRDirectorio de trabajo. Define el directorio de trabajo para instrucciones subsecuentes. Se crea automáticamente si no existe.
WORKDIR /app


# Los comandos siguientes se ejecutan en /app
RUN ls -la
COPY . .
ENVVariables de entorno. Define variables disponibles durante la construcción y en tiempo de ejecución del contenedor.
ENV NODE_ENV=production


ENV APP_HOME=/app \
    APP_USER=appuser \
    PORT=8080


# Usar variables en instrucciones posteriores
ENV APP_DIR=/app
WORKDIR ${APP_DIR}
EXPOSEDocumentar puertos. Documenta qué puertos escucha el contenedor. No publica el puerto en el host.
EXPOSE 8080
EXPOSE 8080 8443
EXPOSE 53/udp
CMDComando por defecto. Define el comando que se ejecuta al iniciar el contenedor. Se puede sobrescribir en docker run.
# Shell form
CMD python app.py


# Exec form (recomendado)
CMD ["python", "app.py"]


# Parámetros para ENTRYPOINT
CMD ["--port", "8080"]
ENTRYPOINTPunto de entrada. Define el ejecutable principal del contenedor. No se sobrescribe fácilmente.
# Combinación típica ENTRYPOINT + CMD
ENTRYPOINT ["python", "app.py"]
CMD ["--host", "0.0.0.0"]
  • CMD: parámetros por defecto. Se sobrescribe con cualquier argumento en docker run.
  • ENTRYPOINT: ejecutable principal inmutable. Requiere --entrypoint para sobrescribirlo.
ADDCopiar con capacidades adicionales. Similar a COPY pero con extracción automática de tar y descarga de URLs.
# Extrae automáticamente archivos tar
ADD archive.tar.gz /app/


# Descarga desde URL
ADD https://example.com/file.zip /tmp/

Combine un Dockerfile con una forma de ejecutar el contenedor y observe qué proceso se inicia realmente.

Dockerfile

CMD ["python", "app.py"]

Ejecución

docker run mi-app

Proceso que se inicia (PID 1)

python app.py

Concepto 6 de 6

Instrucciones avanzadas

ARG, USER, VOLUME, LABEL, HEALTHCHECK y ONBUILD: parametrización, seguridad, metadatos y verificación de salud.

ARGArgumentos de construcción. Variables disponibles solo durante la construcción, no en runtime. Se pasan con --build-arg.
ARG PYTHON_VERSION=3.11
FROM python:${PYTHON_VERSION}


ARG BUILD_DATE
RUN echo "Build date: ${BUILD_DATE}"
Ventana de terminal
$ docker build --build-arg PYTHON_VERSION=3.12 \
  --build-arg BUILD_DATE=$(date) -t mi-app .
USERCambiar usuario. Define el usuario para ejecutar instrucciones subsecuentes y el proceso del contenedor.
# Crear usuario no-root
RUN adduser --disabled-password --gecos '' appuser


# Cambiar a usuario no-root
USER appuser


# Usuario y grupo
USER appuser:appgroup
VOLUMEPunto de montaje. Declara un punto de montaje para volúmenes persistentes.
VOLUME /data
VOLUME ["/data", "/logs", "/config"]
LABELMetadatos. Agrega metadatos a la imagen en formato clave-valor.
LABEL version="1.0.0" \
      maintainer="jesse@example.com" \
      description="Mi aplicación dockerizada" \
      org.opencontainers.image.source="https://github.com/user/repo"
HEALTHCHECKVerificación de salud. Define cómo verificar si el contenedor está saludable.
HEALTHCHECK --interval=30s --timeout=3s \
  --start-period=5s --retries=3 \
  CMD curl -f http://localhost:8080/health || exit 1


# Deshabilitar healthcheck heredado
HEALTHCHECK NONE
ONBUILDTriggers para imágenes base. Ejecuta instrucciones cuando la imagen se usa como base para otra construcción.
# En la imagen base
ONBUILD COPY . /app
ONBUILD RUN npm install


# Cuando otra imagen use FROM esta-imagen,
# los ONBUILD se ejecutan automáticamente

Autoevaluación

Comprueba lo que aprendiste

Cinco preguntas rápidas para verificar las ideas clave de la lectura. Cada respuesta incluye una explicación.

  1. 1En un Dockerfile con FROM, RUN pip install, COPY app.py y CMD, solo se modifica app.py. ¿Qué ocurre al reconstruir?
  2. 2¿Por qué conviene un .dockerignore que excluya node_modules y .git?
  3. 3Un Dockerfile define ENTRYPOINT ["python", "app.py"] y CMD ["--host", "0.0.0.0"]. ¿Qué proceso inicia docker run mi-app --port 9000?
  4. 4¿Qué hace la instrucción EXPOSE 8080?
  5. 5¿Qué diferencia a ARG de ENV?

0/5 respuestas correctas