Docker para desarrolladores: imágenes, contenedores y Compose

Has creado una aplicación que funciona en tu máquina, pero al desplegarla, algo falla. Faltan dependencias, las versiones difieren y la configuración es un desastre. Docker soluciona esto empaquetando tu aplicación y su entorno en una única unidad portátil. Este artículo explica las imágenes de Docker, los contenedores y Docker Compose con ejemplos prácticos para que puedas optimizar tu flujo de trabajo de desarrollo.

¿Qué es una imagen de Docker?

Una imagen de Docker es una plantilla de solo lectura que contiene el código de tu aplicación, el entorno de ejecución, las bibliotecas, las variables de entorno y los archivos de configuración. Piénsalo como una instantánea del entorno de tu aplicación. Las imágenes se construyen a partir de un Dockerfile, que es un archivo de texto con instrucciones.

Aquí tienes un Dockerfile sencillo para una aplicación Node.js:

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

Cada instrucción crea una capa. Las capas se almacenan en caché, por lo que al reconstruir después de un cambio en el código solo se vuelven a ejecutar los pasos desde la capa modificada en adelante. Esto hace que las compilaciones sean rápidas.

¿Qué es un contenedor de Docker?

Un contenedor es una instancia en ejecución de una imagen. Es un proceso aislado con su propio sistema de archivos, red y espacio de procesos, pero comparte el kernel del sistema operativo anfitrión. Esto hace que los contenedores sean ligeros y rápidos de iniciar en comparación con las máquinas virtuales.

Para ejecutar un contenedor a partir de una imagen:

docker run -d -p 3000:3000 --name myapp my-node-app

Esto inicia un contenedor en modo desacoplado (-d), asigna el puerto 3000 del host al puerto 3000 del contenedor (-p 3000:3000) y lo nombra myapp.

Los contenedores son efímeros por defecto. Cualquier dato escrito dentro se pierde cuando el contenedor se detiene. Para persistir datos, usa volúmenes:

docker run -v /host/data:/app/data my-node-app

¿Por qué usar Docker Compose?

Las aplicaciones reales a menudo necesitan múltiples servicios: un servidor web, una base de datos, una caché, etc. Ejecutar cada uno con docker run y enlazarlos manualmente es tedioso. Docker Compose te permite definir y ejecutar aplicaciones multicontenedor con un único archivo YAML.

Aquí tienes un docker-compose.yml para una aplicación Node.js con PostgreSQL y Redis:

version: '3.8'
services:
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
      - REDIS_URL=redis://cache:6379
    depends_on:
      - db
      - cache
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data
  cache:
    image: redis:7
volumes:
  pgdata:

Ejecuta todo con:

docker compose up -d

Compose crea una red para que los servicios puedan comunicarse entre sí por nombre (por ejemplo, db, cache). También gestiona la creación de volúmenes y el orden de dependencias.

Comandos clave de Docker para desarrolladores

• docker build -t myapp . – Construye una imagen a partir de un Dockerfile en el directorio actual.
• docker images – Lista las imágenes locales.
• docker ps – Lista los contenedores en ejecución (añade -a para todos).
• docker exec -it myapp sh – Abre una shell dentro de un contenedor en ejecución.
• docker logs myapp – Ver los registros del contenedor.
• docker compose down – Detiene y elimina los contenedores, redes y volúmenes definidos en Compose.

Buenas prácticas para Docker en desarrollo

• Usa .dockerignore para excluir node_modules, .git y otros archivos innecesarios del contexto de compilación.
• Aprovecha las compilaciones multi-etapa para mantener las imágenes de producción pequeñas. Por ejemplo, compila tu aplicación en una etapa y copia solo los artefactos a una imagen de entorno de ejecución mínima.
• Fija versiones en tu Dockerfile (por ejemplo, node:18-alpine en lugar de node:latest) para compilaciones reproducibles.
• Usa volúmenes para el código durante el desarrollo para la recarga en caliente: volumes: - .:/app en Compose.
• No ejecutes como root en producción. Crea un usuario no root en tu Dockerfile.

Errores comunes y cómo evitarlos

Error 1: Imágenes infladas. Usar una imagen base de sistema operativo completa como ubuntu puede dar como resultado imágenes de más de 1 GB. Usa variantes slim o alpine.

Error 2: Compilaciones lentas. Ordena las instrucciones del Dockerfile de menor a mayor frecuencia de cambio. Copia los archivos de paquetes e instala las dependencias antes de copiar el código fuente.

Error 3: Pérdida de datos. Usa siempre volúmenes para las bases de datos. Sin ellos, los datos desaparecen cuando se elimina el contenedor.

Error 4: Confusión con la red. En Compose, los servicios se comunican a través de una red predeterminada usando los nombres de servicio como nombres de host. No uses localhost para llegar a otro servicio.

Preguntas frecuentes

¿Cuál es la diferencia entre una imagen y un contenedor?

Una imagen es una plantilla de solo lectura; un contenedor es una instancia en ejecución de esa imagen. Puedes ejecutar varios contenedores a partir de la misma imagen.

¿Puedo usar Docker Compose en producción?

Compose es principalmente para desarrollo y pruebas. Para producción, considera orquestadores como Kubernetes o Docker Swarm, aunque Compose puede funcionar para despliegues sencillos.

¿Cómo actualizo un contenedor con código nuevo?

Reconstruye la imagen con docker build y luego recrea el contenedor: docker compose up -d --build.

¿Listo para optimizar tu flujo de trabajo de desarrollo? Prueba nuestro Analizador de registros de Nginx para depurar los registros de tu servidor web en contenedores rápidamente.