QuickStart: distribuisci un'applicazione Docker Compose su Elastic Beanstalk

Questo QuickStart tutorial illustra il processo di creazione di un'applicazione Docker Compose multi-container e la sua distribuzione in un ambiente. AWS Elastic Beanstalk Creerai un'applicazione web Flask con un reverse proxy nginx per dimostrare come Docker Compose semplifica l'orchestrazione di più contenitori.

Il tuo AWS account

Se non sei già AWS cliente, devi creare un AWS account. La registrazione ti consente di accedere a Elastic Beanstalk AWS e ad altri servizi di cui hai bisogno.

Se hai già un AWS account, puoi passare a. Prerequisiti

Prerequisiti

Per seguire le procedure in questa guida, devi usare un terminale a riga di comando o una shell per eseguire i comandi. I comandi vengono visualizzati in elenchi preceduti da un simbolo di prompt ($) e dal nome della directory corrente, se appropriato.

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

Su Linux e macOS usa la tua shell e il tuo programma di gestione dei pacchetti preferiti. Su Windows puoi installare il sottosistema Windows per Linux per ottenere una versione integrata per Windows di Ubuntu e Bash.

CLI EB

Questo tutorial utilizza l'interfaccia a riga di comando di Elastic Beanstalk (CLI EB). Per istruzioni dettagliate su come configurare e utilizzare la CLI EB, consulta Installa EB CLI con lo script di configurazione (consigliato) e Configurazione dell'interfaccia a riga di comando EB.

Docker e Docker Compose

Per seguire questo tutorial, avrai bisogno di un'installazione locale funzionante di Docker e Docker Compose. Per ulteriori informazioni, consulta Scarica Docker e installa Docker Compose sul sito Web della documentazione di Docker.

Verifica che Docker e Docker Compose siano installati e in esecuzione eseguendo i seguenti comandi.

~$ docker info
~$ docker compose version

Passaggio 1: creare un'applicazione Docker Compose

Per questo esempio, creiamo un'applicazione multi-contenitore utilizzando Docker Compose che consiste in un'applicazione web Flask e un reverse proxy nginx. Ciò dimostra come Docker Compose semplifica l'orchestrazione di più contenitori che funzionano insieme.

L'applicazione include una configurazione di monitoraggio dello stato che consente a Elastic Beanstalk di raccogliere metriche dettagliate dell'applicazione dal proxy nginx.

L'applicazione è costituita dalla seguente struttura:

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

Create la struttura delle cartelle e aggiungete i seguenti file:

Innanzitutto, create il docker-compose.yml file principale che definisce i servizi e le relative relazioni.

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

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

Crea l'applicazione web Flask nella web directory. Aggiungi i seguenti contenuti al tuo app.py file.

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

Aggiungi i seguenti contenuti al tuo servizio webDockerfile.

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

Crea il reverse proxy nginx nella directory. proxy Aggiungi i seguenti contenuti al tuo nginx.conf file.

Questa configurazione include la configurazione del monitoraggio dello stato che consente a Elastic Beanstalk di raccogliere metriche dettagliate delle applicazioni. Per ulteriori informazioni sulla personalizzazione dei formati dei log di monitoraggio dello stato di salute, consulta. Formato dei log dello stato migliorato

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

Aggiungi i seguenti contenuti al tuo servizio Dockerfile proxy.

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

Infine, crea uno script hook per la piattaforma per configurare le directory di registro e le autorizzazioni necessarie per il monitoraggio dello stato di salute. Gli hook della piattaforma consentono di eseguire script personalizzati durante il processo di distribuzione. Per ulteriori informazioni sui platform hook, consulta. Hook della piattaforma

#!/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

Passaggio 2: Esegui l'applicazione localmente

Usa il comando docker compose up per creare ed eseguire la tua applicazione multi-contenitore localmente. Docker Compose creerà entrambe le immagini dei contenitori e avvierà i servizi definiti nel file. docker-compose.yml

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

L'--buildopzione garantisce che Docker Compose crei le immagini del contenitore prima di avviare i servizi. Dovresti vedere un output che mostra sia il servizio web che il servizio nginx-proxy in fase di avvio.

Vai a http://localhost nel tuo browser. Dovresti vedere il testo «Hello Elastic Beanstalk! Questa è un'applicazione Docker Compose». Il proxy nginx riceve la tua richiesta sulla porta 80 e la inoltra all'applicazione Flask in esecuzione sulla porta 5000.

Al termine del test, interrompi l'applicazione premendo Ctrl+C nel terminale o esegui il seguente comando in un terminale separato:

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

Passaggio 3: distribuisci l'applicazione Docker Compose con l'EB CLI

Esegui i seguenti comandi per creare un ambiente Elastic Beanstalk per questa applicazione.

Fase 4: Testa la tua applicazione su Elastic Beanstalk

Una volta completato il processo di creazione dell'ambiente, apri il sito Web con. eb open

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

Ottimo! Hai distribuito un'applicazione Docker Compose multi-container con Elastic Beanstalk! Si aprirà una finestra del browser che utilizza il nome di dominio creato per l'applicazione. Dovresti vedere il messaggio dalla tua applicazione Flask, servito tramite il reverse proxy nginx.

Fase 5: rimozione

È possibile chiudere l'ambiente quando si finisce di lavorare con l'applicazione. Elastic Beanstalk AWS interrompe tutte le risorse associate all'ambiente.

Per terminare l'ambiente Elastic Beanstalk con l'EB CLI, esegui il comando seguente.

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

AWS risorse per la tua applicazione

Hai appena creato un'applicazione a istanza singola che esegue più contenitori. Funge da semplice applicazione di esempio con una singola EC2 istanza, quindi non richiede il bilanciamento del carico o la scalabilità automatica. Per le applicazioni a istanza singola Elastic Beanstalk crea le seguenti risorse: AWS

Elastic Beanstalk gestisce tutte queste risorse. Quando arresti l'ambiente, Elastic Beanstalk termina tutte le risorse che contiene. L'applicazione Docker Compose esegue più contenitori sulla singola EC2 istanza, con Elastic Beanstalk che gestisce automaticamente l'orchestrazione.

Passaggi successivi

Quando disponi di un'applicazione in esecuzione in un ambiente, puoi distribuire una nuova versione dell'applicazione o un'applicazione diversa in qualsiasi momento. La distribuzione di una nuova versione dell'applicazione è molto rapida perché non richiede il provisioning o il riavvio delle istanze. EC2 Puoi anche esplorare il tuo nuovo ambiente utilizzando la console Elastic Beanstalk. Per i passaggi dettagliati, consulta Esplora il tuo ambiente nel capitolo Guida introduttiva di questa guida.

Dopo aver distribuito una o due applicazioni di esempio e essere pronti per iniziare a sviluppare ed eseguire applicazioni Docker Compose localmente, vedi. Preparazione dell'immagine Docker per la distribuzione su Elastic Beanstalk

Esegui la distribuzione con la console Elastic Beanstalk

Puoi anche utilizzare la console Elastic Beanstalk per avviare un'applicazione Docker Compose. Crea un file ZIP contenente il tuo docker-compose.yml file e tutte le directory e i file associati, quindi caricalo quando crei una nuova applicazione. Per la procedura dettagliata, consulta Creare un'applicazione di esempio nel capitolo Guida introduttiva di questa guida.