Suddivisione di un'applicazione monolitica in microservizi

con Amazon Elastic Container Service, Docker e Amazon EC2

Containerizzazione del monolite

Modulo 2 – Distribuzione del monolito

In questo modulo, utilizzerai Amazon Elastic Container Service (Amazon ECS) per avviare un cluster gestito di istanze di calcolo EC2 e distribuire l'immagine come un container in esecuzione sul cluster. Inizia a creare

Panoramica dell'architettura

a. Client
Il client esegue una richiesta sulla porta 80 al sistema di bilanciamento del carico.

b. Sistema di bilanciamento del carico
Il sistema di bilanciamento del carico distribuisce richieste a tutte le porte disponibili.

c. Gruppi di destinazione
Le istanze vengono registrate nel gruppo di destinazione dell’applicazione.

d. Porte container
Ogni container esegue un unico processo applicativo che vincola il cluster node.js principale alla porta 80 all’interno del proprio namespace.

e. Monolito node.js nel container
Il cluster node.js principale è responsabile della distribuzione del traffico ai lavoratori nell’ambito dell’applicazione monolitica. Questa architettura è nel container ma è comunque monolitica perché ciascun container ha le stesse caratteristiche del resto dei container.

Cos'è Amazon Elastic Container Service?

Amazon Elastic Container Service (ECS) è un servizio di gestione di container altamente scalabile ad elevate prestazioni che supporta i container Docker e consente di eseguire applicazioni su un cluster gestito di istanze Amazon EC2 in modo semplice. Bastano semplici chiamate API per avviare e interrompere applicazioni compatibili con Docker, eseguire query sullo stato del cluster e accedere a molte funzioni comuni come i gruppi di sicurezza, Elastic Load Balancing, i volumi EBS e i ruoli IAM.

Puoi usare Amazon ECS per pianificare il posizionamento dei contenitori nel cluster in base alle esigenze di risorse e ai requisiti di disponibilità. Puoi anche integrare il sistema di pianificazione interno o di terze parti in uso per soddisfare specifici requisiti aziendali o applicativi.

Non sono previsti costi aggiuntivi per l'utilizzo di Amazon ECS. I prezzi sono calcolati in base alle risorse AWS (ad esempio istanze EC2 o volumi EBS) che vengono create per memorizzare e gestire l'applicazione.

Tempo richiesto per il completamento: 30 minuti

Servizi utilizzati:

Istruzioni per l'implementazione

Segui i passaggi indicati nelle istruzioni seguenti per distribuire l’applicazione node.js utilizzando Amazon ECS. Fai clic sul numero di ciascuna fase per espandere la sezione.

Fase 1. Avvia un ECS Cluster con AWS CloudFormation
Crea un cluster Amazon ECS distribuito dietro a un Application Load Balancer.
1. Vai alla console AWS CloudFormation.
2. Seleziona Create stack (Crea stack).
3. Seleziona Upload a template file (Carica file di esempio) e scegli il file ecs.yml dal progetto GitHub in amazon-ecs-nodejs-microservice/2-containerized/infrastructure/ecs.yml quindi seleziona Next (Successivo).
4. Per il nome dello stack, inserisci BreakTheMonolith-Demo. Verifica che gli altri parametri abbiano i seguenti valori:
  
  Capacità desiderata = 2
  
  Tipo di istanza = t2.micro
  
  Dimensioni max = 2
5. Seleziona Next (Successivo).
6. Nella pagina Configure stack options (Configura opzioni stack), mantieni le opzioni predefinite, quindi scorri e seleziona Next (Successivo).
7. Nella pagina Review BreakTheMonolith-Demo (Rivedi BreakTheMonolith-Demo), scorri fino in fondo, conferma la dichiarazione Capabilities (Capacità) selezionando la casella di controllo e seleziona Create stack (Crea stack).
Lo stack viene visualizzato con lo stato CREATE_IN_PROGRESS. Per verificare lo stato di avanzamento, seleziona il pulsante di aggiornamento in alto a destra della schermata. Questo processo richiede in genere meno di 5 minuti.
⚐ NOTA: facoltativamente, puoi utilizzare l’interfaccia a riga di comando di AWS (AWS CLI) per distribuire gli stack AWS CloudFormation. Esegui il codice seguente nel terminare dalla cartella amazon-ecs-nodejs-microservices/3-microservices e sostituisci [region] con la tua regione AWS.
```
$ aws cloudformation deploy \
   --template-file infrastructure/ecs.yml \
   --region [region] \
   --stack-name BreakTheMonolith-Demo \
   --capabilities CAPABILITY_NAMED_IAM
```
Fase 2. Verifica che il cluster sia in esecuzione
- Vai alla console Amazon ECS.
  Il cluster deve essere visualizzato nell’elenco.
