QuickStart: Implante um aplicativo Docker Compose no Elastic Beanstalk

Este QuickStart tutorial mostra o processo de criação de um aplicativo Docker Compose com vários contêineres e sua implantação em um ambiente. AWS Elastic Beanstalk Você criará uma aplicação Web Flask com um proxy reverso nginx para demonstrar como o Docker Compose simplifica a orquestração de vários contêineres.

Sua AWS conta

Se você ainda não é AWS cliente, precisa criar uma AWS conta. A inscrição permite que você acesse o Elastic Beanstalk AWS e outros serviços de que você precisa.

Se você já tem uma AWS conta, você pode passar paraPré-requisitos.

Pré-requisitos

Para seguir os procedimentos neste manual, você precisa de um terminal de linha de comando ou de um shell para executar os comandos. Nas listagens, os comandos são mostrados precedidos por um símbolo de prompt ($) e pelo nome do diretório atual, quando apropriado.

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

No Linux e no macOS, você pode usar seu gerenciador de pacotes e de shell preferido. No Windows, você pode instalar o subsistema Windows para Linux para obter uma versão do Ubuntu e Bash integrada ao Windows.

EB CLI

Este tutorial também usa a Interface de Linhas de Comando do Elastic Beanstalk (CLI do EB). Para obter detalhes sobre a instalação e configuração da CLI do EB, consulte Instalar a EB CLI com script de configuração (recomendado) e Configurar a EB CLI.

Docker e Docker Compose

Para seguir este tutorial, você precisará de uma instalação local funcional do Docker e do Docker Compose. Para obter mais informações, consulte Obter o Docker e Instalar o Docker Compose no site de documentação do Docker.

Verifique se o Docker e o Docker Compose estão instalados e em execução executando os seguintes comandos.

~$ docker info
~$ docker compose version

Etapa 1: Crie uma aplicação Docker Compose

Neste exemplo, criamos um aplicação de vários contêineres usando o Docker Compose que consiste em um aplicação web Flask e um proxy reverso nginx. Isso demonstra como o Docker Compose simplifica a orquestração de vários contêineres que funcionam juntos.

A aplicação inclui uma configuração de monitoramento de integridade que permite que o Elastic Beanstalk colete métricas detalhadas da aplicação a partir do seu proxy nginx.

A aplicação tem a seguinte estrutura:

~/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

Crie a estrutura de diretórios e adicione os seguintes arquivos:

Primeiro, crie o arquivo principal docker-compose.yml que define os serviços e seus relacionamentos.

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

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

Crie a aplicação web Flask no diretório web. Adicione o seguinte conteúdo ao seu arquivo app.py.

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

Adicione o seguinte conteúdo ao seu serviço Web Dockerfile.

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"]

Crie o proxy reverso nginx no diretório proxy. Adicione o seguinte conteúdo ao seu arquivo nginx.conf.

Essa configuração inclui a configuração de monitoramento da integridade, que permite ao Elastic Beanstalk coletar métricas detalhadas da aplicação. Para obter mais informações sobre como personalizar os formatos dos logs de monitoramento da integridade, consulte Formato de log de integridade aprimorado.

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;
        }
    }
}

Adicione o seguinte conteúdo ao seu serviço proxy Dockerfile.

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

Por fim, crie um script de gancho de plataforma para configurar os diretórios de log e as permissões necessárias para o monitoramento da integridade. Hooks de plataforma permitem que você execute scripts personalizados durante o processo de implantação. Para obter mais informações sobre hooks de plataforma, consulte Hooks de 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

Etapa 2: executar a aplicação localmente

Use o comando docker compose up para criar e executar sua aplicação de vários contêiner localmente. O Docker Compose criará as duas imagens de contêiner e iniciará os serviços definidos no seu arquivo docker-compose.yml.

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

A opção --build garante que o Docker Compose crie as imagens do contêiner antes de iniciar os serviços. Você deve ver a saída mostrando a inicialização do serviço Web e do serviço nginx-proxy.

Navegue até http://localhost no navegador. Você verá o texto "Hello Elastic Beanstalk! Esta é uma aplicação do Docker Compose". O proxy nginx recebe sua solicitação na porta 80 e a encaminha para a aplicação Flask executada na porta 5000.

Quando terminar o teste, interrompa a aplicação pressionando Ctrl+C no terminal ou execute o seguinte comando em um terminal separado:

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

Etapa 3: implantar a aplicação do Docker Composer com a EB CLI

Execute os seguintes comandos para criar um ambiente Elastic Beanstalk para essa aplicação.

Etapa 4: testar a aplicação no Elastic Beanstalk

Quando o processo de criação de seu ambiente for concluído, abra seu site com eb open.

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

Ótimo! Você fez a implantação de uma aplicação do Docker Compose com vários contêineres usando o Elastic Beanstalk! Isso abre uma janela do navegador usando o nome de domínio criado para o seu aplicativo. Você deve ver a mensagem da sua aplicação Flask, servida por meio do proxy reverso nginx.

Etapa 5: limpar

Você pode encerrar o ambiente quando terminar de trabalhar com a aplicação. O Elastic Beanstalk AWS encerra todos os recursos associados ao seu ambiente.

Para encerrar seu ambiente do Elastic Beanstalk com a CLI do EB, execute o seguinte comando.

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

AWS recursos para seu aplicativo

Você acabou de criar uma aplicação de instância única executando vários contêineres. Ele serve como um aplicativo de amostra simples com uma única EC2 instância, portanto, não requer balanceamento de carga ou escalonamento automático. Para aplicativos de instância única, o Elastic Beanstalk cria os seguintes recursos: AWS

O Elastic Beanstalk gerencia todos esses recursos. Quando você encerra o ambiente, o Elastic Beanstalk encerra todos os recursos dele. Seu aplicativo Docker Compose executa vários contêineres em uma única EC2 instância, com o Elastic Beanstalk gerenciando a orquestração automaticamente.

Próximas etapas

Depois que um ambiente estiver executando um aplicativo, você poderá implantar uma nova versão do aplicativo ou um aplicativo diferente a qualquer momento. A implantação de uma nova versão do aplicativo é muito rápida porque não exige provisionamento ou reinicialização de instâncias. EC2 Também é possível explorar o novo ambiente usando o console do Elastic Beanstalk. Para conhecer as etapas detalhadas, consulte Explore seu ambiente, no capítulo Primeiros passos deste guia.

Depois de implantar uma ou duas aplicações demonstrativas, quando você estiver pronto para começar a desenvolver e executar aplicações Docker Compose localmente, consulte Preparar a imagem do Docker para implantação no Elastic Beanstalk.

Implantar com o console do Elastic Beanstalk

Você também pode usar o console Elastic Beanstalk para iniciar uma aplicação do Docker Compose. Crie um arquivo ZIP contendo seu arquivo docker-compose.yml e todos os diretórios e arquivos associados e, em seguida, carregue-o ao criar uma nova aplicação. Para conhecer as etapas detalhadas, consulte Criar uma aplicação de exemplo, no capítulo Primeiros passos deste guia.