Guía de Docker Nivel Medio: Dockerfile, Volúmenes, Redes y Compose por Santiago Soñora

“Hola, mundo” en Docker

El 'Hola, mundo' en Docker consiste en ejecutar un contenedor simple basado en una imagen mínima que imprime un mensaje.

📋 Copiar

docker run hello-world

Resultado:

Output

Hello from Docker!
This message shows that your installation appears to be working correctly.

Comandos básicos

Familiarizarse con estos comandos es esencial para interactuar eficientemente con Docker:

Ver versión e información de Docker
📋 Copiar
```
docker version && docker info
```
Muestra la versión instalada de Docker y detalles sobre el demonio Docker (incluyendo info sobre contenedores, imágenes, etc.).
Listar contenedores activos
📋 Copiar
```
docker ps
```
Muestra los contenedores que se encuentran actualmente en ejecución.
Listar todos los contenedores (activos y detenidos)
📋 Copiar
```
docker ps -a
```
Muestra una lista completa de todos los contenedores, independientemente de su estado (en ejecución, detenido, etc.).
Listar imágenes
📋 Copiar
```
docker images
```
Muestra todas las imágenes Docker que tienes descargadas localmente.
Ejecutar un contenedor en modo 'detached' (segundo plano)
📋 Copiar
```
docker run -d --name mi-web -p 80:80 mi_imagen_web
```
Crea y ejecuta un contenedor llamado `mi-web` desde la imagen `mi_imagen_web` en segundo plano (`-d`) y mapea el puerto 80 del host al 80 del contenedor (`-p`).
Ejecutar contenedor con volumen montado
📋 Copiar
```
docker run -d -v mi_volumen_datos:/app/data mi_imagen_app
```
Ejecuta un contenedor y monta el volumen con nombre `mi_volumen_datos` en el directorio `/app/data` dentro del contenedor para persistir datos.
Ejecutar contenedor en una red personalizada
📋 Copiar
```
docker run -d --network mi_red_interna mi_imagen_servicio
```
Conecta el contenedor `mi_imagen_servicio` a la red definida por el usuario `mi_red_interna`.
Construir una imagen desde Dockerfile
📋 Copiar
```
docker build -t mi_usuario/mi_app:1.0 .
```
Construye una imagen a partir del `Dockerfile` en el directorio actual (`.`) y la etiqueta con el nombre `mi_usuario/mi_app` y tag `1.0`.
Construir imagen con Multi-stage build (ejemplo conceptual)
📋 Copiar
```
# Contenido de Dockerfile:
FROM node:lts as builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY .
RUN npm run build

FROM node:lts-slim
WORKDIR /app
COPY --from=builder /app/dist .
CMD ["node", "server.js"]
```
Muestra un `Dockerfile` con dos etapas (`builder` y la etapa final) para construir una aplicación Node.js, copiando solo los archivos de build a una imagen base más pequeña.
Detener un contenedor
📋 Copiar
```
docker stop id_o_nombre
```
Detiene la ejecución de un contenedor de forma 'graciosa' (enviando señal TERM, esperando un tiempo, luego KILL si es necesario).
Reiniciar un contenedor
📋 Copiar
```
docker restart id_o_nombre
```
Detiene y luego inicia un contenedor.
Eliminar un contenedor
📋 Copiar
```
docker rm id_o_nombre
```
Elimina un contenedor (debe estar detenido).
Eliminar una imagen
📋 Copiar
```
docker rmi nombre_imagen_o_id
```
Elimina una imagen (no puede tener contenedores asociados).
Inspeccionar contenedor o imagen
📋 Copiar
```
docker inspect id_o_nombre
```
Muestra la configuración detallada, el estado y otra información de bajo nivel sobre un contenedor o imagen en formato JSON.
Ver logs de un contenedor
📋 Copiar
```
docker logs id_o_nombre
```
Muestra la salida estándar (`stdout`) y de error (`stderr`) de un contenedor.
Ejecutar comando dentro de un contenedor en ejecución
📋 Copiar
```
docker exec -it id_o_nombre bash
```
Ejecuta un comando (ej: `bash` o `sh`) dentro de un contenedor en ejecución, permitiendo interactuar con él (`-it` para terminal interactiva).
Empujar (push) una imagen a un registro
📋 Copiar
```
docker push mi_usuario/mi_app:1.0
```
Sube la imagen etiquetada `mi_usuario/mi_app:1.0` al registro configurado (Docker Hub por defecto si no se especifica otro).
Crear un volumen con nombre
📋 Copiar
```
docker volume create nombre_volumen
```
Crea un volumen gestionado por Docker en el sistema de archivos del host para la persistencia de datos.
Listar volúmenes
📋 Copiar
```
docker volume ls
```
Muestra una lista de todos los volúmenes gestionados por Docker.
Eliminar volúmenes no usados
📋 Copiar
```
docker volume prune
```
Elimina todos los volúmenes que no están asociados a ningún contenedor detenido.
Crear una red personalizada
📋 Copiar
```
docker network create mi_red_privada --driver bridge
```
Crea una nueva red Docker con el driver `bridge`, aislando los contenedores conectados a ella.
Listar redes
📋 Copiar
```
docker network ls
```
Muestra una lista de todas las redes Docker.
Levantar aplicación con Docker Compose
📋 Copiar
```
docker compose up -d --build
```
Construye (o reconstruye si es necesario) las imágenes y inicia los servicios definidos en el archivo `docker-compose.yml` en modo segundo plano.
Detener servicios con Docker Compose
📋 Copiar
```
docker compose stop
```
Detiene los contenedores de los servicios definidos en el archivo Compose, pero no los elimina.
Detener y remover servicios con Docker Compose
📋 Copiar
```
docker compose down
```
Detiene y elimina los contenedores, redes por defecto y volúmenes por defecto creados por Docker Compose.