- Seleziona il cluster BreakTheMonolith-Demo, quindi seleziona la scheda Tasks (Attività) per verificare che non vi siano attività in esecuzione.
- Seleziona la scheda ECS Instances (Istanze ECS) per verificare che siano presenti le due istanze Amazon EC2 create dal modello AWS CloudFormation.
  ⚐ Nota: se ricevi un messaggio che segnala che l’agente ECS è obsoleto, seleziona Learn more (Ulteriori informazioni) per istruzioni su come aggiornarlo.
Fase 3. Creare una definizione di attività
Le definizioni di attività specificano in che modo Amazon ECS distribuisce i container delle applicazioni nel cluster.
- Nel menu di navigazione a sinistra Amazon ECS, seleziona Task Definitions (Definizioni attività).
- Seleziona Create new Task Definition (Crea nuova definizione attività).
- Nella pagina Select launch type compatibility (Seleziona compatibilità con il tipo di lancio), seleziona l'opzione EC2 e poi seleziona Next step (Fase successiva).
- Nella pagina Configure task and container definitions (Configura le definizioni di attività e container), esegui le operazioni seguenti:
  
  Nel campo Task Definition Name (Nome definizione attività), inserisci api.
  
  Scorri verso il basso fino a Container Definitions (Definizioni container) e seleziona Add container (Aggiungi container).
  
  Nella finestra Add container (Aggiungi container):
  
  I parametri che non sono stati definiti possono essere lasciati vuoti o con le impostazioni predefinite.
  
  Nel campo Container name (Nome container), inserisci api.
  
  Nel campo Image (Immagine), inserisci [account-ID].dkr.ecr.[region].amazonaws.com/api:v1
  Sostituisci [account-ID] e [region] con le tue informazioni specifiche. Assicurati che il tag v1 corrisponda al valore che hai utilizzato nel Modulo 1 per applicare i tag ed eseguire il push dell’immagine. Questo è l’URL dell’immagine del repository ECR che è stata creata nel modulo precedente.
  
  Nel campo Memory Limits (Limiti di memoria), verifica che sia selezionato Hard limit (Limite rigido) e inserisci come valore 256.
  
  In Port mappings (Collegamenti porta), porta host = 0 e porta container = 3000.
  
  Scorri fino a ENVIRONMENT, unità CPU = 256.
- Seleziona Add (Aggiungi).
  Torni alla pagina Configure task and container definitions (Configura le definizioni di attività e container).
- Scorri fino in fondo alla pagina e seleziona Create (Crea).
La tua definizione dell’attività è elencata nella console.
Fase 4. Configurazione di Application Load Balancer: gruppo di destinazione
Application Load Balancer (ALB) consente al tuo servizio di accettare il traffico in ingresso. L’ALB instrada automaticamente il traffico alle istanze di container in esecuzione sul tuo cluster utilizzandole come un gruppo di destinazione.

Controlla il nome del VPC: se non è la prima volta che usi questo account AWS, potresti avere più VPC. È importante configurare il gruppo di destinazione con il VPC corretto.

Vai alla sezione Load Balancer della console EC2.

Individua il sistema di bilanciamento del carico denominato demo.

Seleziona la casella di controllo demo per visualizzare i dettagli del sistema di bilanciamento del carico.

Nella scheda Descrizione, individua l'attributo VPC (in questo formato: vpc-xxxxxxxxxxxxxxxxx).
⚐ Nota: avrai bisogno dell'attributo VPC nella fase successiva al momento di configurare i gruppi di destinazione ALB.
Configura il gruppo di destinazione ALB

Vai alla sezione Target Groups (Gruppi di destinazione) della console EC2.

Seleziona Create target group (Crea gruppo di destinazione).

Configura i seguenti parametri del gruppo di destinazione (per i parametri non elencati di seguito, mantieni i valori predefiniti):

Per Target group name (Nome del gruppo di destinazione), inserisci api.

Per Protocol (Protocollo), seleziona HTTP.

Per Port (Porta), inserisci 80.

Per il VPC, seleziona il valore che corrisponde a quello della descrizione del sistema di bilanciamento del carico. This is most likely NOT your default VPC (Molto probabilmente questo NON è il tuo VPC predefinito).

