Implementazione di un'applicazione Web di container in Amazon ECS

GUIDA ALLE OPERAZIONI DI BASE

Modulo 2: Creazione dell'infrastruttura e implementazione dell'applicazione

In questo modulo verrà creato un cluster ECS e verrà distribuita l'applicazione con CDK

Introduzione

In questo modulo verrà creata un'applicazione AWS CDK che creerà tutta l'infrastruttura necessaria per configurare un cluster ECS e per implementare in esso un container di esempio.

Gli argomenti affrontati

  • Creazione di un'applicazione CDK semplice
  • Creazione di un cluster ECS, con Fargate per la capacità
  • Creazione di una definizione di attività e di un servizio per implementare l'applicazione

 Tempo richiesto per il completamento

15 minuti

 Prerequisiti del modulo

  • Account AWS con accesso da amministratore**
  • Browser consigliato: l'ultima versione di Chrome o Firefox

[**]Gli account creati nelle ultime 24 ore potrebbero non avere ancora accesso a tutti servizi richiesti per questo tutorial.

Implementazione

Creazione dell'app CDK

Per prima cosa, verificare che CDK sia installato. Se non è installato, seguire le istruzioni riportate in Nozioni di base su AWS CDK:

cdk --version

Adesso creeremo lo scheletro dell'applicazione CDK usando TypeScript come linguaggio. Emettere il seguente comando nel terminale:

mkdir cdk-ecs-infra
cd cdk-ecs-infra
cdk init app --language typescript

Il risultato sarà il seguente:

Applying project template app for typescript
# Welcome to your CDK TypeScript project!

This is a blank project for TypeScript development with CDK.

The `cdk.json` file tells the CDK Toolkit how to execute your app.

## Useful commands

 * `npm run build`   compile typescript to js
 * `npm run watch`   watch for changes and compile
 * `npm run test`    perform the jest unit tests
 * `cdk deploy`      deploy this stack to your default AWS account/region
 * `cdk diff`        compare deployed stack with current state
 * `cdk synth`       emits the synthesized CloudFormation template

Executing npm install...
✅ All done!

Creazione del codice per lo stack di risorse

Passare al file /lib/cdk-ecs-infra-stack.ts, che è dove verrà scritto il codice per lo stack di risorse che verrà creato.

Una pila di risorse è una serie di risorse delle infrastrutture cloud (nel tuo caso particolare saranno tutte risorse AWS) di cui è stato effettuato il provisioning in un account specifico. L'account o la regione in cui sono fornite queste risorse possono essere configurati nella pila, come descritto nella guida Nozioni di base su AWS CDK.

In questa pila di risorse, verranno create le seguenti risorse:

  • Ruolo IAM: questo ruolo verrà assegnato al container in modo che possa richiamare altri servizi AWS.
  • Definizione di attività ECS: i parametri specifici da utilizzare all'avvio del container.
  • Modello ECS per il servizio Fargate a carico bilanciato: astrae la complessità di tutti i componenti necessari per creare il cluster, il bilanciatore del carico, il servizio e configura tutto perché funzionino insieme.

Creazione del cluster ECS

Per iniziare a creare il cluster ECS, è necessario per prima cosa importare i moduli corretti:

npm i @aws-cdk/aws-s3-assets

Quindi, nel file lib/cdk-eb-infra-stack.ts aggiungere la dipendenza alla parte superiore del file.

npm i @aws-cdk/aws-ec2 @aws-cdk/aws-ecs @aws-cdk/aws-ecs-patterns @aws-cdk/aws-iam 

Modificare il file lib/cdk-eb-infra-stack.ts per aggiungere la dipendenza alla parte superiore del file:

import ecs = require('@aws-cdk/aws-ecs'); // Allows working with ECS resources
import ec2 = require('@aws-cdk/aws-ec2'); // Allows working with EC2 and VPC resources
import iam = require('@aws-cdk/aws-iam'); // Allows working with IAM resources
import ecsPatterns = require('@aws-cdk/aws-ecs-patterns') // Helper to create ECS services with loadbalancers, and configure them

Questi moduli forniscono accesso a tutti i componenti necessari per implementare l'applicazione Web. Il primo passaggio è quello di trovare il VPC di default nell'account aggiungendo il seguente codice:

// Look up the default VPC
const vpc = ec2.Vpc.fromLookup(this, "VPC", {
   isDefault: true
});

Successivamente, sarà necessario definire il container da utilizzare e decidere come deve essere configurato. Questo viene fatto creando una definizione di attività per fornire la porta del container, la quantità di CPU e memoria necessaria e l'immagine del container da utilizzare. Per questa guida, verrà creata l'immagine del container fornita con l'applicazione di esempio nella cartella SampleApp e impostare CDK in modo da gestire la creazione, il caricamento e l'implementazione del container per conto dell'utente. Verrà inoltre creato un ruolo IAM vuoto per collegare la definizione di attività per le guide future. 

Per creare la definizione di attività e il ruolo IAM, aggiungere il seguente codice:

const taskIamRole = new iam.Role(this, "AppRole", {
    roleName: "AppRole",
    assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
});

const taskDefinition = new ecs.FargateTaskDefinition(this, 'Task', {
    taskRole: taskIamRole,
});

taskDefinition.addContainer('MyContainer', {
    image: ecs.ContainerImage.fromAsset('../SampleApp'),
    portMappings: [{ containerPort: 80 }],
    memoryReservationMiB: 256,
     cpu : 256,
});

Nel codice sopra, è stato specificato un tipo di definizione di attività da implementare su Fargate utilizzando FargateTaskDefintion e ContainerImage.fromAsset. CDK genererà l'immagine del container utilizzando il Dockerfile nella directory SampleApp.

Successivamente, sarà necessario configurare il cluster ECS, definire un servizio, creare un bilanciatore del carico, configurarlo per la connessione al servizio e impostare le regole del gruppo di sicurezza richieste. Un servizio in ECS è utilizzato per avviare una definizione di attività specificando il numero di copie desiderato, le strategie di implementazione e altre configurazioni. Per questo esempio, verrà avviata soltanto una copia del container. Un gruppo di sicurezza funge da firewall virtuale per l'istanza per controllare il traffico in entrata e in uscita, ma non è necessario configurarlo poiché il modello ECS utilizzato lo farà per conto dell'utente. 

Aggiungere il seguente codice al progetto di seguito per la definizione di attività:

new ecsPatterns.ApplicationLoadBalancedFargateService(this, "MyApp", {
    vpc: vpc,
    taskDefinition: taskDefinition,
    desiredCount: 1,
    serviceName: 'MyWebApp',
    assignPublicIp: true,
    publicLoadBalancer: true,
})

Si sta passando l'oggetto vpc cercato in precedenza per specificare dove creare tutte le risorse, insieme alla definizione di attività che definisce quale immagine del container implementare. desiredCount indica il numero di copie desiderato, serviceName come chiamare il servizio e publicLoadBalancer è impostato su true in modo che ci si possa accedere tramite Internet. La riga che imposta assignPublicIp su true è importante in questo esempio poiché si utilizza il VPC predefinito che non dispone di sottoreti private. La best practice consiglia di avviare servizi in sottoreti private, ma non rientra nell'ambito di questa guida.

A questo punto si è pronti per implementare l'applicazione Web, ma prima è necessario configurare CDK sull'account tramite il quale si sta effettuando l'implementazione. 

Modificare il file bin/cdk-ecs-infra.ts e rimuovere i commenti dalla linea 14:

env: { account: process.env.CDK_DEFAULT_ACCOUNT, region: process.env.CDK_DEFAULT_REGION },

Verrà utilizzato l'ID account e la regione configurata in AWS CLI. Prima di poter utilizzare CDK, è necessario eseguirne il bootstrap per creare l'infrastruttura richiesta perché possa gestire l'infrastruttura nell'account. Per eseguire il processo bootstrap di CDK, eseguire cdk bootstrap. Dovrebbe essere visualizzato un output simile al seguente:

cdk bootstrap

#output
⏳  Bootstrapping environment aws://0123456789012/<region>...
✅  Environment aws://0123456789012/<region> bootstrapped

Questo creerà l'infrastruttura richiesta per CDK per gestire l'infrastruttura nell'account; consigliamo di seguire la procedura riportata in Nozioni di base su AWS CDK se non si è esperti di configurazione di un'applicazione CDK.

Una volta che il processo di bootstrap è completo, eseguire cdk deploy per implementare il container, il cluster e tutto il resto dell'infrastruttura richiesta. Dovrebbe essere visualizzato un risultato simile al seguente:

gsg-build-ecs-2

CDK chiederà conferma prima di creare l'infrastruttura, poiché è la creazione dell'infrastruttura che cambia la configurazione della sicurezza, nel nostro caso creando ruoli IAM e gruppi di sicurezza. Premere y e quindi Invio per implementare. CDK ora imposterà tutta l'infrastruttura definita e per il completamento ci vorranno alcuni minuti. 

Mentre è in esecuzione, verranno visualizzati aggiornamenti simili al seguente:

gsg-build-ecs-3

Una volta completato, l'output con il collegamento all'URL pubblico per accedere al servizio sarà:

gsg-build-ecs-4

Esempio di codice completo

import * as cdk from '@aws-cdk/core';
import ecs = require('@aws-cdk/aws-ecs');
import ec2 = require('@aws-cdk/aws-ec2');
import iam = require('@aws-cdk/aws-iam');
import ecsPatterns = require('@aws-cdk/aws-ecs-patterns')

export class CdkEcsInfraStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

      // Look up the default VPC
      const vpc = ec2.Vpc.fromLookup(this, "VPC", {
        isDefault: true
      });

      const taskIamRole = new iam.Role(this, "AppRole", {
        roleName: "AppRole",
        assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
      });

      const taskDefinition = new ecs.FargateTaskDefinition(this, 'Task', {
        taskRole: taskIamRole,
      });

      taskDefinition.addContainer('MyContainer', {
        image: ecs.ContainerImage.fromAsset('../SampleApp'),
        portMappings: [{ containerPort: 80 }],
        memoryReservationMiB: 256,
        cpu : 256,
      });

      new ecsPatterns.ApplicationLoadBalancedFargateService(this, "MyApp", {
        vpc: vpc,
        taskDefinition: taskDefinition,
        desiredCount: 1,
        serviceName: 'MyWebApp',
        assignPublicIp: true,
        publicLoadBalancer: true,
      })

  }
}

Conclusione

In questo modulo è stato descritto come creare un cluster ECS con un bilanciatore del carico per smistare il traffico al container in esecuzione su Fargate utilizzando un modello ECS fornito da CDK. Nel modulo successivo saranno eliminate tutte le risorse che sono state create in questa guida.

A seguire: Eliminazione delle risorse

Facci sapere com'è andata.

Grazie per il tuo feedback
Siamo contenti che questa pagina ti sia stata d’aiuto. Vuoi condividere ulteriori dettagli per aiutarci a continuare a migliorare?
Chiudi
Grazie per il tuo feedback
Ci dispiace che questa pagina non ti sia stata d'aiuto. Vuoi condividere ulteriori dettagli per aiutarci a continuare a migliorare?
Chiudi