Docker Compose: definición y administración de aplicaciones basadas en múltiples contenedores.

Docker Compose es una herramienta que permite definir y administrar aplicaciones que se ejecutan en múltiples contenedores de Docker. En lugar de tener que ejecutar y administrar cada contenedor de forma individual, Compose permite definir varios contenedores y configurar su conexión y comunicación entre sí mediante un archivo YAML (un lenguaje de marcado similar al JSON).

Cada contenedor se define en el archivo YAML con su propia imagen de Docker, configuración de red, variables de ambiente, puertos expuestos, y cualquier otra opción específica del contenedor. Docker Compose también permite definir servicios, que son un conjunto de contenedores y configuraciones relacionados que forman una aplicación completa, como una aplicación web con un servidor web, un servidor de base de datos y otros servicios.

Una vez definido el archivo YAML, Docker Compose gestiona todo el ciclo de vida de los contenedores. Permite crear y eliminar contenedores basados ​​en la configuración deseada, iniciar y detener grupos de contenedores de forma simultánea, y en general, administrar múltiples contenedores de la aplicación como si fueran una sola entidad.

Docker Compose también tiene herramientas para mostrar los registros de los contenedores, identificar problemas y resolver conflictos. En resumen, Docker Compose simplifica el trabajo con aplicaciones basadas en múltiples contenedores, eliminando la complejidad de la administración de cada contenedor individualmente.

Con su sistema de definición de archivos YAML, es fácilmente escalable y adaptable a diferentes configuraciones, y es una pieza fundamental en la automatización de la gestión de aplicaciones Docker.

Supongamos que tienes una aplicación web que consiste en una base de datos MySQL y un servidor web Nginx.

Con Docker Compose, puedes definir y administrar esta aplicación basada en dos contenedores.

Primero, crearías un archivo docker-compose.yml para describir la configuración de la aplicación:

        
version: "3"
services:
  mysql:
    image: mysql
    environment:
      MYSQL_ROOT_PASSWORD: example
    ports:
      - "3306:3306"
  nginx:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - mysql
        
    

En este archivo, se definen dos servicios: mysql y nginx.

Para cada servicio, se especifica la imagen de Docker que se usará, así como cualquier configuración adicional como puertos, variables de entorno y volúmenes.

En el caso del servicio MySQL, se proporciona una contraseña de root y se expone el puerto 3306.

El servicio Nginx, por otro lado, se vincula al puerto 80 del host y se utiliza un archivo de configuración de Nginx personalizado desde el directorio actual.

Finalmente, se establece una dependencia de nginx en mysql, lo que garantiza que la base de datos se inicie antes de que se inicie el servidor web.

Para administrar esta aplicación, simplemente ejecuta docker-compose up en el directorio que contiene el archivo docker-compose.yml.

Docker Compose creará y ejecutará los dos contenedores, y la aplicación estará disponible en el host en el puerto 80.

Un ejemplo práctico de cómo usar Docker Compose para definir y administrar una aplicación basada en varios contenedores.

Supongamos que queremos crear un entorno de desarrollo local para una aplicación web con una base de datos MySQL. Para ello, necesitamos tener dos contenedores: uno para la aplicación web y otro para la base de datos.

1. Primero, creamos un archivo docker-compose.yml con la siguiente definición:

                   
   version: '3'
   services:
     web:
       build: .
       ports:
         - "8000:8000"
       depends_on:
         - db
     db:
       image: mysql:5.7
       environment:
         MYSQL_DATABASE: ejemplo
         MYSQL_USER: usuario
         MYSQL_PASSWORD: contraseña
         MYSQL_ROOT_PASSWORD: rootcontraseña
       volumes:
         - db_data:/var/lib/mysql
   volumes:
     db_data:
                   
               

   En este archivo, definimos dos servicios: web y db. El servicio web se construye a partir de un archivo Dockerfile en el directorio actual (build: .) y expone el puerto 8000. El servicio db utiliza la imagen oficial de MySQL 5.7 y crea una base de datos con nombre "ejemplo" y usuario "usuario" con contraseña "contraseña". Además, definimos un volumen db_data para que los datos de la base de datos se almacenen en el host en lugar de en el contenedor.

2. Luego, creamos el archivo Dockerfile para el servicio web, que podría ser algo así como:

                   
   FROM python:3
   ENV PYTHONUNBUFFERED 1
   RUN mkdir /code
   WORKDIR /code
   COPY requirements.txt /code/
   RUN pip install -r requirements.txt
   COPY . /code/
                   
               

3. A continuación, creamos un archivo requirements.txt que contiene las dependencias de nuestra aplicación Python.

                   
   Django~=2.2.0
   mysqlclient==1.4.2.post1
                   
               

4. Ahora que hemos definido nuestra aplicación y nuestros servicios, podemos ejecutar $ docker-compose up en la terminal para iniciar nuestros contenedores. Docker Compose proporciona una forma fácil de crear, ejecutar y administrar aplicaciones que constan de varios contenedores. Con esta herramienta, podemos definir nuestras dependencias y servicios en un solo archivo YAML para que podamos mover fácilmente nuestra aplicación entre entornos y asegurarnos de que se ejecute de manera confiable y consistente en cualquier lugar.