Herramienta de composición Docker para ejecutar aplicaciones de contenedores múltiples

El objetivo de este artículo es mostrar cómo ejecutar aplicaciones de varios contenedores con un solo comando. Compose es una herramienta para definir y ejecutar aplicaciones Docker de varios contenedores. Con Compose, utiliza un archivo de configuración (archivo YAML) para configurar sus contenedores docker. Luego, con un solo comando, crea e inicia todos los servicios (contenedores) desde su configuración. Permítanme explicar esto tomando un ejemplo. 

En este artículo se espera que esté familiarizado con Docker y tenga una experiencia considerable en su uso.

Digamos que tenemos una aplicación simple que tiene dos componentes, una aplicación de matraz y una base de datos redis. Iré ejecutando la aplicación completa con y sin usar la herramienta docker-compose, lo que le daría un mayor uso de esta herramienta de redacción.

Creando el proyecto

Crear directorio gfg_docker_compose contiene nuestro proyecto

$ mkdir gfg_docker_compose

Mover a ese directorio

$ cd gfg_docker_compose

Cree el archivo de requisitos.txt

gfg_docker_compose/ $ touch requirements.txt

Cópielo en los  requisitos.txt

flask
redis

Crear archivo app.py tendrá el código para nuestra aplicación de matraz

gfg_docker_compose/ $ touch app.py

Copie el siguiente código en app.py 
 

from flask import Flask, request, jsonify
from redis import Redis
 
# initializing a new flask app
app = Flask(__name__)
 
# initializing a new redis database
# Hostname will be same as the redis service name
# in the docker compose configuration
redis = Redis(host ="localhost", db = 0, socket_timeout = 5,
              charset ="utf-8", decode_responses = True)
 
# Our app has a single route allowing two methods POST and GET.
 
 
@app.route('/', methods =['POST', 'GET'])
def animals():
 
    if request.method == 'POST':
        # Take the name of the animal
        name = request.json['name']
        # push the name to the end of animals list in the redis db
        redis.rpush('animals', {'name': name})
        # return a success
        return jsonify({'status': 'success'})
 
    if request.method == 'GET':
        # return complete list of names from animals
        return jsonify(redis.lrange('animals', 0, -1))

Explicación:

Simplemente estamos aceptando requests GET y POST de dos métodos para la ruta `/`. Cada vez que se realiza una solicitud POST con el nombre, el nombre se agrega al final de la lista de animales. Para la solicitud GET, devolveremos la lista de nombres de la lista de animales.

Crear el archivo acoplable

gfg_docker_compose/ $ touch dockerfile

Copie el siguiente código en el dockerfile 

# pulling the base image
FROM python:3.7.0-alpine3.8
 
# Creating a folder and moving into it
WORKDIR /usr/src/app
 
# Copying the dependency list
COPY requirements.txt ./
 
# Installing the python dependencies
RUN pip install --no-cache-dir -r requirements.txt
 
# Copying the flask code into the container
COPY . .
 
ENV FLASK_APP=app.py
 
EXPOSE 5000
 
# Starting the server
CMD flask run --host=0.0.0.0

Explicación:

Comenzaremos con la imagen base python:3.7.0-alpine3.8. Copiaremos el archivo requirements.txt e instalaremos todas las dependencias de nuestra aplicación de matraz. Luego copiaríamos el archivo app.py en el contenedor y finalmente ejecutaríamos la aplicación del matraz. 

Y ahora estamos listos con la aplicación docker.

Sin herramienta docker-compose

Iniciar y usar esta aplicación sin la herramienta de redacción sería complicado para una aplicación de varios contenedores, ya que debe recordar la configuración completa y usarla cada vez que ejecute la aplicación. Veamos cómo es normalmente sin la herramienta de redacción

Ahora tendrá un árbol de proyecto como

gfg_docker_compose
--- app.py
--- requirements.txt
--- Dockerfile

Ahora se ejecutará e iniciará nuestro contenedor de servidor redis

gfg_docker_compose/ $  docker run --name=redis redis:4.0.11-alpine

se inicia el servidor redis

