Buongiorno a tutti e benvenuti in un nuovo articolo di tooldech oggi parleremo di AWS ECS!
Sei pronto a portare la tua applicazione Python online in modo scalabile e sicuro? In questo articolo ti guiderò passo dopo passo nel deployment di una web app Python su AWS ECS (Elastic Container Service), con l’aggiunta di un Load Balancer per distribuire il traffico. Anche se sei alle prime armi con AWS, questa guida è pensata proprio per te.
Cos’è AWS ECS e perché usarlo
Amazon ECS è un servizio gestito che ti permette di eseguire container Docker in cloud senza dover gestire server manualmente. ECS supporta due modalità:
- EC2 launch type: usi istanze EC2 gestite da te.
- Fargate launch type: serverless, non gestisci l’infrastruttura.
In questa guida useremo Fargate, perfetto per chi vuole iniziare in modo semplice.
Perché aggiungere un Load Balancer?
Un Load Balancer distribuisce il traffico tra più istanze della tua app, migliora la disponibilità e consente l’auto scaling.
Prerequisiti
Prima di iniziare, assicurati di avere:
- Un account AWS
- AWS CLI installata
- Docker installato
- Una semplice app Python Flask (la useremo come esempio)
1. Creare una semplice app Flask
Andremo a creare una directory per la tua app e aggiungi i file:
app.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return "Hello from ECS!"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=80)
requirements.txt
flask
Il risultato che dovrete avere più o meno è questo.
2. Creare un’immagine Docker
Dockerfile
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY app.py .
CMD ["python", "app.py"]
Costruiamo e testiamo l’immagine:
docker build -t flask-ecs-demo .
docker run -p 9010:80 flask-ecs-demo
Visita http://localhost:9010 e verifica che funzioni sulla tua macchina.
3. Pubblicare l’immagine su Amazon ECR
Una volta creato in locale la nostra immagine dobbiamo predisporre il repository dell’immagine container su aws.
Prima di partire con la creazione, ricordiamoci di aver configurato il nostro account aws sulla macchina.
a. Creare un repository ECR:
Prima di passare alla creazione del repository, controlliamo di avere l’immagine docker installata, tramite il comando
docker images
Ora possiamo creare il repository
aws ecr create-repository --repository-name flask-ecs-demo
b. Login a ECR:
Questo punto serve per fare login nel registry privato di Amazon ECR, non su Docker Hub.
Spiegazione dei parametri
aws ecr get-login-password: genera una password temporanea per autenticarti ad Amazon ECR.docker login: è il comando Docker per fare login a un registry.--username AWS: deve essere letteralmenteAWS, come da specifica ECR (non mettere il tuo nome utente AWS).--password-stdin: passa la password generata dal comando precedente.<ACCOUNT_ID>: è il tuo ID account AWS a 12 cifre (es.123456789012).<REGION>: la regione AWS dove hai creato il repository, es.eu-west-1,us-east-1, ecc.
N.B per fare tutto questo dobbiamo aver effettuato la aws configure!
per recuperare il vostro <ACCOUNT_ID> potete usare da terminale il seguente comando per recuperare le informazioni
aws sts get-caller-identity 
aws ecr get-login-password | docker login --username AWS --password-stdin <ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com
N.B. queste sono credenziali temporanee fate tutto entro 12 ore se no vi manderà questo errore
c. Taggare e pushare l’immagine:
Dopo aver fatto login nel tuo registry Amazon ECR.
Dobbiamo :
- Dire a Docker dove inviare l’immagine (cioè a ECR)
- Usare un nome completo (chiamato tag) per inviarla
- Effettuare il push dell’immagine nel registry ECR
Io per questo test sto usando powershell di windows.
Una volta sostituito le parti con le credenziali vostre, potete partire a lanciare i comandi da terminale uno alla volta.
docker tag flask-ecs-demo:latest <ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com/flask-ecs-demo
docker push <ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com/flask-ecs-demo
Una volta fatto volendo possiamo andare a controllare sulla console per vedere se è stato caricato correttamente.
4. Creare un cluster ECS Fargate con Load Balancer
In questo punto andremo a costruire il cluster ECS da deployare su aws.
Puoi usare la console AWS oppure AWS Copilot per facilitare il processo, noi oggi andremo a provare il metodo guidato con AWS copilot.
Metodo con AWS Copilot :
Il metodo per installare AWS Copilot corretto è il seguente andare sul link di GItHub e sacricare la versione per il sistema operativo che si sta usando.
a. Installa Copilot per Windows da GitHub:
https://github.com/aws/copilot-cli/releases
b. Aggiungere al PATH di sistema il .exe:
Una volta installato aggiungeremo alla cartella al PATH di sistema
quello che dovrete sarà il percorso del file .exe nella cartella che vorrete usare come cartella di sistema.
c. Eseguire copilot:
In questo punto siamo pronti ad eseguire copilot, con il comando:
copilot-windows.exe initN.B. potete anche rinominare il file .exe
Quando farete partire copilot vi chiederà dei valori da impostare segui le istruzioni:
- App name:
ecs-demo - Service type:
Load Balanced Web Service - Service name:
flaskweb - Dockerfile path:
./Dockerfile - Port: invio default 80
Arrivato a questo punto chiederà se si vorrà deployare l’ambiente.
Dovrete digitare “y” così Copilot inizierà a creare l’ambiente su AWS (es. test o prod) e a deployare il tuo servizio su ECS con Load Balancer.
💡 Dopo y, Copilot ti chiederà:
- Nome dell’ambiente → puoi scrivere
test - Regione AWS → es.
eu-west-1(quella che stai usando)
Copilot creerà:
- Un cluster ECS
- Un Application Load Balancer (ALB)
- Un servizio gestito in Fargate
- Creazione del VPC + subnet + Load Balancer
- Deploy della tua app su Fargate
- Configurazione del DNS (con URL pubblico)
Se tutto è andato per il verso giusto, vi dovrà fornire un link cliccabile da terminla e oppure basta recarsi sulla console di AWS, con la vostra applicazione containerizzata su ecs.
5. Verifica il funzionamento
Dopo qualche minuto, Copilot ti mostrerà un URL pubblico tipo:
http://<random>.eu-west-1.elb.amazonaws.com
Visita il link: dovresti vedere il messaggio “Hello from ECS!”
Conclusione
Siamo arrivati alla fine di questo articolo di tooldech, oggi hai appena imparato a containerizzare un’app Python, pubblicarla su AWS ECR, deployarla su ECS con Fargate, e esporla tramite Load Balancer. Un’architettura moderna, scalabile e serverless.
Ti ringrazio di essere arrivato fino a questo punto della lettura, ti auguro una buona lettura con altri articoli di tooldech, alla prossima!
Seguici sui social!
Italian 
English