QuickStart: implementación de una aplicación Docker Compose en Elastic Beanstalk

En este tutorial de QuickStart se detalla el proceso de creación de una aplicación Docker Compose multicontenedor y su implementación en un entorno de AWS Elastic Beanstalk. Creará una aplicación web Flask con un proxy inverso nginx para demostrar cómo Docker Compose simplifica la orquestación de contenedores múltiples.

Cuenta de AWS

Si aún no es cliente de AWS, debe crear una cuenta de AWS. Cuando lo haga, tendrá acceso a Elastic Beanstalk y otros servicios de AWS que necesita.

Si ya tiene una cuenta de AWS, puede pasar a Requisitos previos.

Requisitos previos

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema ($) y del nombre del directorio actual, si es aplicable.

~/eb-project$ this is a command
this is output

En Linux y macOS, puede utilizar el administrador de shell y paquetes preferido. En Windows, puede instalar Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

CLI DE EB

En este tutorial también se utiliza la interfaz de línea de comandos de Elastic Beanstalk (CLI de EB). Para obtener detalles sobre la instalación y configuración de la CLI de EB, consulte Instalación de la CLI de EB con el script de configuración (recomendado) y Configuración de la CLI de EB.

Docker y Docker Compose

Para seguir este tutorial, necesita una instalación local activa de Docker y Docker Compose. Para obtener más información, consulte Obtener Docker e Instalar Docker Compose en el sitio web de documentos de Docker.

Compruebe que Docker y Docker Compose estén instalados y en ejecución; para ello, ejecute los siguientes comandos.

~$ docker info
~$ docker compose version

Paso 1: crear una aplicación Docker Compose

Para este ejemplo, creamos una aplicación multicontenedor con Docker Compose que consta de una aplicación web Flask y un proxy inverso nginx. Esto demuestra cómo Docker Compose simplifica la orquestación de contenedores múltiples que funcionan juntos.

La aplicación incluye una configuración de monitoreo del estado que permite que Elastic Beanstalk recopile métricas detalladas de la aplicación desde su proxy nginx.

La aplicación consta de la siguiente estructura:

~/eb-docker-compose-flask/
|-- docker-compose.yml
|-- web/
|   |-- Dockerfile
|   |-- app.py
|   `-- requirements.txt
|-- proxy/
|   |-- Dockerfile
|   `-- nginx.conf
`-- .platform/
    `-- hooks/
        `-- postdeploy/
            `-- 01_setup_healthd_permissions.sh

Compruebe que la estructura del directorio y añada los siguientes archivos:

En primer lugar, cree el archivo docker-compose.yml principal que defina los servicios y sus relaciones.

services:
  web:
    build: ./web
    expose:
      - "5000"

  nginx-proxy:
    build: ./proxy
    ports:
      - "80:80"
    volumes:
      - "/var/log/nginx:/var/log/nginx"
    depends_on:
      - web

Cree un directorio para la aplicación web Flask en el directorio web. Agergue el siguiente contenido al archivo app.py.

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello Elastic Beanstalk! This is a Docker Compose application'

Agregue el siguiente contenido al Dockerfile de su servicio web.

FROM public.ecr.aws/docker/library/python:3.12
COPY . /app
WORKDIR /app
RUN pip install Flask==3.1.1
EXPOSE 5000
CMD [ "python3", "-m" , "flask", "run", "--host=0.0.0.0"]

Cree el proxy inverso nginx en el directorio proxy. Agergue el siguiente contenido al archivo nginx.conf.

Esta configuración incluye una configuración de monitoreo del estado que permite que Elastic Beanstalk recopile métricas detalladas de la aplicación. Para obtener más información sobre la personalización de los formatos de registro de monitoreo del estado, consulte Formato de los registros de estado avanzados.

events {
    worker_connections 1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    map $http_upgrade $connection_upgrade {
        default       "upgrade";
    }

    # Health monitoring log format for Elastic Beanstalk
    log_format healthd '$msec"$uri"$status"$request_time"$upstream_response_time"$http_x_forwarded_for';
    
    upstream flask_app {
        server web:5000;
    }

    server {
        listen 80 default_server;
        root /usr/share/nginx/html;

        # Standard access log
        access_log /var/log/nginx/access.log;
        
        # Health monitoring log for Elastic Beanstalk
        if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
            set $year $1;
            set $month $2;
            set $day $3;
            set $hour $4;
        }
        access_log /var/log/nginx/healthd/application.log.$year-$month-$day-$hour healthd;
        
        location / {
            proxy_pass http://flask_app;
            proxy_http_version    1.1;

            proxy_set_header    Connection             $connection_upgrade;
            proxy_set_header    Upgrade                $http_upgrade;
            proxy_set_header    Host                   $host;
            proxy_set_header    X-Real-IP              $remote_addr;
            proxy_set_header    X-Forwarded-For        $proxy_add_x_forwarded_for;
        }
    }
}