Entonces, usando ese comando, extraeremos redis: 4.0.11-alpine image y ejecutaremos un contenedor redis. Ahora nuestro redis ha comenzado, por lo que debe tomar la dirección IP del contenedor.

gfg_docker_compose/ $ docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' redis

Extraer la dirección IP del contenedor redis

esto le da una dirección IP que debe colocar en el parámetro de host en app.py. 

Ahora la línea se ve como en app.py

redis = Redis(host="IPAddress", db=0, socket_timeout=5,
              charset="utf-8", decode_responses=True)

donde IPAddress es la dirección IP que obtiene del contenedor redis.

Cree la aplicación del matraz

gfg_docker_compose/ $  docker build -t gfg/flask-app .

Nuestra imagen gfg/flask-app está construida con éxito

Espere un momento y se creará la imagen de la aplicación.

Ahora también iniciaremos nuestro contenedor de aplicaciones de matraz. 

Abra una nueva pestaña de terminal y ejecute el siguiente comando

gfg_docker_compose/ $  docker run -p 5000:5000 gfg/flask-app

Se inicia nuestra aplicación de matraz.

Entonces, al usar ese comando, extraeremos la aplicación gfg/flask que hemos creado anteriormente y ejecutaremos nuestro contenedor de aplicaciones de frasco. Además, -p se usa para asignar el puerto 5000 del contenedor al host.

Finalmente, cuando se dirige a la aplicación del matraz en un navegador, debería ver algo como esto.

Nuestra aplicación está funcionando.

Con la herramienta docker-compose

Con la herramienta docker-compose, el proceso de configuración de las aplicaciones docker de varios contenedores será bastante sencillo. La idea detrás de esto es que escribiremos la configuración completa del contenedor en un archivo YAML llamado docker-compose.yml y luego, con comandos simples, podemos iniciar y detener la aplicación. Este método también nos ayudará a compartir nuestras aplicaciones docker fácilmente con otros desarrolladores, simplemente compartiendo el archivo docker-compose y el proyecto.

crear el archivo docker-compose.yml

gfg_docker_compose/ $  touch docker-compose.yml

Ahora el árbol del proyecto se vería así

gfg_docker_compose
--- app.py
--- requirements.txt
--- Dockerfile
--- docker-compose.yml

Ahora copie el siguiente código YAML en el archivo docker-compose.yml .

version: '3'
 
services:
  app:
    build: .
    image: gfg/flask-app
    environment:
      - FLASK_ENV=development
    ports:
      - 5000:5000
 
  redis:
    image: redis:4.0.11-alpine

Explicación:

• version: indica la versión de docker-compose a usar, aquí estamos usando la versión 3
• services: contiene todas las configuraciones de nuestros servicios de aplicación (contenedor).
• aplicación: hemos denominado nuestra aplicación de matraz como servicio de aplicación, siéntase libre de darle cualquier otro nombre que desee.
• build: ruta relativa al Dockerfile
• imagen: nombre de la imagen final de la aplicación docker
• entorno: lista de variables de entorno
• puertos: lista de puertos que se asignarán desde el contenedor a la máquina host
• redis: nombre de nuestro servicio redis
• imagen: nombre de la imagen.

NOTA: La aplicación de nombres de servicio y redis también son el nombre de host para los servicios (contenedores) que ejecutamos porque docker-compose crea automáticamente una red y agrega nuestros contenedores a esa red para que cada contenedor pueda reconocer otros contenedores por su nombre de servicio como nombre de host dentro de esa red . Entonces, esta es la razón por la que mantendremos el parámetro de host en el archivo app.py para que se rediseñe.

Iniciar la aplicación

gfg_docker_compose/ $  docker-compose up --build

Una salida exitosa de docker-compose up se ve así

–build se usa para mencionar explícitamente la creación de imágenes antes de iniciar la aplicación.

Puede ver la aplicación funcionando de la siguiente manera

Nuestra aplicación acoplable está funcionando

Detener la aplicación completa

gfg_docker_compose/ $  docker-compose down

Un docker-compose down exitoso se ve así

Con la herramienta docker-compose, podemos hacer que el proceso de configuración de la aplicación Docker de varios contenedores sea mucho más rápido y sencillo que de la forma habitual.