Servicios, Redes y Volúmenes en Compose

Introducción

En esta lección profundizaremos en los tres pilares fundamentales de Docker Compose: servicios, redes y volúmenes. Dominar estos conceptos te permitirá crear entornos de desarrollo locales robustos, reproducibles y idénticos entre todos los miembros de tu equipo.

Cuando trabajas con aplicaciones reales, rara vez tienes un solo contenedor. Típicamente necesitas una base de datos, un servidor web, un servicio de caché, quizás un message broker. Docker Compose resuelve este problema permitiéndote definir toda esta arquitectura en un único archivo docker-compose.yml.

Definición de Servicios

Los servicios son la pieza central de Docker Compose. Cada servicio representa un contenedor que se creará a partir de una imagen específica. Veamos la estructura básica:

version: '3.8'
services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    environment:
      - NODE_ENV=development
    volumes:
      - ./app:/usr/share/nginx/html
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: developer
      POSTGRES_PASSWORD: devpassword
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

Configuración avanzada de servicios

Los servicios ofrecen numerosas opciones de configuración. Veamos las más relevantes para desarrollo local:

Dependencias entre servicios

Usa la opción depends_on para asegurar que un servicio inicie después de otro:

services:
  backend:
    build: ./backend
    depends_on:
      - db
      - redis
  db:
    image: postgres:15
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes

Control de restart

Configura el comportamiento de reinicio del contenedor:

services:
  api:
    image: node:18
    restart: unless-stopped
  worker:
    image: node:18
    restart: on-failure
  monitor:
    image: prometheus
    restart: always

Las opciones disponibles son: no (nunca reiniciar), always (siempre reiniciar), on-failure (reiniciar solo si sale con código de error), y unless-stopped (reiniciar siempre excepto si se detuvo manualmente).

Variables de entorno

Docker Compose soporta múltiples formas de definir variables de entorno:

services:
  api:
    image: node:18
    environment:
      # Forma explícita
      DB_HOST: db
      DB_PORT: 5432
      # Forma corta (valor desde el host)
      - NODE_ENV
      # Archivo .env
      env_file:
        - .env.production
        - ./config/secrets.env

Redes en Docker Compose

Por defecto, Docker Compose crea una red para todos los servicios definidos, permitiéndoles comunicarse entre sí usando los nombres de servicio como hostnames. Sin embargo, puedes customize esta configuración para casos más complejos.

Redes personalizadas

Para arquitecturas más complejas, puedes definir múltiples redes:

version: '3.8'
services:
  frontend:
    image: nginx:alpine
    networks:
      - web-network
    ports:
      - "80:80"
  backend:
    image: node:18
    networks:
      - web-network
      - api-network
    depends_on:
      - db
  db:
    image: postgres:15
    networks:
      - api-network
    volumes:
      - db_data:/var/lib/postgresql/data

networks:
  web-network:
    driver: bridge
  api-network:
    driver: bridge
    internal: true  # Redisolada, sin acceso externo

DNS y resolución de nombres

Docker Compose configura automáticamente un DNS interno. Cada servicio puede resolver:

• Su propio nombre de servicio
• Otros nombres de servicio en la misma red
• alias personalizados que puedes definir

services:
  api:
    image: node:18
    networks:
      app-network:
        aliases:
          - api-service
          - rest-api

Volúmenes y Persistencia de Datos

Los volúmenes son esenciales para persistir datos más allá del ciclo de vida de un contenedor. Sin volúmenes, cualquier dato guardado dentro del contenedor se pierde cuando se elimina.

Tipos de volúmenes

Docker Compose soporta tres tipos de volúmenes:

1. Volúmenes anónimos (anonymous volumes)

services:
  app:
    image: node:18
    volumes:
      - /data  # Docker crea un volumen anónimo

2. Volúmenes con nombre (named volumes)

services:
  db:
    image: postgres:15
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Los volúmenes con nombre persisten hasta que se eliminen explícitamente con docker volume rm. Son ideales para bases de datos y cualquier dato que necesites mantener.