Añada el siguiente contenido al Dockerfile de servicio proxy.

FROM public.ecr.aws/nginx/nginx:alpine
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80

Por último, cree un script de enlace a la plataforma para configurar los directorios de registro y los permisos necesarios para el monitoreo del estado. Los enlaces a la plataforma le permiten ejecutar scripts personalizados durante el proceso de implementación. Para obtener más información acerca de los enlaces a la plataforma, consulte Enlaces de la plataforma.

#!/bin/bash
set -ex

NGINX_CONTAINER=$(docker ps --filter "name=nginx-proxy" -q)

if [ -z "$NGINX_CONTAINER" ]; then
    echo "Error: No nginx-proxy container found running"
    exit 1
fi

NGINX_UID=$(docker exec ${NGINX_CONTAINER} id -u nginx)
NGINX_GID=$(docker exec ${NGINX_CONTAINER} id -g nginx)

mkdir -p /var/log/nginx/healthd
chown -R ${NGINX_UID}:${NGINX_GID} /var/log/nginx

Paso 2: ejecutar la aplicación a nivel local

Utilice el comando docker compose up para crear y ejecutar la aplicación multicontenedor de forma local. Docker Compose creará las dos imágenes del contenedor e iniciará los servicios definidos en el archivo docker-compose.yml.

~/eb-docker-compose-flask$ docker compose up --build

La opción --build garantiza que Docker Compose cree las imágenes del contenedor antes de iniciar los servicios. Debería ver el resultado que muestra el inicio del servicio web y del servicio nginx-proxy.

En el navegador, vaya a http://localhost. Debería ver el texto “Hola, Elastic Beanstalk. Esta es una aplicación Docker Compose». El proxy nginx recibe su solicitud en el puerto 80 y la reenvía a la aplicación Flask que se ejecuta en el puerto 5000.

Cuando termine de probar, detenga la aplicación pulsando Ctrl+C en el terminal o ejecute el siguiente comando en otro terminal:

~/eb-docker-compose-flask$ docker compose down

Paso 3: implementar la aplicación Docker Compose con la CLI de EB

Ejecute los siguientes comandos para crear un entorno de Elastic Beanstalk en esta aplicación.

Paso 4: probar la aplicación en Elastic Beanstalk

Cuando finalice el proceso de creación del entorno, abra el sitio web con eb open.

~/eb-docker-compose-flask$ eb open

¡Genial! Ha implementado una aplicación Docker Compose multicontenedor con Elastic Beanstalk. Se abre una ventana del navegador con el nombre de dominio creado para su aplicación. Debería ver el mensaje de su aplicación Flask, enviado a través del proxy inverso nginx.

Paso 5: Eliminar

Cuando termine de trabajar con la aplicación, puede terminar el entorno. Elastic Beanstalk cancela todos los recursos de AWS asociados a su entorno.

Utilice el comando siguiente de la CLI de EB para terminar su entorno de Elastic Beanstalk.

~/eb-docker-compose-flask$ eb terminate

Recursos deAWS para su aplicación

Acaba de crear una aplicación de instancia única que ejecuta contendores múltiples. Sirve como una aplicación de muestra sencilla con una sola instancia de EC2, por lo que no requiere equilibrio de carga ni escalado automático. Para aplicaciones de instancia única, Elastic Beanstalk crea los siguientes recursos de AWS:

Elastic Beanstalk administra todos estos recursos. Cuando termina su entorno, Elastic Beanstalk termina todos los recursos que este contiene. La aplicación Docker Compose ejecuta contenedores múltiples en una única instancia de EC2, y Elastic Beanstalk gestiona la orquestación automáticamente.

Pasos a seguir a continuación

Una vez que disponga de un entorno que ejecute una aplicación, podrá implementar una nueva versión de la aplicación o una aplicación distinta en cualquier momento. La implementación de una nueva versión de la aplicación es una tarea muy rápida, ya que no se requiere aprovisionar ni reiniciar instancias EC2. También puede explorar el nuevo entorno con la consola de Elastic Beanstalk. Para ver los pasos detallados, consulte Explore your environment en el capítulo Getting started de esta guía.

Después de que implemente una aplicación de muestra o dos y esté listo para empezar a desarrollar y poner en funcionamiento las aplicaciones Docker Compose de forma local, consulte Preparación de la imagen de Docker para implementarla en Elastic Beanstalk.

Implementar con la consola de Elastic Beanstalk

También puede utilizar la consola de Elastic Beanstalk para lanzar una aplicación Docker Compose. Cree un archivo ZIP que contenga su archivo docker-compose.yml y todos los directorios y archivos asociados y cárguelo cuando cree una nueva aplicación. Para ver los pasos detallados, consulte Create an example application en el capítulo Getting Started de esta guía.