Accedi a Advanced health check settings (Impostazioni avanzate di verifica di integrità) e modifica i seguenti parametri secondo esigenza:

Per Healthy threshold (Soglia di integrità), inserisci 2.

Per Unhealthy threshold (Soglia di non integrità), inserisci 2.

Per Timeout, inserisci 5.

Per Interval (Intervallo), inserisci 6.

Seleziona Create (Crea).
Fase 5. Configura l'Application Load Balancer: Listener
Il listener ALB controlla le richieste di connessione in ingresso all’ALB.

Add a Listener to the ALB (Aggiungi un Listener all’ALB)
- Vai alla sezione Load Balancer della console EC2.
- Seleziona la casella di controllo demo per visualizzare i dettagli del sistema di bilanciamento del carico.
- Seleziona la scheda Listener.
- Seleziona Add listener (Aggiungi Listener) e modifica i seguenti parametri secondo esigenza:
  
  Per Protocol:port (Porta protocollo), seleziona HTTP e inserisci 80.
  
  Per Default action(s) (Azioni predefinite), seleziona Forward to (Inoltra a) e nel campo Target group (Gruppo di destinazione), insersci api.
- Seleziona Save (Salva).
Fase 6. Distribuzione del monolite come servizio
Distribuisci il monolite come servizio nel cluster.
- Vai alla console Amazon ECS e seleziona Clusters dalla barra del menu a sinistra.
- Seleziona il cluster BreakTheMonolith-Demo, seleziona la scheda Services (Servizi) e poi seleziona Create (Crea).
- Nella pagina Configure service (Configura servizio), modifica i seguenti parametri (mantenendo i valori predefiniti per i parametri non riportati di seguito):
  
  Per Launch type (Tipo di lancio), seleziona EC2.
  
  Per Service name (Nome servizio), inserisci api.
  
  Per Number of tasks (Numero di attività), inserisci 1.
  
  Seleziona Next step (Fase successiva).
- Nella pagina Configure network (Configura rete), sezione Load balancing (Bilanciamento del carico), seleziona Application Load Balancer.
  Vengono visualizzati altri parametri: Service IAM role (Ruolo IAM servizio) e Load balancer name (Nome sistema di bilanciamento del carico).
  
  Per Service IAM role (Ruolo IAM servizio), seleziona BreakTheMonolith-Demo-ECSServiceRole.
  
  Per Nome sistema di bilanciamento del carico, verifica che sia selezionato demo.
- Nella sezione Container to load balance (Container di cui eseguire il bilanciamento del carico), seleziona Add to load balancer (Aggiungi a sistema di bilanciamento del carico).
  Vengono visualizzate informazioni aggiuntive etichettate api:3000.
- Nella sezione api:3000, esegui le seguenti operazioni:
  
  Per Production listener port (Porta listener di produzione), seleziona 80:HTTP.
  
  Per il Target group name (Nome del gruppo di destinazione), seleziona il tuo gruppo: api.
  
  Seleziona Next step (Fase successiva).
- Nella pagina Set Auto Scaling (Imposta Auto Scaling), lascia l’impostazione predefinita e seleziona Next step (Fase successiva).
- Nella pagina Review (Esamina), esamina le impostazioni e seleziona quindi Create Service (Crea servizio).
- Una volta creato il servizio, seleziona View Service (Visualizza servizio).
Ottimo lavoro! Il tuo servizio è ora in esecuzione. La registrazione dell’integrità del container e la ricezione del traffico richiederà un minuto.
Fase 7. Test del monolito
Convalida la distribuzione verificando che il servizio sia disponibile da internet ed eseguendo il ping.

Per trovare l’URL del servizio:
- Vai alla sezione Load Balancer della console EC2.
- Seleziona il sistema di bilanciamento del carico demo.
- Nella scheda Description (Descrizione), copia il nome DNS e incollalo in una nuova scheda o finestra del browser.
- Dovrebbe essere visualizzato il messaggio Ready to receive requests (Pronto per ricevere richieste).
Verifica tutte le parti del servizio: l’applicazione node.js instrada il traffico a ciascun lavoratore in base all’URL. Per vedere un lavoratore, basta aggiungere il relativo nome api/[worker-name] alla fine del nome DNS come segue:
- http://[DNS name]/api/users
- http://[DNS name]/api/threads
- http://[DNS name]/api/posts
Puoi anche aggiungere un numero di record alla fine dell’URL per scendere al livello di dettaglio di un record specifico. Ad esempio: http://[DNS name]/api/posts/1 o http://[DNS name]/api/users/2