In questo modulo, suddividerai l’applicazione node.js in numerosi servizi interconnessi e invierai l’immagine di ciascun servizio in un repository Amazon Elastic Container Registry (Amazon ECR). Inizia a creare

L'architettura dell'applicazione finale usa Amazon Elastic Container Service (Amazon ECS) e Application Load Balancer (ALB). 

Panoramica dell'architettura

a. Client
Il client invia richieste relative al traffico attraverso la porta 80.

b. Sistema di bilanciamento del carico
L’ALB instrada il traffico esterno al servizio adatto. L’ALB verifica la richiesta del client e usa le regole di instradamento per dirigere la richiesta a un’istanza e una porta relative al gruppo di destinazione corrispondente alla regola.

c. Gruppi di destinazione
Ciascun servizio ha un gruppo di destinazione che tiene traccia delle istanze e porte di ciascun container in esecuzione per tale servizio.

d. Microservizi
Amazon ECS distribuisce ciascun servizio in un container attraverso un cluster EC2. Ciascun container gestisce solo una singola funzione.

Isolamento di arresti
Anche le migliori aziende tecniche possono essere soggette, e lo sono, ad arresti fatali della produzione. Oltre a seguire tutte le best practice standard per la gestione efficace degli arresti, un approccio che può limitare l’impatto di tali arresti è la creazione di microservizi. Una buona architettura di microservizi fa sì che se una microparte del servizio si arresta, il problema non si propaga, per cui tutte le altre parti del servizio continuano a funzionare correttamente.

Isolamento finalizzato alla sicurezza
In un’applicazione monolitica, se per una delle sue funzioni si verifica una violazione della sicurezza, ad esempio una vulnerabilità che consente l’esecuzione di codice in remoto, devi presupporre che un utente malintenzionato potrebbe aver ottenuto accesso anche a ogni altra funzione del sistema. Ciò può essere pericoloso se, ad esempio, la funzione di upload del tuo avatar ha un problema di sicurezza che alla fine compromette il tuo database per quanto riguarda le password degli utenti. Separare funzioni in microservizi impiegando Amazon ECS consente di assicurare l’accesso a risorse AWS conferendo a ciascun servizio un suo proprio ruolo AWS Identity and Access Management (IAM). Quando si seguono le best practice relative ai microservizi, se un utente malintenzionato compromette un servizio, può ottenere accesso solo alle risorse di tale servizio e non può accedere in orizzontale ad altre risorse da altri servizi senza violare la sicurezza di questi ultimi.

Scalabilità indipendente
Quando le funzionalità sono suddivide in microservizi, è possibile dimensionare indipendentemente la quantità di infrastruttura e il numero di istanze utilizzate da ciascuna classe di microservizi. Risulta così più facile misurare il costo di una particolare funzione e identificare quelle che potrebbe essere necessario ottimizzare per prime. Se una particolare funzione ha problemi con le esigenze delle proprie risorse, non vi sarà alcun impatto su altre funzioni e sarà possibile continuare a ottenere prestazioni affidabili.

Velocità di sviluppo
I microservizi riducono i rischi dello sviluppo, consentendo quindi a un team di operare più velocemente. In un monolite, aggiungere una nuova funzione può influire su ogni altra funzione del monolite stesso. Gli sviluppatori devono valutare con attenzione l’impatto di qualsiasi codice che aggiungono e accertarsi che non introducano alcun problema. Dall’altro canto, un’architettura di microservizi appropriata ha un nuovo codice per una nuova funzione che si introduca per un nuovo servizio. Gli sviluppatori possono contare sul fatto che qualunque codice scrivano non sarà in grado di influire sul codice esistente a meno che non scrivano esplicitamente una connessione fra due microservizi.

Tempo richiesto per il completamento: 20 minuti

Servizi utilizzati:


Segui le istruzioni dettagliate riportate di seguito per suddividere il monolite. Fai clic sul numero di ciascuna fase per espandere la sezione.

break-the-monolith
  • Fase 1. Esecuzione del provisioning dei repository ECR

    Nei due moduli precedenti, hai distribuito la tua applicazione come un monolite impiegando un singolo servizio e un singolo repository dell’immagine del container. Per distribuire l’applicazione come tre microservizi, dovrai eseguire il provisioning di tre repository (uno per ciascun servizio) in Amazon ECR.

    I nostri tre servizi sono:

    1. utenti
    2. thread
    3. post

    Crea i tre repository ripetendo i seguenti passaggi per ciascun servizio:

    • Vai alla console Amazon ECR.
    • Seleziona Crea repository.
    • Nella pagina Crea repository, nel campo Nome repository, crea un repository per il servizio (post, thread o utenti).
      ⚐ Nota: per le opzioni Immutabilità tag, non modificare le impostazioni predefinite.

    Ora dovresti avere quattro repository in Amazon ECR. Registra le informazioni del repository per ciascun microservizio creato. Queste informazioni saranno necessarie in una fase successiva. Le informazioni necessarie sono nel seguente formato:
    [account-id].dkr.ecr.[region].amazonaws.com/[service-name]

    repository
  • Fase 2. Autenticazione di Docker con AWS (facoltativo)

    Avrai bisogno di accedere a Docker per creare e inviare le immagini per ciascun servizio. Se stai seguendo questo tutorial facendo pause, potresti essere stato scollegato da Docker. In tal caso, procedi come segue per riaccedere a Docker.

    • Esegui  $(aws ecr get-login --no-include-email --region [your-region])
      Sostituisci [your-region], per esempio: $(aws ecr get-login --no-include-email --region us-west-2)

    Se l’autenticazione è riuscita, riceverai il messaggio di conferma: Login riuscito.

  • Fase 3. Creazione e invio delle immagini per ciascun servizio

    Nella cartella del progetto amazon-ecs-nodejs-microservices/3-microservices/services, troverai le cartelle con i file per ciascun servizio. Nota che ogni microservizio è sostanzialmente un clone del servizio monolitico precedente.

    È possibile vedere in che modo ciascun servizio è ora specializzato confrontando il file db.json in ciascun servizio e nel servizio api monolitico. In passato post, thread e utenti venivano memorizzati in un singolo file di database. Ora ognuno viene memorizzato nel file di database del suo servizio corrispondente.

    Apri il terminale e imposta il percorso per la sezione ~/amazon-ecs-nodejs-microservices/3-microservices/services

    Crea e inserisci il tag in ogni immagine

    • Nel terminale, esegui docker build -t [service-name] ./[service-name]
      Sostituisci il nome del servizio, [service-name], per esempio: docker build -t posts ./posts

    • Terminata la creazione, inserisci il tag nell’immagine in modo che sia possibile inviarla al repository:
      docker tag [service-name]:latest [account-ID].dkr.ecr.[region].amazonaws.com/[service-name]:v1
      Sostituisci [service-name], [account-ID] e [region], per esempio: docker tag posts:latest [account-id].dkr.ecr.us-west-2.amazonaws.com/posts:v1

    • Esegui docker push per inviare la tua immagine a ECR: docker push [account-id].dkr.ecr.[region].amazonaws.com/[service-name]:v1
      Sostituisci [service-name], [account-ID] e [region].

    Se passi al repository ECR, dovresti vedere le tue immagini con il tag v1. 

    ♻ Ripeti questi passaggi per ciascuno dei tre microservizi.  

    ⚐ NOTA: assicurati di creare tutte e tre le immagini e applicarvi il tag.