Guía Docker Compose: Simplificar el desarrollo multicontenedor

Docker Compose simplifica la gestión de aplicaciones Docker multicontenedor, permitiendo a los programadores escribir y ejecutar aplicaciones complejas sin esfuerzo.

Los ingenieros de DevOps intermedios, programadores de backend y programadores nativos de la nube, especialmente los que trabajan en microservicios o arquitecturas multiservicio, se enfrentan a menudo al reto de gestionar numerosos contenedores interconectados. Docker Compose aborda estas complejidades, agilizando los flujos de trabajo de desarrollo y pruebas. 

En este artículo aprenderás todo lo que necesitas para utilizar Docker Compose. Consulta nuestra Guía Docker para principiantes si estás empezando con Docker. 

¿Qué es Docker Compose?

Docker Compose es una herramienta diseñada para definir y orquestar aplicaciones Docker multicontenedor mediante un único archivo de configuración YAML. 

Con Compose, puedes especificar fácilmente servicios, redes, volúmenes, configuraciones de entorno y dependencias. Es ideal para el desarrollo local, las configuraciones de prueba, la creación rápida de prototipos y los entornos de producción más pequeños.

Los casos de uso habituales de Docker Compose incluyen la creación de entornos locales que reflejen sistemas del mundo real, como arquitecturas de microservicios. Al definir claramente las interacciones de los componentes, Compose proporciona coherencia, facilidad de uso y ciclos de iteración más rápidos.

Quizá te preguntes por qué no utilizar simplemente Kubernetes. En primer lugar, es excesivo para proyectos pequeños y pruebas locales. Como descubrirás en nuestra página Kubernetes vs. Kubernetes. Docker tutorial, Kubernetes es más adecuado para gestionar múltiples contenedores a través de clusters. Nuestro curso de Contenedores y Virtualización con D ocker y Kubernetes profundiza en cómo crear y desplegar aplicaciones con Docker y Kubernetes. 

Por qué utilizar Docker Compose frente a ¿Comandos Docker manuales?

Gestionar varios contenedores individualmente puede convertirse rápidamente en un caos debido a:

• Órdenes de dependencia complejas, 
• Entornos incoherentes, y 
• Problemas de escalabilidad. 

Con comandos manuales, te arriesgas a errores humanos, desviaciones de configuración y flujos de trabajo ineficaces. 

Docker Compose ayuda a resolver estos problemas definiendo todos los servicios y dependencias de la aplicación en un archivo YAML. Esto aporta coherencia, escalabilidad y facilidad de gestión de las dependencias, reduciendo significativamente los errores e impulsando la productividad.

Componer es más rápido que crear los contenedores manualmente y conectarlos. Además, componer crea una red por defecto para la comunicación entre todos los contenedores. Además, gestiona los volúmenes, asegurando su reacoplamiento automático tras la sustitución o reinicio del servicio. 

Puedes aprender a contenerizar aplicaciones de machine learning con Docker y Kubernetes en nuestro tutorial Cómo contenerizar una aplicación utilizando Docker . 

¿Cuál es la diferencia entre Docker y Docker Compose?

Mientras que Docker es la plataforma para construir, ejecutar y gestionar contenedores, Docker Compose es la herramienta que facilita la definición y gestión de varios contenedores mediante un archivo YAML, principalmente docker-compose.yml. 

Docker maneja contenedores individuales, pero Docker Compose te permite apilarlos en un único servicio. Por ejemplo, una aplicación con backend, frontend, base de datos, caché, etc. 

Puedes construir y ejecutar tus contenedores sin Docker Compose. Sin embargo, encapsularlo todo en un único archivo docker-compose.yml facilita la gestión de varios contenedores. También permite poner en marcha tu aplicación en cualquier entorno con un solo comando. 

Comprender Docker y Docker Compose es crucial para superar tus próximas entrevistas. Asegúrate de que estás preparado explorando las 26 mejores preguntas y respuestas de la entrevista Docker de 2025. 

Fundamentos de Docker Compose

Antes de entrar en detalles prácticos, es esencial comprender los principios básicos y la sintaxis de Docker Compose. Antes de utilizar Compose, asegúrate de que tienes instalado Docker siguiendo las instrucciones de nuestra Instalar Docker en Ubuntu: Guía "De la instalación al primer contenedor". 