Conceptos Clave

Comprender estos conceptos fundamentales te ayudará a dominar Docker de forma más organizada y eficiente:

Dockerfile (Instrucciones, Capas, Cache):

El archivo de texto que contiene las instrucciones para construir una imagen Docker. Cada instrucción (`FROM`, `RUN`, `COPY`, `CMD`, `ENTRYPOINT`, `EXPOSE`, `WORKDIR`, `ENV`, `ARG`, `USER`, etc.) crea una nueva capa en la imagen. Docker utiliza un sistema de cache basado en el contenido de las capas para acelerar las construcciones futuras.
Imágenes y Contenedores:

La diferencia fundamental: una Imagen es una plantilla inmutable que empaqueta la aplicación y su entorno (código, librerías, dependencias, archivos de configuración). Un Contenedor es una instancia ejecutable, aislada y efímera de una Imagen. Los contenedores son ligeros y se ejecutan sobre el kernel del sistema operativo del host.
Volúmenes:

El mecanismo preferido para la persistencia de datos en Docker. Los volúmenes (gestionados por Docker) y los montajes 'bind' (directorios del host mapeados a contenedores) permiten almacenar datos importantes (bases de datos, archivos de log, configuraciones) fuera del sistema de archivos efímero del contenedor, asegurando que los datos persistan incluso si el contenedor se elimina.
Redes:

Cómo los contenedores se comunican entre sí y con el exterior. Docker ofrece diferentes drivers de red (bridge por defecto, host, overlay para Swarm/Kubernetes, macvlan). Las redes definidas por el usuario en modo bridge son comunes para aislar servicios y permitir la comunicación por nombre de servicio en Docker Compose.
Docker Compose:

Una herramienta para definir y gestionar aplicaciones compuestas por múltiples contenedores (servicios). Utiliza un archivo YAML (`docker-compose.yml`) para configurar la construcción de imágenes, redes, volúmenes, puertos y dependencias entre servicios, simplificando el despliegue y la gestión de entornos complejos (desarrollo, testing, staging simple).
Registros (Docker Hub y Privados):

Servicios para almacenar, compartir y gestionar imágenes Docker. Docker Hub es el registro público por defecto. Las empresas a menudo utilizan registros privados para sus imágenes internas. Aprender a etiquetar (`tag`) imágenes y a subirlas (`push`) y descargarlas (`pull`) es esencial para la colaboración y el despliegue.
Multi-stage Builds en Dockerfile:

Una técnica avanzada en Dockerfile que utiliza múltiples instrucciones `FROM`. Permite separar el entorno de construcción (con herramientas de compilación, SDKs) del entorno de runtime final (con solo las dependencias necesarias), resultando en imágenes finales mucho más pequeñas y seguras.
Orquestación de Contenedores (Introducción a Swarm y Kubernetes):

La necesidad de gestionar, escalar, desplegar y automatizar la operación de aplicaciones en contenedores a gran escala, a menudo en múltiples máquinas. Docker Swarm es la solución de orquestación nativa de Docker (más simple). Kubernetes es la plataforma líder de orquestación de facto en la industria (más compleja y potente). Comprender por qué se necesitan estas herramientas.
Seguridad Básica de Contenedores:

Consideraciones importantes para reducir la superficie de ataque de los contenedores. Incluye usar imágenes base mínimas y oficiales, no ejecutar procesos como root dentro del contenedor, gestionar permisos de archivo correctamente, no exponer puertos innecesarios, y considerar herramientas de escaneo de vulnerabilidades para las imágenes.
Optimización de Dockerfile y Tamaño de Imagen:

Técnicas para construir imágenes más eficientes y con menor tamaño, lo que acelera los tiempos de construcción, descarga y despliegue. Incluye ordenar las instrucciones para aprovechar el cache, minimizar el número de capas (ej: encadenar comandos RUN), usar `.dockerignore`, multi-stage builds, y elegir imágenes base optimizadas (ej: Alpine, Slim).

Casos de uso

Algunos ejemplos de aplicaciones prácticas donde se utiliza Docker:

Contenerizar aplicaciones con múltiples servicios dependientes (ej: frontend, backend, base de datos, cache):

Utilizar Docker Compose para definir, configurar y orquestar todos los servicios que componen una aplicación, simplificando la configuración del entorno de desarrollo local o despliegues sencillos.
Gestionar la persistencia de datos para bases de datos o almacenar archivos subidos por usuarios en contenedores:

Implementar volúmenes gestionados por Docker o montajes 'bind' para asegurar que los datos importantes (bases de datos, archivos de configuración, uploads) persistan más allá del ciclo de vida de los contenedores efímeros.
Configurar redes personalizadas para aislar servicios o habilitar comunicación interna controlada:

Crear redes bridge definidas por el usuario para que solo los contenedores conectados a esa red puedan comunicarse entre sí, mejorando la seguridad y la organización.
Construir imágenes optimizadas para producción con tamaño reducido y menor superficie de ataque:

Aplicar técnicas de Dockerfile como multi-stage builds, `.dockerignore`, y optimizar las instrucciones RUN para reducir el tamaño final de la imagen y eliminar dependencias de desarrollo innecesarias.
Desplegar aplicaciones multi-contenedor en un único host o clúster pequeño con Docker Compose o Swarm:

Utilizar Docker Compose o inicializar un Swarm de Docker para gestionar el despliegue básico, escalado y orquestación de aplicaciones en un entorno simple.
Crear entornos de desarrollo locales que repliquen fielmente el entorno de producción:

Usar Docker y Docker Compose para definir y levantar un entorno de desarrollo que incluya todas las dependencias (versiones de lenguaje, bases de datos, servicios externos) de forma idéntica a como estarán en producción.
Compartir imágenes de aplicaciones o servicios entre equipos o con plataformas de CI/CD:

Construir imágenes, etiquetarlas con tags significativos y subirlas a un registro (Docker Hub o privado) para facilitar la colaboración y la automatización del despliegue.
Automatizar la construcción y prueba de imágenes en pipelines de CI/CD:

Integrar comandos `docker build` y `docker push` en flujos de trabajo de integración continua/despliegue continuo para automatizar la creación y el despliegue de nuevas versiones de la aplicación.

Consejos para Principiantes

Aquí tienes algunas recomendaciones para facilitar tus inicios en Docker:

Optimiza tus Dockerfiles:

Un buen Dockerfile es clave. Ordena tus instrucciones para aprovechar el cache de capas. Usa `.dockerignore`. Considera multi-stage builds para imágenes finales pequeñas. Minimiza el número de comandos `RUN` (encadenándolos con `&&`).
Entiende a Fondo los Volúmenes para la Persistencia de Datos:

Los datos dentro de un contenedor se pierden al eliminarlo. Aprende a usar volúmenes (`docker volume create`, `-v <nombre>:/ruta`) para la base de datos, logs, archivos de configuración o cualquier dato que necesite persistir. No uses bind mounts para persistencia de datos en producción a menos que sepas lo que haces.
Domina Docker Compose para Aplicaciones Multi-servicio:

Si trabajas con backend + base de datos, frontend + API, etc., Docker Compose (`docker-compose.yml`) es indispensable. Te permite definir y orquestar todos tus servicios en un solo archivo. Aprende su sintaxis YAML.
Limpia Regularmente Recursos no Usados:

Imágenes, contenedores y volúmenes viejos pueden consumir mucho espacio en disco. Usa `docker system prune` (con cuidado), `docker image prune -a`, `docker container prune`, `docker volume prune`.
Considera la Seguridad Básica:

No ejecutes contenedores como root. Crea un usuario dentro del Dockerfile con la instrucción `USER`. Usa imágenes base mínimas. No expongas puertos innecesarios. Sé consciente de cómo manejar secretos.
Aprende a Inspeccionar Contenedores e Imágenes y a Ver Logs:

`docker inspect <id>` y `docker logs <id>` son tus herramientas clave para entender qué está pasando con tus contenedores, ver su configuración y depurar errores. `docker exec -it <id> <comando>` te permite ejecutar comandos dentro de un contenedor en ejecución.
Familiarízate con los Registros (Docker Hub, Registros Privados):

Aprende a etiquetar tus imágenes (`docker tag`) y a subirlas (`docker push`) a un registro. Esto es necesario para compartir imágenes con otros o para desplegarlas en servidores remotos.
Entiende la Diferencia entre CMD y ENTRYPOINT en Dockerfile:

Aunque ambos especifican comandos a ejecutar, tienen roles diferentes. CMD define el comando por defecto (que puede ser sobrescrito al ejecutar el contenedor). ENTRYPOINT define el comando principal del contenedor, al que se le pasan los argumentos definidos en CMD (o pasados al ejecutar `docker run`).

Herramientas relacionadas

Si te interesa Docker, también podrías explorar estas herramientas:

Recursos útiles

Amplía tus conocimientos con estos enlaces y materiales: