In questo modulo, distribuirai l'applicazione node.js come un set di servizi interconnessi dietro a un Application Load Balancer (ALB). Poi utilizzerai ALB per spostare in modo ottimale il traffico dal monolite ai microservizi. Inizia a creare

Questo è il processo che ti permetterà di distribuire i microservizi e far transitare in modo sicuro il traffico dell'applicazione fuori dal monolite.

panoramica dell'architettura
  1. Commuta il traffico
    Questa è la configurazione iniziale. L'applicazione monolitica node.js è in esecuzione in un container su Amazon ECS.
  2. Avvia i microservizi
    Utilizzando le tre immagini di container che hai creato e caricato su Amazon ECR nel modulo precedente, avvierai tre microservizi sul tuo cluster Amazon ECS esistente.
  3. Configura i gruppi di destinazione
    Come nel Modulo 2, aggiungerai un gruppo di destinazione a ciascun servizio e aggiornerai le regole di ALB per collegare i nuovi microservizi.
  4. Spegni il monolite
    Modificando una regola nell'ALB, comincerai a inviare il traffico ai microservizi in esecuzione. Una volta verificato il reinstradamento, spegni il monolite.

Tempo richiesto per il completamento: 30 minuti

Servizi utilizzati:


Segui i passaggi indicati nelle istruzioni seguenti per distribuire i microservizi. Fai clic sul numero di ciascuna fase per espandere la sezione.

break-the-monolith
  • Fase 1. Scrittura delle definizioni delle attività per i tuoi servizi

    Distribuirai tre nuovi microservizi sullo stesso cluster in esecuzione dal Modulo 2. Come nel Modulo 2, scriverai le definizioni delle attività per ciascun servizio.

    ⚐ NOTA: è possibile aggiungere più container a una definizione di attività. In questo modo potresti eseguire tutti e tre i microservizi come container differenti su un unico servizio. Tuttavia, questo approccio sarebbe ancora monolitico visto che ogni container dovrebbe essere dimensionato in modo lineare con il servizio. Il tuo obiettivo è disporre di tre servizi indipendenti. Ciascun servizio richiede una propria definizione dell'attività, che esegua un container con l'immagine del servizio corrispondente.

    Puoi creare queste definizioni delle attività dalla console Amazon ECS oppure accelerare la procedura scrivendole come un file JSON. Per scrivere la definizione dell'attività come un file JSON, procedi come segue:

    1. Dalla console Amazon Container Services, sotto Amazon ECS, seleziona Definizioni di attività.
    2. Nella pagina Definizioni di attività, fai clic sul pulsante Crea nuova definizione di attività.
    3. Nella pagina Seleziona compatibilità con il tipo di lancio, seleziona l'opzione EC2 e poi seleziona Fase successiva.
    4. Nella pagina Configura definizioni di container e attività, scorri giù alla sezione Volumi e fai clic sul pulsante Configura tramite JSON.
    5. Copia e incolla il seguente frammento di codice nel campo JSON, sostituendo il codice esistente.
      Ricordati di sostituire i placeholder [servire-name], [account-ID], [region] e [tag].

    ⚐ Nota: i seguenti parametri vengono utilizzati per la definizione di attività:

    • Nome = [service-name: post, thread e utenti] 
    • Immagine = [URL dell'immagine del repository Amazon ECR]:latest 
    • cpu = 256 
    • memoria = 256 
    • Porta container = 3000 
    • Post host = 0
    {
        "containerDefinitions": [
            {
                "name": "[service-name]",
                "image": "[account-id].dkr.ecr.[region].amazonaws.com/[service-name]:[tag]",
                "memoryReservation": "256",
                "cpu": "256",
                "essential": true,
                "portMappings": [
                    {
                        "hostPort": "0",
                        "containerPort": "3000",
                        "protocol": "tcp"
                    }
                ]
            }
        ],
        "volumes": [],
        "networkMode": "bridge",
        "placementConstraints": [],
        "family": "[service-name]"
    }

    ♻ Ripeti i passaggi per creare una definizione di attività per ciascun servizio:

    • post
    • thread
    • utenti
  • Fase 2. Configura i gruppi di destinazione dell'Application Load Balancer

    Come nel Modulo 2, configurerai un gruppo di destinazione per ciascun servizio (post, thread e utenti). I gruppi di destinazione consentono al traffico di raggiungere correttamente ciascun servizio. Configurerai i gruppi di destinazione utilizzando l'interfaccia a riga di comando (CLI) di AWS. Tuttavia, prima di procedere, assicurati che il nome VPC sia quello utilizzato per questo tutorial:

    • Vai alla sezione Load Balancer della console EC2.
    • Seleziona la casella di controllo accanto a demo, seleziona la scheda Descrizione e individua l'attributo VPC (in questo formato: vpc-xxxxxxxxxxxxxxxxx).
      ⚐ Nota: avrai bisogno dell'attributo VPC al momento di configurare i gruppi di destinazione.

    Configura i gruppi di destinazione

    Nel tuo terminale, immetti il seguente comando per creare un gruppo di destinazione per ciascun servizio (post, thread e utenti). Inoltre, creerai un gruppo di destinazione (blocca-traffico) per evitare che il traffico raggiunga il monolite quando i microservizi saranno pienamente operativi. Ricordati di sostituire i seguenti placeholder: [region], [service-name] e [vpc-attribute].

    Nomi dei servizi: post, thread, utenti e blocca-traffico

    aws elbv2 create-target-group --region [region] --name [service-name] --protocol HTTP --port 80 --vpc-id [vpc-attribute] --healthy-threshold-count 2 --unhealthy-threshold-count 2 --health-check-timeout-seconds 5 --health-check-interval-seconds 6
    gruppi di destinazione
  • Fase 3. Configura le regole del listener

    Il listener controlla le richieste di connessione in entrata all'ALB per instradare il traffico in modo appropriato.

    Al momento, tutti e quattro i servizi (il monolite e i tre microservizi) sono in esecuzione sotto lo stesso sistema di bilanciamento del carico. Per effettuare la transizione dal monolite ai microservizi, inizierai a inviare traffico ai microservizi arrestando il traffico verso il monolite.

    Accedi alle regole del listener

    • Vai alla sezione Load Balancer della console EC2.
    • Individua il sistema di bilanciamento del carico denominato demo e seleziona la corrispondente casella di controllo per visualizzarne i dettagli.
    • Seleziona la scheda Listener.

    Aggiorna le regole del listener

    In questa scheda deve comparire un solo listener. Per modificare le regole del listener, procedi come segue:

    • Nella colonna Rules (Regole), seleziona View/edit rules (Visualizza/modifica regole).
    • Nella pagina Rules (Regole), fai clic sul pulsante più (+).
      Sulla pagina compare l'opzione Insert Rule (Inserisci regola). 
    • Usa il seguente modello per inserire le regole necessarie, una per mantenere il traffico verso il monolite e una per ciascun microservizio:
      • IF Path = /api/[nome-servizio]* THEN Forward to [nome-servizio]
        Ad esempio: IF Path = /api/post* THEN Forward to post
      • Inserisci le regole nel seguente ordine:
        • api: /api* inoltra ad api
        • utenti: /api/users* inoltra agli utenti
        • thread: /api/threads* inoltra ai thread
        • post: /api/posts* inoltra ai post
    • Seleziona Save (Salva).
    • Seleziona la freccia verso l'alto, nell'angolo in alto a sinistra della pagina, per tornare alla console del sistema di bilanciamento del carico.
    Configura le regole del listener dell'Application Load Balancer
  • Fase 4. Distribuisci i microservizi

    Distribuisci i tre microservizi (post, thread e utenti) al cluster. Ripeti questi passaggi per ciascuno dei tre microservizi.

    • Vai alla console Amazon ECS e seleziona Cluster dalla barra dei 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 Task Definition (Definizione attività), fai clic sul pulsante Enter a value (Immetti un valore) per selezionare automaticamente il valore di revisione più alto.
        Ad esempio, api:1 
      • Per Service name (Nome del servizio), immetti il nome di un servizio (post, thread o utenti).
      • Per Number of tasks (Numero di attività), immetti 1
    • Seleziona Next step (Fase successiva).
    • Nella pagina Configure network (Configura rete), sezione Load balancing (Bilanciamento del carico), esegui queste operazioni:
      • Per Load balancer type (Tipo di sistema di bilanciamento del carico), seleziona Application Load Balancer.
      • Per Ruolo servizio IAM, seleziona BreakTheMonolith-Demo-ECSServiceRole.
      • Per Nome sistema di bilanciamento del carico, verifica che sia selezionato demo.
      • Nella sezione Container per bilanciamento del carico, fai clic sul pulsante Aggiungi al sistema di bilanciamento del carico e apporta le seguenti modifiche:
        • Per Production listener port (Porta listener di produzione), imposta 80:HTTP.
        • Per Nome gruppo di destinazione, seleziona il gruppo appropriato: (post, thread o utenti)
    • Seleziona Fase successiva.
    • Nella pagina Set Auto Scaling (Imposta Auto Scaling), seleziona Next step (Fase successiva).
    • Nella pagina Review (Revisione), seleziona Create Service (Crea servizio).
    • Seleziona View Service (Visualizza servizio).

    Tutti i tuoi servizi inizieranno in pochi secondi. Prima di continuare, controlla che tutti i servizi siano in esecuzione e funzionino correttamente.

    Distribuzione di microservizi con Amazon ECS
  • Fase 5. Trasferisci il traffico ai microservizi

    Ora i microservizi sono in esecuzione, ma tutto il traffico sta ancora transitando verso il servizio del monolite. Per reinstradare il traffico verso i microservizi, procedi come segue per aggiornare le regole del listener:

    • 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.
      Deve comparire un solo listener.
    • Nella colonna Rules (Regole), seleziona View/edit rules (Visualizza/modifica regole).
    • Nella pagina Rules (Regole), fai clic sul pulsante meno ( -) dal menu superiore.
    • Elimina la prima regola (/api* forwards to api) selezionando la casella di controllo accanto alla regola.
    • Seleziona Delete (Elimina).
    • Aggiorna la regola predefinita per l'inoltro al blocca-traffico:
      • Seleziona il pulsante di modifica (matita) dal menu superiore.
      • Seleziona l'icona di modifica (matita) accanto alla regola predefinita (HTTP 80: default action).
      • Seleziona l'icona di modifica (matita) nella colonna THEN per modificare il comando Inoltra a.
      • Nel campo Target group (Gruppo di destinazione), seleziona drop-traffic.
      • Fai clic sul pulsante Update (Aggiorna).

    La seguente schermata mostra un esempio delle regole aggiornate.

    Trasferisci il traffico ai microservizi con Amazon EC2

    Disattiva il monolite: ora il traffico è diretto ai microservizi e puoi disattivare il servizio del monolite.

    • Torna al cluster Amazon ECS BreakTheMonolith-Demo-ECSCluster.
    • Nella scheda Services (Servizi), seleziona la casella di controllo accanto ad api e seleziona Update (Aggiorna).
    • Nella pagina Configure service (Configura servizio), individua Number of tasks (Numero di attività) e immetti 0.
    • Seleziona Skip to review (Passa alla revisione).
    • Seleziona Update Service (Aggiorna servizio).

    Amazon ECS ora filtrerà qualsiasi connessione che il servizio ha distribuito dai container al cluster e arresterà i container. Se dopo circa 30 secondi aggiornerai le liste di Distribuzione o Attività, vedrai il numero di attività scendere a 0. Il servizio è ancora attivo, perciò se per qualche ragione dovessi annullare l'operazione, potrai semplicemente aggiornarlo per distribuire ulteriori attività.

    Facoltativamente, puoi eliminare il servizio api. Nella scheda Services (Servizi), seleziona la casella di controllo accanto ad api, seleziona Delete (Elimina) e conferma l'eliminazione.

    Ora hai trasferito completamente node.js dal monolite ai microservizi senza tempi di inattività!

  • Fase 6. Convalida la distribuzione

    Trova l’URL del tuo servizio: è lo stesso URL che hai utilizzato nel Modulo 2 di questo tutorial.

    • Vai alla sezione Load Balancer della console EC2.
    • Seleziona la casella di controllo demo per visualizzare i dettagli del sistema di bilanciamento del carico.
    • Nella scheda Descrizione, individua il Nome DNS e seleziona l'icona di copia alla fine dell'URL. 
    • Incolla il nome DNS in una nuova finestra o scheda del browser.

    Dovresti visualizzare il messaggio 'Pronto per ricevere richieste'.

    Guarda i valori per ogni microservizio: il tuo ALB instrada il traffico in base all'URL della richiesta. Per visualizzare ciascun servizio, è sufficiente aggiungere il nome alla fine del nome DNS:

    • http://[DNS name]/api/users
    • http://[DNS name]/api/threads
    • http://[DNS name]/api/posts
    visualizza i valori per ciascun microservizio

    ⚐ NOTA: questi URL funzionano allo stesso modo della distribuzione del monolite. Questo è molto importante perché qualsiasi API o consumatore che vuole connettersi a quest'applicazione non sarà interessato dalle modifiche apportate. Il passaggio dal monolite ai microservizi non necessita di alcuna modifica ad altre parti dell'infrastruttura.

    È inoltre possibile utilizzare strumenti come Postman per testare le API.