Marco conceptual

Docker Compose abstrae la complejidad de la orquestación de contenedores para el desarrollo local y despliegues más sencillos. Con un archivo de composición con formato YAML, declaras qué servicios necesitan, defines sus dependencias, especificas redes, volúmenes, variables de entorno y mucho más. Compose gestiona eficazmente el arranque, la parada, el escalado y la interconexión de estos servicios.

Sintaxis de Core Compose

Docker Compose gira en torno a una sencilla sintaxis YAML. Los componentes básicos incluyen:

• services para definir aplicaciones en contenedores
• images o build contextos para especificar contenedores
• ports para exponer servicios
• volumes para el almacenamiento persistente de datos
• networks para la comunicación entre servicios

Definición del servicio y arquitectura de la aplicación

Los archivos de composición representan los servicios y conexiones de la aplicación.

Definición de los servicios

Los servicios son el núcleo de un archivo Compose. Puedes definir y nombrar claramente varios servicios (como interfaces web, bases de datos y servicios de caché), especificando las dependencias mediante palabras clave sencillas como depends_on para controlar el orden de inicio de los contenedores.

Conceptos básicos sobre redes

Docker Compose crea automáticamente redes predeterminadas para facilitar la comunicación entre los servicios definidos. Los programadores también pueden especificar redes personalizadas si es necesario para mejorar el aislamiento o para requisitos de red detallados.

Gestión del volumen

Los volúmenes permiten la persistencia de los datos más allá de los ciclos de vida de los contenedores. Puedes especificar volúmenes con nombre o montar directorios host en contenedores, asegurando que las bases de datos, registros u otros datos con estado persistan de forma consistente.

Variables de entorno

Compose simplifica el paso seguro de variables de entorno y secretos a los contenedores. Admite declaraciones directas bajo servicios y referenciar variables almacenadas en env junto a archivos de composición para mantener los valores sensibles protegidos y separados de las definiciones de Docker.

Escalado y orquestación de Docker Compose

Docker Compose también agiliza el escalado y la orquestación básicos, lo que resulta especialmente útil para escenarios de pruebas de carga rápidas o para evaluar servicios paralelos.

Escalar los servicios

La bandera "-escala" de Componer te permite crear varias copias de servicios rápidamente. Esto facilita la comprobación de escenarios como la evaluación del equilibrio de carga o la gestión de solicitudes simultáneas.

Por ejemplo, escalar el contenedor de una aplicación Flask puede hacerse con un solo comando:

docker-compose up --scale flaskapp=4

Docker Compose frente a Docker Swarm y Kubernetes

Aunque Docker Compose destaca en el desarrollo local y las configuraciones a pequeña escala, está limitado en la orquestación a escala de producción y con varios hosts. Para escenarios complejos, de nivel de producción en numerosos hosts, son adecuados orquestadores más robustos como Docker Swarm o Kubernetes, ya que ofrecen un potente equilibrio de carga, autorreparación, redes avanzadas y escalabilidad a gran escala que no están disponibles en Compose.

Nuestro Docker Compose vs. Docker Compose. La entrada del blog de Kubernetes profundiza en las principales diferencias entre Docker Compose y Kubernetes.  

Técnicas de Optimización para un Uso Eficiente de la Composición

La utilización eficiente de Docker Compose incluye optimizar las compilaciones, añadir comprobaciones de estado y gestionar los recursos del servicio. En esta sección, aprenderás más sobre estas técnicas de optimización.

Estrategias de construcción eficientes

El uso de compilaciones multietapa en Dockerfiles ayuda a reducir el tamaño de las imágenes Docker, mientras que el aprovechamiento explícito del almacenamiento en caché de las compilaciones acelera significativamente los procesos de desarrollo e IC.

Controles sanitarios y políticas de reanudación

Compose te permite definir comprobaciones explícitas del estado del contenedor para mantener la fiabilidad de la aplicación. Las políticas de reinicio ayudan a garantizar que los contenedores averiados se reinicien automáticamente, mejorando la resiliencia.

Gestionar los límites de recursos