3. Bind mounts (montajes de enlace)

services:
  frontend:
    image: node:18
    volumes:
      - ./src:/app/src:ro  # :ro = solo lectura
      - ./package.json:/app/package.json
  api:
    image: node:18
    volumes:
      - ~/.npm:/root/.npm  # Cache de npm entre ejecuciones

Configuración avanzada de volúmenes

volumes:
  db_data:
    driver: local
    driver_opts:
      type: none
      o: bind
      device: /host/path
  s3_backup:
    driver: local-persist
    driver_opts:
      persistonchange: true

Usos prácticos de volúmenes

Veamos un ejemplo completo de una aplicación con persistencia adecuada:

version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - ./src:/app/src        # Código fuente en vivo
      - node_modules:/app/node_modules  # Preserva node_modules
    environment:
      - NODE_ENV=development
      - DB_HOST=postgres
    depends_on:
      - postgres
      - redis
    command: npm run dev

  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: myapp_dev
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: dev123
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5432:5432"

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    ports:
      - "6379:6379"
    command: redis-server --appendonly yes

volumes:
  postgres_data:
  redis_data:
  node_modules:

# Listar volúmenes
docker volume ls

# Inspeccionar un volumen
docker volume inspect mi_proyecto_postgres_data

# Eliminar volúmenes huérfanos
docker volume prune

# Eliminar un volumen específico
docker volume rm mi_proyecto_postgres_data

# Ver uso de disco
docker system df -v

Ejemplo Integrado: Stack MEAN Completo

Veamos un ejemplo completo que integra todos los conceptos:

version: '3.8'

services:
  mongodb:
    image: mongo:6
    restart: unless-stopped
    networks:
      - backend
    volumes:
      - mongodb_data:/data/db
    environment:
      MONGO_INITDB_DATABASE: myapp
    ports:
      - "27017:27017"

  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile.dev
    restart: unless-stopped
    networks:
      - backend
    volumes:
      - ./backend/src:/app/src
      - backend_modules:/app/node_modules
    environment:
      NODE_ENV: development
      MONGODB_URI: mongodb://mongodb:27017/myapp
      JWT_SECRET: dev-secret-change-in-prod
    ports:
      - "5000:5000"
    depends_on:
      - mongodb
    command: npm run dev

  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile.dev
    restart: unless-stopped
    networks:
      - frontend
      - backend
    volumes:
      - ./frontend/src:/app/src
      - frontend_modules:/app/node_modules
    environment:
      REACT_APP_API_URL: http://localhost:5000
    ports:
      - "3000:3000"
    depends_on:
      - backend
    command: npm start

  nginx:
    image: nginx:alpine
    restart: unless-stopped
    networks:
      - frontend
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/conf.d:/etc/nginx/conf.d:ro
    ports:
      - "80:80"
      - "443:443"
    depends_on:
      - backend
      - frontend

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true  # La base de datos solo es accesible internamente

volumes:
  mongodb_data:
  backend_modules:
  frontend_modules:

Debugging y Troubleshooting

Cuando algo no funciona, estos comandos te ayudarán a diagnosticar problemas:

# Ver logs de todos los servicios
docker-compose logs -f

# Ver logs de un servicio específico
docker-compose logs -f backend

# Ver logs de múltiples servicios
docker-compose logs -f backend db redis

# Ejecutar un comando en un servicio existente
docker-compose exec backend npm run debug

# Abrir una shell en un contenedor
docker-compose exec backend sh

# Ver estado de todos los servicios
docker-compose ps

# Ver configuración resuelta
docker-compose config

Resumen de Comandos Esenciales

Dominar servicios, redes y volúmenes en Docker Compose es fundamental para crear entornos de desarrollo reproducibles. Practica con ejemplos reales y experimentarás cómo Docker Compose simplifica enormemente la gestión de aplicaciones complejas.