Building Multi-Container Applications with Docker Compose

A medida que el desarrollo de software adopta cada vez más la arquitectura de microservicios, la necesidad de gestionar aplicaciones complejas que involucran múltiples servicios se ha vuelto primordial. Docker Compose surge como una herramienta vital que simplifica la orquestación de aplicaciones de múltiples contenedores. Este artículo tiene como objetivo profundizar en las funcionalidades avanzadas de Docker Compose, ofreciendo información sobre sus capacidades y proporcionando ejemplos prácticos para ilustrar su uso.

Understanding Docker Compose

Docker Compose es una herramienta diseñada para definir y gestionar aplicaciones Docker de múltiples contenedores. Permite a los desarrolladores especificar los servicios, redes y volúmenes que su aplicación requiere en un solo archivo YAML, que generalmente se denomina docker-compose.yml. Con unos pocos comandos, los desarrolladores pueden compilar, iniciar, escalar y detener múltiples contenedores, facilitando un flujo de trabajo optimizado.

Conceptos Fundamentales

Before diving into Docker Compose, it’s essential to understand some core concepts:

• Servicios: A service is defined in the docker-compose.yml archivo y representa un único contenedor o un grupo de contenedores en ejecución con la misma imagen.

• NetworksDocker Compose te permite crear redes personalizadas para una mejor comunicación entre servicios. Cada servicio puede comunicarse a través de una red privada, mejorando la seguridad y reduciendo la complejidad.

• VolumesLos volúmenes se utilizan para persistir los datos generados y utilizados por los contenedores de Docker. Docker Compose facilita la definición y gestión de volúmenes para sus servicios.

Setting Up Docker Compose

Para arrancar nuestra exploración de Docker Compose, comenzaremos configurando el entorno. Asegúrate de tener Docker instalado en tu máquina. Docker Compose se incluye con Docker Desktop; sin embargo, si estás utilizando una distribución de Linux, es posible que necesites instalarlo por separado.

Instalación

En Ubuntu, por ejemplo, se puede instalar Docker Compose utilizando los siguientes comandos:

sudo apt-get update
sudo apt-get install docker-compose

Una vez instalado, puedes verificar la instalación comprobando la versión:

docker-compose --versión

Creando una Aplicación Simple

Vamos a crear una aplicación multi-contenedor simple usando Docker Compose. Para nuestro ejemplo, construiremos una pila de aplicaciones web que consta de una API Flask, una caché Redis y una base de datos PostgreSQL.

Estructura del Proyecto

Primero, crea la siguiente estructura de directorios:

myapp/
├── Dockerfile
├── app.py
├── requirements.txt
└── docker-compose.yml

Escribir el código de la aplicación

En requirements.txt, definiremos las dependencias necesarias para nuestra aplicación Flask:

Flask==2.0.2
redis==4.0.2
psycopg2==2.9.1

En app.py, escribiremos una aplicación Flask simple que interactúa con Redis y PostgreSQL:

from flask import Flask
import redis
import psycopg2

app = Flask(__name__)

# Configurar Redis
redis_client = redis.StrictRedis(host='redis', port=6379, decode_responses=True)

# Configurar PostgreSQL
def get_db_connection():
    conn = psycopg2.connect(host='db', database='mydb', user='myuser', password='mypassword')
    return conn

@app.route('/')
def index():
    redis_client.incr('hits')
    return f'Hola Mundo! Esta página ha sido vista {redis_client.get("hits")} veces.'

@app.route('/db')
def db():
    conn = get_db_connection()
    cur = conn.cursor()
    cur.execute('SELECT message FROM messages;')
    message = cur.fetchone()
    cur.close()
    conn.close()
    return message[0] if message else 'No se encontraron mensajes.'

if __name__ == '__main__':
    app.run(host='0.0.0.0')

Writing the Dockerfile

Ahora, crearemos un... Dockerfile for our Flask application:

# Use the official Python image from the Docker Hub
FROM python:3.9-slim

# Set the working directory
WORKDIR /app

# Copy the requirements file and install dependencies
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

# Copy the application code
COPY app.py ./

# Expose the application port
EXPOSE 5000

# Command to run the application
CMD ["python", "app.py"]

Creación de la configuración de Docker Compose

Ahora, definamos los servicios en el docker-compose.yml:

```
version: '3.8'

servicios:
  web:
    build: .
    puertos:
      - "5000:5000"
    depende_de:
      - redis
      - db
    entorno:
      REDIS_HOST: redis
      POSTGRES_HOST: db

  redis:
    imagen: redis:alpine

  db:
    imagen: postgres:13
    reiniciar: siempre
    entorno:
      POSTGRES_DB: mydb
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
    volúmenes:
      - db_data:/var/lib/postgresql/data

volúmenes:
  db_data:
```

Explanation of the Configuration

En el docker-compose.yml archivo, hemos definido tres servicios: web, redis, and db.

• web: This service builds from the Dockerfile located in the current directory. It exposes port 5000 to allow access to the Flask application. The depends_on la directiva asegura que redis and db Los servicios se inician antes de web servicio.

• redis: Este servicio utiliza la imagen oficial de Redis de Docker Hub.

• db: This service runs a PostgreSQL database. It uses environment variables to set up the database, user, and password. A volume (datos_bd) se define para persistir los datos de la base de datos.

Ejecutando la aplicación

Con todo configurado, puedes iniciar tu aplicación multi-contenedor ejecutando:

docker-compose up

Este comando construirá los servicios y arrancará la aplicación. Una vez que la aplicación esté en funcionamiento, podrás acceder a ella en http://localhost:5000. Deberías ver el mensaje que indica cuántas veces se ha visto la página.

Scaling the Services

One of the powerful features of Docker Compose is the ability to scale services. For instance, to scale the web service to 3 instances, you can run the following command:

docker-compose up --scale web=3

This command will start three instances of the web service, allowing load balancing between them.

Advanced Configuration

As your application grows in complexity, you may want to incorporate more advanced features of Docker Compose.

Redes personalizadasEn el capítulo anterior, aprendiste a usar redes neuronales preentrenadas para realizar predicciones. En este capítulo, aprenderás a crear tus propias redes neuronales desde cero. Primero, aprenderás a crear una red neuronal personalizada para clasificar ropa. Luego, aprenderás a crear una red neuronal personalizada para clasificar imágenes de frutas. Finalmente, aprenderás a crear una red neuronal personalizada para predecir el precio de una casa.

Por defecto, Docker Compose crea una sola red para tu aplicación. Puedes definir múltiples redes en tu docker-compose.yml file:

redes:
  frontend:
  backend:

You can assign services to specific networks:

services:
  web:
    networks:
      - frontend
  redis:
    networks:
      - backend
  db:
    networks:
      - backend

Health Checks

Definir las comprobaciones de estado es fundamental para garantizar que tus servicios se ejecutan correctamente. Puedes agregar comprobaciones de estado usando el... chequeo de salud propiedad

services:
  web:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000/"]
      interval: 30s
      timeout: 10s
      retries: 5

Environment Variables and Secrets

Puedes pasar variables de entorno para la configuración utilizando el entorno clave:

environment:
  - FLASK_ENV=production

Para información sensible, Docker Compose admite secretos, que pueden definirse y utilizarse de forma segura dentro de sus servicios.

secrets:
  db_password:
    file: ./secrets/db_password.txt

services:
  db:
    environment:
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password

Using External Volumes

Instead of defining volumes within docker-compose.yml, you can use external volumes, which are managed outside of your Compose application:

volumes:
  db_data:
    external: true

Depuración y Registro

Docker Compose integrates seamlessly with Docker logs, allowing you to view logs from all services. You can view the logs with:

docker-compose logs -f

This command follows the logs and displays output from all services, which is invaluable for debugging.

Conclusión

Docker Compose es una herramienta poderosa para gestionar aplicaciones de múltiples contenedores, ofreciendo simplicidad y flexibilidad a través de su configuración YAML. Al permitir a los desarrolladores definir servicios, redes y volúmenes en un solo archivo, Docker Compose agiliza el proceso de desarrollo y despliegue.

As applications become more complex, the advanced features discussed—such as custom networks, health checks, environment variables, and logging—become essential for maintaining robust and reliable applications. Whether you’re building microservices or simple web applications, understanding Docker Compose is a crucial skill in the modern development landscape.

By mastering these advanced Docker Compose features, you’ll be well-equipped to handle the demands of deploying and managing complex applications effectively. Happy coding!