Establecer límites de CPU y memoria directamente dentro de las definiciones YAML de Componer te ayuda a controlar las asignaciones de recursos, mejorando la previsibilidad y la eficiencia de los recursos.

Un fragmento de ejemplo para los límites de recursos:

services:
  flaskapp:
    image: flask
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M

Ejemplo práctico: Aplicación multicontenedor

He aquí un ejemplo real simplificado de una aplicación Python Flask combinada con Redis:

services:
  redis:
    image: redis:7
    container_name: redis
    ports:
      - "6379:6379"
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3
  web:
    build: .
    container_name: flask_app
    command: gunicorn app:app --worker-class gevent --bind 0.0.0.0:5000 --timeout 3000
    ports:
      - "5000:5000"
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

  worker:
    build: .
    container_name: celery_worker
    command: celery -A celery_worker.celery worker --loglevel=info
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

El archivo Docker Compose define una aplicación multicontenedor con tres servicios:

1. redis
2. web (aplicación Flask con Gunicorn)
3. trabajador (Trabajador apio)

Para el servicio redis:

• Utiliza la imagen oficial de Redis 7.
• Establece el nombre del contenedor en redis.
• Asigna el puerto 6379 dentro del contenedor al 6379 en el host.
• Se reinicia siempre si se bloquea (reiniciar: siempre).
• Define un healthcheck que ejecuta redis-cli ping cada 30 segundos, agota el tiempo de espera a los 5 segundos y vuelve a intentarlo 3 veces antes de declarar que el contenedor no está sano.

Para el servicio web:

• Construye la imagen a partir del directorio actual (build: . ).
• Nombra el contenedor flask_app.
• Ejecuta el comando gunicorn app:app utilizando gevent workers, enlazando con 0.0.0.0:5000, con un tiempo de espera largo de 3000 segundos
• Asigna el puerto 5000 del contenedor al 5000 del host.
• Declara una dependencia del servicio redis, asegurando que Redis se inicie primero.
• Establece una variable de entorno REDIS_URL que apunta al contenedor interno de Redis.
• Carga variables de entorno adicionales del archivo .env.
• Monta tres carpetas locales en el contenedor:
• ./shorts a /app/shorts,
• ./temp_uploads a /app/temp_uploads 
• ./uploads a /app/uploads
• Configurado para reiniciarse siempre si se bloquea.

Para el trabajador servicio:

• También construye la imagen desde el directorio actual (construir: .), reutilizando el mismo archivo Docker que el archivo web web.
• Nombra el contenedor: celery_worker.
• Ejecuta el comando celery -A celery_worker.celery worker --loglevel=info que inicia un trabajador Celery para procesar trabajos en segundo plano.
• Declara una dependencia del servicio redis, asegurando que Redis se inicie primero.
• Establece la misma variable de entorno REDIS_URL para conectar con el broker de Redis.
• Carga otras variables de entorno del archivo .env.
• Monta las mismas tres carpetas que el web permitiendo que tanto la aplicación web como el trabajador compartan archivos y cargas.
• Configurado para reiniciarse siempre si se bloquea.

Explora más ideas de proyectos Docker en nuestro tutorial 10 ideas de proyectos Docker. 

Crear y ejecutar aplicaciones multicontenedor

Docker Compose ofrece un conjunto de herramientas sencillas para las tareas rutinarias de los contenedores:

Imágenes de edificios

Utiliza docker compose build para generar imágenes de contenedores según los archivos Docker que hayas definido. Cubrimos más información sobre la creación de imágenes Docker en nuestro Cómo aprender Docker desde cero: Guía para profesionales de los datos tutorial. 

Servicios de ejecución

Utilizando docker compose up se inician todos los servicios definidos en el archivo de composición. Para el modo independiente, utiliza docker compose up -d. Nuestro curso Introducción a Docker entra en más detalles sobre la ejecución de un contenedor en segundo plano. 

Ver contenedores en ejecución

Para ver los contenedores activos y sus estados, utiliza docker compose ps para listar todos los servicios en ejecución.

Detener los servicios

Utiliza docker compose down para detener los servicios en ejecución. 

Ver registros

Utiliza docker compose logs para comprobar los registros. Puedes especificar un contenedor del que comprobar los registros utilizando docker logs container_name. Para transmitir los registros, utiliza docker compose -f container_name. 

