Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # 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. **Non per uso in produzione** Gli esempi sono solo a scopo dimostrativo. Non utilizzare applicazioni di esempio in produzione. **Topics** + [Il tuo AWS account](#docker-compose-quickstart-aws-account) + [Prerequisiti](#docker-compose-quickstart-prereq) + [Passaggio 1: creare un'applicazione Docker Compose](#docker-compose-quickstart-create-app) + [Fase 2: Esegui l'applicazione localmente](#docker-compose-quickstart-run-local) + [Passaggio 3: distribuisci l'applicazione Docker Compose con l'EB CLI](#docker-compose-quickstart-deploy) + [Fase 4: Testa la tua applicazione su Elastic Beanstalk](#docker-compose-quickstart-run-eb-ap) + [Fase 5: rimozione](#docker-compose-quickstart-cleanup) + [AWS risorse per la tua applicazione](#docker-compose-quickstart-eb-resources) + [Fasi successive](#docker-compose-quickstart-next-steps) + [Esegui la distribuzione con la console Elastic Beanstalk](#docker-compose-quickstart-console) ## Il tuo AWS account Se non sei già un 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](#docker-compose-quickstart-prereq) ### Crea un AWS account #### Registrati per un Account AWS Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno. **Per iscriverti a un Account AWS** 1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup) 1. Segui le istruzioni online. Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono. Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks). AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**. #### Crea un utente con accesso amministrativo Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane. **Proteggi i tuoi Utente root dell'account AWS** 1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password. Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *. 1. Abilita l’autenticazione a più fattori (MFA) per l’utente root. Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*. **Crea un utente con accesso amministrativo** 1. Abilita il Centro identità IAM. Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *. 1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente. Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*. **Accesso come utente amministratore** + Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM. Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*. **Assegnazione dell’accesso ad altri utenti** 1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo. Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *. 1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On). Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *. ## 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 (\$1) 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](https://docs.microsoft.com/en-us/windows/wsl/install-win10) 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)](eb-cli3.md#eb-cli3-install) e [Configurazione dell'interfaccia a riga di comando EB](eb-cli3-configuration.md). ### 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](https://docs.docker.com/get-docker/) [Compose sul sito Web della documentazione di Docker](https://docs.docker.com/compose/install/). 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 loro relazioni. **Example `~/eb-docker-compose-flask/docker-compose.yml`** ``` 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. **Example `~/eb-docker-compose-flask/web/app.py`** ``` 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 web`Dockerfile`. **Example `~/eb-docker-compose-flask/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"] ``` 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](health-enhanced-serverlogs.md) **Example `~/eb-docker-compose-flask/proxy/nginx.conf`** ``` 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. **Example `~/eb-docker-compose-flask/proxy/Dockerfile`** ``` 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](platforms-linux-extend.hooks.md) **Example `~/eb-docker-compose-flask/.platform/hooks/postdeploy/01_setup_healthd_permissions.sh`** ``` #!/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 ``` ## Fase 2: Esegui l'applicazione localmente Usa il comando [docker compose up](https://docs.docker.com/compose/reference/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'**--build**opzione 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\$1 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\$1C** 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. **Per creare un ambiente e distribuire l'applicazione Docker Compose** 1. Inizializza il repository della CLI EB con il comando **eb init**. ``` ~/eb-docker-compose-flask$ eb init -p docker docker-compose-tutorial --region us-east-2 Application docker-compose-tutorial has been created. ``` Questo comando crea un'applicazione denominata `docker-compose-tutorial` e configura il repository locale per creare ambienti con l'ultima versione della piattaforma Docker. 1. (Facoltativo) Esegui nuovamente **eb init** per configurare una coppia di chiavi predefinite e connetterti all'istanza EC2 che esegue l'applicazione. ``` ~/eb-docker-compose-flask$ eb init Do you want to set up SSH for your instances? (y/n): y Select a keypair. 1) my-keypair 2) [ Create new KeyPair ] ``` Seleziona una coppia di chiavi se ne hai già una, oppure segui le istruzioni per creare una nuova. Se il prompt non è visualizzato o devi modificare le impostazioni in seguito, esegui **eb init -i**. 1. Crea un ambiente e distribuisci in esso l'applicazione con **eb create**: Elastic Beanstalk `docker-compose.yml` rileva automaticamente il file e distribuisce l'applicazione multi-contenitore. ``` ~/eb-docker-compose-flask$ eb create docker-compose-tutorial ``` Elastic Beanstalk impiega circa cinque minuti per creare l'ambiente e distribuire l'applicazione multi-container. ## 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\$1 Hai distribuito un'applicazione Docker Compose multi-container con Elastic Beanstalk\$1 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 istanza EC2, quindi non richiede il bilanciamento del carico o la scalabilità automatica. Per le applicazioni a istanza singola Elastic Beanstalk crea le seguenti risorse: AWS + **Istanza EC2**: una macchina virtuale di Amazon EC2 configurata per eseguire applicazioni Web sulla piattaforma selezionata. Ogni piattaforma esegue un insieme diverso di software, file di configurazione e script per supportare una versione della lingua, un framework, un container Web specifici o una determinata combinazione di tutti questi elementi. La maggior parte delle piattaforme utilizza Apache o nginx come proxy inverso che elabora il traffico web su cui viene eseguita l'app Web, inoltra le richieste all'app, fornisce asset statici e genera log degli accessi e di errore. + **Gruppo di sicurezza istanze**: un gruppo di sicurezza di Amazon EC2 configurato per abilitare il traffico in entrata sulla porta 80. Questa risorsa consente al traffico TTP proveniente dal load balancer di raggiungere l'istanza EC2 in esecuzione sull'app Web. Per impostazione predefinita, il traffico non è consentito su altre porte. + **Bucket Amazon S3**: posizione di storage per il codice sorgente, i log e altri artefatti creati quando si utilizza Elastic Beanstalk. + ** CloudWatch Allarmi Amazon**: due CloudWatch allarmi che monitorano il carico sulle istanze nel tuo ambiente e vengono attivati se il carico è troppo alto o troppo basso. Quando viene attivato un allarme, il gruppo Auto Scaling aumenta o diminuisce di conseguenza. + **CloudFormation stack**: Elastic CloudFormation Beanstalk utilizza per avviare le risorse nell'ambiente e propagare le modifiche alla configurazione. Le risorse sono definite in un modello, visualizzabile nella [console CloudFormation](https://console.aws.amazon.com/cloudformation). + **Nome di dominio***: un nome di dominio che indirizza alla tua app Web nel modulo. *subdomain* *region*.elasticbeanstalk.com*. 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 istanza EC2, con Elastic Beanstalk che gestisce automaticamente l'orchestrazione. ## Fasi successive 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 veloce 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](GettingStarted.md#GettingStarted.Explore) 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](single-container-docker-configuration.md) ## 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](GettingStarted.md#GettingStarted.CreateApp) nel capitolo Guida *introduttiva* di questa guida.