Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Creazione di risorse Amazon ECS utilizzando AWS CDK AWS Cloud Development Kit (AWS CDK) È un framework Infrastructure-as-Code (IAC) che puoi utilizzare per definire l'infrastruttura AWS cloud utilizzando un linguaggio di programmazione di tua scelta. Per definire la tua infrastruttura cloud, devi innanzitutto scrivere un'app (in uno dei linguaggi supportati dal CDK) contenente uno o più stack. Quindi, lo sintetizzi in un CloudFormation modello e distribuisci le tue risorse sul tuo. Account AWS Segui i passaggi descritti in questo argomento per distribuire un server Web containerizzato con Amazon Elastic Container Service (Amazon ECS) e su Fargate. AWS CDK La AWS Construct Library, inclusa nel CDK, fornisce moduli che puoi usare per modellare le risorse che forniscono. Servizi AWS Per i servizi più diffusi, la libreria fornisce costrutti curati con impostazioni predefinite intelligenti e best practice. Uno di questi moduli, `[aws-ecs-patterns](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs_patterns-readme.html)`, fornisce astrazioni di alto livello che possono essere utilizzate per definire il servizio containerizzato e tutte le risorse di supporto necessarie in poche righe di codice. In questo argomento viene utilizzato il costrutto [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs_patterns.ApplicationLoadBalancedFargateService.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs_patterns.ApplicationLoadBalancedFargateService.html). Questo costrutto implementa un servizio Amazon ECS su Fargate dietro un Application Load Balancer. Il modulo `aws-ecs-patterns` include anche costrutti che utilizzano un Network Load Balancer e sono eseguiti su Amazon EC2. Prima di iniziare questa attività, configurate l'ambiente di AWS CDK sviluppo e installatelo AWS CDK eseguendo il comando seguente. Per istruzioni su come configurare l'ambiente di AWS CDK sviluppo, consulta [Getting Started With the AWS CDK - Prerequisiti](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites). ``` npm install -g aws-cdk ``` **Nota** Queste istruzioni presuppongono che tu stia usando AWS CDK v2. **Topics** + [Passaggio 1: configura il tuo progetto AWS CDK](#ecs-web-server-cdk-step-1) + [Passaggio 2: utilizzare il AWS CDK per definire un server Web containerizzato su Fargate](#ecs-web-server-cdk-step-2) + [Fase 3: Test del server Web](#ecs-web-server-cdk-step-3) + [Fase 4: pulizia](#ecs-web-server-cdk-step-4) + [Fasi successive](#ecs-web-server-cdk-next-steps) ## Passaggio 1: configura il tuo progetto AWS CDK Crea una directory per la tua nuova AWS CDK app e inizializza il progetto. ------ #### [ TypeScript ] ``` mkdir hello-ecs cd hello-ecs cdk init --language typescript ``` ------ #### [ JavaScript ] ``` mkdir hello-ecs cd hello-ecs cdk init --language javascript ``` ------ #### [ Python ] ``` mkdir hello-ecs cd hello-ecs cdk init --language python ``` Dopo l'avvio del progetto, attiva l'ambiente virtuale del progetto e installa le dipendenze AWS CDK di base. ``` source .venv/bin/activate python -m pip install -r requirements.txt ``` ------ #### [ Java ] ``` mkdir hello-ecs cd hello-ecs cdk init --language java ``` Importa questo progetto Maven nel tuo IDE Java. Ad esempio, in Eclipse, usa **File** > **Import** (Importa) > **Maven** > **Existing Maven Projects** (Progetti Maven esistenti). ------ #### [ C\$1 ] ``` mkdir hello-ecs cd hello-ecs cdk init --language csharp ``` ------ #### [ Go ] ``` mkdir hello-ecs cd hello-ecs cdk init --language go ``` ------ **Nota** Il modello di AWS CDK applicazione utilizza il nome della directory del progetto per generare nomi per i file e le classi di origine. In questo esempio, la directory è denominata `hello-ecs`. Se utilizzi un nome di directory del progetto diverso, l'app non corrisponderà a queste istruzioni. AWS CDK v2 include costrutti stabili per tutti Servizi AWS in un unico pacchetto chiamato. `aws-cdk-lib` Questo pacchetto viene installato come dipendenza quando inizializzi il progetto. Quando lavori con determinati linguaggi di programmazione, il pacchetto viene installato quando crei il progetto per la prima volta. In questo argomento viene descritto come utilizzare un costrutto Amazon ECS Patterns, che fornisce astrazioni di alto livello per lavorare con Amazon ECS. Questo modulo si basa sui costrutti Amazon ECS e su altri costrutti per il provisioning delle risorse necessarie per l'applicazione Amazon ECS. I nomi utilizzati per importare queste librerie nell'applicazione CDK potrebbero differire leggermente a seconda del linguaggio di programmazione utilizzato. Come riferimento, ecco i nomi utilizzati in ogni linguaggio di programmazione CDK supportato. ------ #### [ TypeScript ] ``` aws-cdk-lib/aws-ecs aws-cdk-lib/aws-ecs-patterns ``` ------ #### [ JavaScript ] ``` aws-cdk-lib/aws-ecs aws-cdk-lib/aws-ecs-patterns ``` ------ #### [ Python ] ``` aws_cdk.aws_ecs aws_cdk.aws_ecs_patterns ``` ------ #### [ Java ] ``` software.amazon.awscdk.services.ecs software.amazon.awscdk.services.ecs.patterns ``` ------ #### [ C\$1 ] ``` Amazon.CDK.AWS.ECS Amazon.CDK.AWS.ECS.Patterns ``` ------ #### [ Go ] ``` github.com/aws/aws-cdk-go/awscdk/v2/awsecs github.com/aws/aws-cdk-go/awscdk/v2/awsecspatterns ``` ------ ## Passaggio 2: utilizzare il AWS CDK per definire un server Web containerizzato su Fargate Utilizza l'immagine del container [https://gallery.ecr.aws/ecs-sample-image/amazon-ecs-sample](https://gallery.ecr.aws/ecs-sample-image/amazon-ecs-sample). Questa immagine contiene un'app web PHP in esecuzione su Ngingx. Nel AWS CDK progetto che avete creato, modificate il file che contiene la definizione dello stack in modo che sia simile a uno dei seguenti esempi. **Nota** Uno stack è un'unità di implementazione. Tutte le risorse devono trovarsi in uno stack e tutte le risorse in uno stack vengono implementate contemporaneamente. Se una risorsa non viene implementata, verrà eseguito il rollback di tutte le altre risorse già implementate. Un' AWS CDK app può contenere più stack e le risorse in uno stack possono fare riferimento a risorse in un altro stack. ------ #### [ TypeScript ] Aggiorna `lib/hello-ecs-stack.ts` in modo che assomigli a quanto segue. ``` import * as cdk from 'aws-cdk-lib'; import { Construct } from 'constructs'; import * as ecs from 'aws-cdk-lib/aws-ecs'; import * as ecsp from 'aws-cdk-lib/aws-ecs-patterns'; export class HelloEcsStack extends cdk.Stack { constructor(scope: Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); new ecsp.ApplicationLoadBalancedFargateService(this, 'MyWebServer', { taskImageOptions: { image: ecs.ContainerImage.fromRegistry('public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest'), }, publicLoadBalancer: true }); } } ``` ------ #### [ JavaScript ] Aggiorna `lib/hello-ecs-stack.js` in modo che assomigli a quanto segue. ``` const cdk = require('aws-cdk-lib'); const { Construct } = require('constructs'); const ecs = require('aws-cdk-lib/aws-ecs'); const ecsp = require('aws-cdk-lib/aws-ecs-patterns'); class HelloEcsStack extends cdk.Stack { constructor(scope = Construct, id = string, props = cdk.StackProps) { super(scope, id, props); new ecsp.ApplicationLoadBalancedFargateService(this, 'MyWebServer', { taskImageOptions: { image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'), }, publicLoadBalancer: true }); } } module.exports = { HelloEcsStack } ``` ------ #### [ Python ] Aggiorna `hello-ecs/hello_ecs_stack.py` in modo che assomigli a quanto segue. ``` import aws_cdk as cdk from constructs import Construct import aws_cdk.aws_ecs as ecs import aws_cdk.aws_ecs_patterns as ecsp class HelloEcsStack(cdk.Stack): def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) ecsp.ApplicationLoadBalancedFargateService(self, "MyWebServer", task_image_options=ecsp.ApplicationLoadBalancedTaskImageOptions( image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")), public_load_balancer=True ) ``` ------ #### [ Java ] Aggiorna `src/main/java/com.myorg/HelloEcsStack.java` in modo che assomigli a quanto segue. ``` package com.myorg; import software.constructs.Construct; import software.amazon.awscdk.Stack; import software.amazon.awscdk.StackProps; import software.amazon.awscdk.services.ecs.ContainerImage; import software.amazon.awscdk.services.ecs.patterns.ApplicationLoadBalancedFargateService; import software.amazon.awscdk.services.ecs.patterns.ApplicationLoadBalancedTaskImageOptions; public class HelloEcsStack extends Stack { public HelloEcsStack(final Construct scope, final String id) { this(scope, id, null); } public HelloEcsStack(final Construct scope, final String id, final StackProps props) { super(scope, id, props); ApplicationLoadBalancedFargateService.Builder.create(this, "MyWebServer") .taskImageOptions(ApplicationLoadBalancedTaskImageOptions.builder() .image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample")) .build()) .publicLoadBalancer(true) .build(); } } ``` ------ #### [ C\$1 ] Aggiorna `src/HelloEcs/HelloEcsStack.cs` in modo che assomigli a quanto segue. ``` using Amazon.CDK; using Constructs; using Amazon.CDK.AWS.ECS; using Amazon.CDK.AWS.ECS.Patterns; namespace HelloEcs { public class HelloEcsStack : Stack { internal HelloEcsStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props) { new ApplicationLoadBalancedFargateService(this, "MyWebServer", new ApplicationLoadBalancedFargateServiceProps { TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions { Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample") }, PublicLoadBalancer = true }); } } } ``` ------ #### [ Go ] Aggiorna `hello-ecs.go` in modo che assomigli a quanto segue. ``` package main import ( "github.com/aws/aws-cdk-go/awscdk/v2" // "github.com/aws/aws-cdk-go/awscdk/v2/awssqs" "github.com/aws/aws-cdk-go/awscdk/v2/awsecs" "github.com/aws/aws-cdk-go/awscdk/v2/awsecspatterns" "github.com/aws/constructs-go/constructs/v10" "github.com/aws/jsii-runtime-go" ) type HelloEcsStackProps struct { awscdk.StackProps } func NewHelloEcsStack(scope constructs.Construct, id string, props *HelloEcsStackProps) awscdk.Stack { var sprops awscdk.StackProps if props != nil { sprops = props.StackProps } stack := awscdk.NewStack(scope, &id, &sprops) // The code that defines your stack goes here // example resource // queue := awssqs.NewQueue(stack, jsii.String("HelloEcsQueue"), &awssqs.QueueProps{ // VisibilityTimeout: awscdk.Duration_Seconds(jsii.Number(300)), // }) res := awsecspatterns.NewApplicationLoadBalancedFargateService(stack, jsii.String("MyWebServer"), &awsecspatterns.ApplicationLoadBalancedFargateServiceProps{ TaskImageOptions: &awsecspatterns.ApplicationLoadBalancedTaskImageOptions{ Image: awsecs.ContainerImage_FromRegistry(jsii.String("amazon/amazon-ecs-sample"), &awsecs.RepositoryImageProps{}), }, }, ) awscdk.NewCfnOutput(stack, jsii.String("LoadBalancerDNS"), &awscdk.CfnOutputProps{Value: res.LoadBalancer().LoadBalancerDnsName()}) return stack } func main() { defer jsii.Close() app := awscdk.NewApp(nil) NewHelloEcsStack(app, "HelloEcsStack", &HelloEcsStackProps{ awscdk.StackProps{ Env: env(), }, }) app.Synth(nil) } // env determines the AWS environment (account+region) in which our stack is to // be deployed. For more information see: https://docs.aws.amazon.com/cdk/latest/guide/environments.html func env() *awscdk.Environment { // If unspecified, this stack will be "environment-agnostic". // Account/Region-dependent features and context lookups will not work, but a // single synthesized template can be deployed anywhere. //--------------------------------------------------------------------------- return nil // Uncomment if you know exactly what account and region you want to deploy // the stack to. This is the recommendation for production stacks. //--------------------------------------------------------------------------- // return &awscdk.Environment{ // Account: jsii.String("123456789012"), // Region: jsii.String("us-east-1"), // } // Uncomment to specialize this stack for the AWS Account and Region that are // implied by the current CLI configuration. This is recommended for dev // stacks. //--------------------------------------------------------------------------- // return &awscdk.Environment{ // Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")), // Region: jsii.String(os.Getenv("CDK_DEFAULT_REGION")), // } } ``` ------ Il frammento breve precedente include quanto segue: + Il nome logico del servizio, `MyWebServer`. + L'immagine del container è stata ottenuta dalla Galleria pubblica di Amazon ECR: `amazon/amazon-ecs-sample`. + Altre informazioni pertinenti, ad esempio il fatto che il bilanciatore del carico ha un indirizzo pubblico ed è accessibile da Internet. AWS CDK Creerà tutte le risorse necessarie per distribuire il server Web, incluse le seguenti risorse. Queste risorse sono state omesse in questo esempio. + Cluster Amazon ECS + Istanze Amazon VPC e Amazon EC2 + Gruppo Auto Scaling + Application Load Balancer + Ruoli IAM e policy Alcune risorse con provisioning automatico verranno condivise da tutti i servizi Amazon ECS definiti nello stack. Salva il file di origine, quindi esegui il comando `cdk synth` nella directory principale dell'applicazione. AWS CDK Esegue l'app e sintetizza un CloudFormation modello a partire da essa, quindi visualizza il modello. Il modello è un file YAML di circa 600 righe. L'inizio del file è mostrato di seguito. Il modello potrebbe differire da questo esempio. ``` Resources: MyWebServerLB3B5FD3AB: Type: AWS::ElasticLoadBalancingV2::LoadBalancer Properties: LoadBalancerAttributes: - Key: deletion_protection.enabled Value: "false" Scheme: internet-facing SecurityGroups: - Fn::GetAtt: - MyWebServerLBSecurityGroup01B285AA - GroupId Subnets: - Ref: EcsDefaultClusterMnL3mNNYNVpcPublicSubnet1Subnet3C273B99 - Ref: EcsDefaultClusterMnL3mNNYNVpcPublicSubnet2Subnet95FF715A Type: application DependsOn: - EcsDefaultClusterMnL3mNNYNVpcPublicSubnet1DefaultRouteFF4E2178 - EcsDefaultClusterMnL3mNNYNVpcPublicSubnet2DefaultRouteB1375520 Metadata: aws:cdk:path: HelloEcsStack/MyWebServer/LB/Resource MyWebServerLBSecurityGroup01B285AA: Type: AWS::EC2::SecurityGroup Properties: GroupDescription: Automatically created Security Group for ELB HelloEcsStackMyWebServerLB06757F57 SecurityGroupIngress: - CidrIp: 0.0.0.0/0 Description: Allow from anyone on port 80 FromPort: 80 IpProtocol: tcp ToPort: 80 VpcId: Ref: EcsDefaultClusterMnL3mNNYNVpc7788A521 Metadata: aws:cdk:path: HelloEcsStack/MyWebServer/LB/SecurityGroup/Resource # and so on for another few hundred lines ``` Per distribuire il servizio nella tua applicazione Account AWS, esegui il `cdk deploy` comando nella directory principale dell'applicazione. Ti viene chiesto di approvare le policy IAM che hanno generato. AWS CDK L'implementazione richiede diversi minuti, durante i quali vengono AWS CDK create diverse risorse. Le ultime righe dell'output dell'implementazione includono il nome host pubblico del bilanciatore del carico e un URL del nuovo server Web. Sono i seguenti: ``` Outputs: HelloEcsStack.MyWebServerLoadBalancerDNSXXXXXXX = Hello-MyWeb-ZZZZZZZZZZZZZ-ZZZZZZZZZZ.us-west-2.elb.amazonaws.com HelloEcsStack.MyWebServerServiceURLYYYYYYYY = http://Hello-MyWeb-ZZZZZZZZZZZZZ-ZZZZZZZZZZ.us-west-2.elb.amazonaws.com ``` ## Fase 3: Test del server Web Copia l'URL dall'output dell'implementazione e incollalo nel browser Web. Viene visualizzato il seguente messaggio di benvenuto dal server Web. ![\[Screenshot dell'applicazione di esempio Amazon ECS. L'output indica “Amazon ECS”.\]](http://docs.aws.amazon.com/it_it/AmazonECS/latest/developerguide/images/simple-php-app-congrats.png) ## Fase 4: pulizia Dopo aver finito con il server Web, termina il servizio utilizzando il CDK eseguendo il comando `cdk destroy` nella directory principale dell'applicazione. In questo modo si evita di incorrere in addebiti non intenzionali in futuro. ## Fasi successive Per ulteriori informazioni su come sviluppare l' AWS infrastruttura utilizzando la AWS CDK, consulta la [Guida per gli AWS CDK sviluppatori](https://docs.aws.amazon.com/cdk/v2/guide/). Per informazioni sulla scrittura di AWS CDK app nella lingua che preferisci, consulta quanto segue: ------ #### [ TypeScript ] [Lavorare con AWS CDK in TypeScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-typescript.html) ------ #### [ JavaScript ] [Lavorare con l' AWS CDK interno JavaScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-javascript.html) ------ #### [ Python ] [Lavorare con il AWS CDK in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html) ------ #### [ Java ] [Lavorare con il AWS CDK in Java](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-java.html) ------ #### [ C\$1 ] [Lavorare con il AWS CDK in C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html) ------ #### [ Go ] [Lavorare con AWS CDK in Go](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-go.html) ------ Per ulteriori informazioni sui moduli AWS Construct Library utilizzati in questo argomento, consultate le seguenti panoramiche di riferimento sulle AWS CDK API. + [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs-readme.html) + [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs_patterns-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs_patterns-readme.html)