Nuestra guía Los 18 mejores comandos de Docker para crear, ejecutar y gestionar contenedores desglosa más comandos de Docker para que puedas gestionar con confianza aplicaciones en distintos entornos.

Casos de uso avanzados de Docker Compose 

Los flujos de trabajo compuestos se adaptan a configuraciones de desarrollo más complejas o a distintas configuraciones de entorno.

Configuración multientorno

Múltiples archivos de composición o archivos de anulación facilitan diferentes configuraciones del entorno (desarrollo, pruebas, producción). Esto mantiene las definiciones mantenibles y legibles, permitiendo modificaciones rápidas sin configuraciones desordenadas.

Gestión de la dependencia

Mientras que depends_on se encarga de la ordenación básica del arranque, los escenarios complejos pueden incorporar scripts de inicialización (como "espera-por-ello"), asegurando que los contenedores sólo se inicien cuando se cumplan determinadas condiciones, como que la base de datos esté lista.

Integración con CI/CD

Compose se integra sin esfuerzo en los flujos de trabajo de integración continua, automatizando la configuración completa del entorno para las pruebas. Plataformas como GitLab CI y GitHub Actions ofrecen enfoques nativos o sencillos para la integración de Compose, agilizando las pruebas automatizadas.

Buenas prácticas y retos comunes

Puedes evitar errores comunes y crear configuraciones fáciles de mantener organizando y estructurando las definiciones de Composición cuidadosamente.

Organización de archivos de composición

Mantén tus archivos de composición claros y modulares. Para proyectos más sencillos, puede bastar con un único archivo, pero para aplicaciones más grandes, considera la posibilidad de dividir la configuración en varios archivos Compose utilizando la función de anulación. Esto permite:

• Separación lógica de los componentes (por ejemplo, docker-compose.backend.yml, docker-compose.frontend.yml)
• Personalización más fácil del entorno local frente al de producción
• Control de versiones y colaboración racionalizados, ya que los cambios en un servicio no afectan a todo el archivo

Utiliza nombres de servicio significativos y una sangría coherente para que los archivos sean más fáciles de leer y navegar.

Peligros potenciales

Ten en cuenta estos errores comunes:

• Utilizar etiquetas latest para las imágenes: Esto introduce imprevisibilidad, ya que la versión real de la imagen puede cambiar con el tiempo. Fija siempre las versiones de las imágenes explícitamente (por ejemplo, postgres:15.1) para garantizar la coherencia entre entornos.
• Secretos de codificación: Nunca incluyas datos sensibles (por ejemplo, claves API, contraseñas) directamente en los archivos Compose. En su lugar, utiliza variables de entorno, archivos .env (excluidos del control de versiones) o herramientas de gestión de secretos como Docker Secrets para un manejo seguro.
• Definiciones de servicio excesivamente complejas: Resiste el impulso de meter demasiada lógica o demasiadas responsabilidades en un solo recipiente. Sigue el principio de responsabilidad única, y favorece la simplicidad siempre que sea posible.
• Descuidar la creación explícita de redes: Define redes personalizadas en Compose en lugar de confiar en el comportamiento por defecto. Esto ofrece un mejor control sobre la comunicación de los servicios, reduce los conflictos entre puertos y mejora los límites de seguridad.

Si adoptas estas prácticas, tus flujos de trabajo basados en Compose serán más sólidos, seguros y fáciles de mantener en entornos colaborativos o en evolución.

Conclusión

Docker Compose simplifica significativamente la creación, gestión y ejecución de aplicaciones multicontenedor para los programadores. Sus claras definiciones basadas en YAML, su facilidad de orquestación y su escalabilidad directa lo hacen inestimable para escenarios de desarrollo local y arquitecturas de despliegue más sencillas. Aunque los orquestadores avanzados como Docker Swarm y Kubernetes son más adecuados para cargas de trabajo de producción a gran escala, Compose sigue siendo un punto de entrada esencial para comprender los fundamentos de la orquestación de contenedores y mejorar los flujos de trabajo de los programadores.

Consulta nuestros cursos de Docker para aprender:

• Containerización y virtualización con Docker y Kubernetes 
• Docker intermedio