Seleziona le tue preferenze relative ai cookie

Utilizziamo cookie essenziali e strumenti simili necessari per fornire il nostro sito e i nostri servizi. Utilizziamo i cookie prestazionali per raccogliere statistiche anonime in modo da poter capire come i clienti utilizzano il nostro sito e apportare miglioramenti. I cookie essenziali non possono essere disattivati, ma puoi fare clic su \"Personalizza\" o \"Rifiuta\" per rifiutare i cookie prestazionali.

Se sei d'accordo, AWS e le terze parti approvate utilizzeranno i cookie anche per fornire utili funzionalità del sito, ricordare le tue preferenze e visualizzare contenuti pertinenti, inclusa la pubblicità pertinente. Per continuare senza accettare questi cookie, fai clic su \"Continua\" o \"Rifiuta\". Per effettuare scelte più dettagliate o saperne di più, fai clic su \"Personalizza\".

Preferenze
Contattaci
Feedback
AWS Documentation
Crea un Account AWS

Esempio: creare un AWS Fargate servizio utilizzando AWS CDK

RSS
Modalità Focus
Esempio: creare un AWS Fargate servizio utilizzando AWS CDK - AWS Cloud Development Kit (AWS CDK) v2
Creazione di un progetto CDKCreare un servizio FargateEliminazione

Questa è la guida per sviluppatori AWS CDK v2. Il vecchio CDK v1 è entrato in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.

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à.

Questa è la guida per sviluppatori AWS CDK v2. Il vecchio CDK v1 è entrato in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.

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à.

In questo esempio, ti mostriamo come creare un AWS Fargate servizio in esecuzione su un cluster Amazon Elastic Container Service (Amazon ECS) gestito da un Application Load Balancer connesso a Internet da un'immagine su Amazon ECR.

Amazon ECS è un servizio di gestione dei container altamente scalabile e veloce che semplifica l'esecuzione, l'arresto e la gestione Docker contenitori su un cluster. Puoi ospitare il tuo cluster su un'infrastruttura serverless gestita da Amazon ECS avviando i tuoi servizi o attività utilizzando il tipo di lancio Fargate. Per un maggiore controllo, puoi ospitare le tue attività su un cluster di istanze Amazon Elastic Compute Cloud (Amazon EC2) che gestisci utilizzando il tipo di EC2 avvio di Amazon.

In questo esempio, lanciamo alcuni servizi utilizzando il tipo di lancio Fargate. Se hai utilizzato il AWS Management Console per creare un servizio Fargate, sai che ci sono molti passaggi da seguire per eseguire tale operazione. AWS contiene diversi tutorial e argomenti di documentazione che illustrano la creazione di un servizio Fargate, tra cui:

Questo esempio crea un servizio Fargate simile utilizzando. AWS CDK

Il costrutto Amazon ECS utilizzato in questo esempio ti aiuta a utilizzare AWS i servizi offrendo i seguenti vantaggi:

  • Configura automaticamente un sistema di bilanciamento del carico.

  • Apre automaticamente un gruppo di sicurezza per i sistemi di bilanciamento del carico. Ciò consente ai sistemi di bilanciamento del carico di comunicare con le istanze senza dover creare esplicitamente un gruppo di sicurezza.

  • Ordina automaticamente la dipendenza tra il servizio e il sistema di bilanciamento del carico collegato a un gruppo target, applicando l'ordine corretto di creazione del AWS CDK listener prima della creazione di un'istanza.

  • Configura automaticamente i dati degli utenti su gruppi di ridimensionamento automatico. Questo crea la configurazione corretta a cui associare un cluster. AMIs

  • Convalida anticipatamente le combinazioni di parametri. Ciò espone i AWS CloudFormation problemi prima, risparmiando così i tempi di implementazione. Ad esempio, a seconda dell'attività, è facile configurare in modo errato le impostazioni della memoria. In precedenza, non si verificava alcun errore fino a quando non avessimo distribuito la nostra app. Ma ora AWS CDK possono rilevare una configurazione errata ed emettere un errore quando sintetizziamo la nostra app.

  • Aggiunge automaticamente le autorizzazioni per Amazon Elastic Container Registry (Amazon ECR) se utilizziamo un'immagine di Amazon ECR.

  • Ridimensiona automaticamente. AWS CDK Fornisce un metodo che ci consente di scalare automaticamente le istanze quando utilizziamo un EC2 cluster Amazon. Ciò avviene automaticamente quando utilizziamo un'istanza in un cluster Fargate.

    Inoltre, AWS CDK impedisce l'eliminazione di un'istanza quando il ridimensionamento automatico tenta di arrestare un'istanza, ma un'attività è in esecuzione o è pianificata su quell'istanza.

    In precedenza, dovevamo creare una funzione Lambda per avere questa funzionalità.

  • Fornisce supporto per gli asset, in modo da poter distribuire una fonte dalla nostra macchina ad Amazon ECS in un unico passaggio. In precedenza, per utilizzare una fonte di applicazione, dovevamo eseguire diversi passaggi manuali, come il caricamento su Amazon ECR e la creazione di un Docker immagine.

Importante

ApplicationLoadBalancedFargateServiceI costrutti che useremo includono numerosi AWS componenti, alcuni dei quali hanno costi non banali se lasciati disponibili nel nostro AWS account, anche se non li utilizziamo. Assicurati di usare clean up (cdk destroy) se segui questo esempio.

Creazione di un progetto CDK

Iniziamo creando un progetto CDK. Questa è una directory che memorizza il nostro AWS CDK codice, inclusa la nostra app CDK.

TypeScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript
JavaScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language javascript
Python
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language python
source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead
pip install -r requirements.txt
Java
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language java

Ora possiamo importare il progetto Maven nel nostro IDE.

C#
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language csharp

Ora possiamo aprire src/MyEcsConstruct.sln in Visual Studio.

anchoranchoranchoranchoranchor
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript

Successivamente, eseguiamo l'app e confermiamo che crea uno stack vuoto.

cdk synth

Creare un servizio Fargate

Esistono due modi diversi in cui possiamo eseguire le nostre attività relative ai container con Amazon ECS:

  • Utilizza il tipo di Fargate avvio, in cui Amazon ECS gestisce per noi le macchine fisiche su cui vengono eseguiti i nostri container.

  • Usa il tipo di EC2 avvio, dove ci occupiamo della gestione, ad esempio specificando il ridimensionamento automatico.

Per questo esempio, creeremo un servizio Fargate in esecuzione su un cluster Amazon ECS, gestito da un Application Load Balancer con accesso a Internet.

Aggiungiamo le seguenti importazioni di moduli AWS Construct Library al nostro file stack:

TypeScript

File: lib/my_ecs_construct-stack.ts

import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as ecs from "aws-cdk-lib/aws-ecs";
import * as ecs_patterns from "aws-cdk-lib/aws-ecs-patterns";
JavaScript

Archiviazione: lib/my_ecs_construct-stack.js

const ec2 = require("aws-cdk-lib/aws-ec2");
const ecs = require("aws-cdk-lib/aws-ecs");
const ecs_patterns = require("aws-cdk-lib/aws-ecs-patterns");
Python

Archiviazione: my_ecs_construct/my_ecs_construct_stack.py

from aws_cdk import (aws_ec2 as ec2, aws_ecs as ecs,
                     aws_ecs_patterns as ecs_patterns)
Java

Archiviazione: src/main/java/com/myorg/MyEcsConstructStack.java

import software.amazon.awscdk.services.ec2.*;
import software.amazon.awscdk.services.ecs.*;
import software.amazon.awscdk.services.ecs.patterns.*;
C#

Archiviazione: src/MyEcsConstruct/MyEcsConstructStack.cs

using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECS.Patterns;
anchoranchoranchoranchoranchor

File: lib/my_ecs_construct-stack.ts

import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as ecs from "aws-cdk-lib/aws-ecs";
import * as ecs_patterns from "aws-cdk-lib/aws-ecs-patterns";

All'interno del nostro stack, aggiungiamo il seguente codice:

TypeScript
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });
JavaScript
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });
Python
        vpc = ec2.Vpc(self, "MyVpc", max_azs=3)     # default is all AZs in region

        cluster = ecs.Cluster(self, "MyCluster", vpc=vpc)

        ecs_patterns.ApplicationLoadBalancedFargateService(self, "MyFargateService",
            cluster=cluster,            # Required
            cpu=512,                    # Default is 256
            desired_count=6,            # Default is 1
            task_image_options=ecs_patterns.ApplicationLoadBalancedTaskImageOptions(
                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")),
            memory_limit_mib=2048,      # Default is 512
            public_load_balancer=True)  # Default is True
Java
        Vpc vpc = Vpc.Builder.create(this, "MyVpc")
                            .maxAzs(3)  // Default is all AZs in region
                            .build();

        Cluster cluster = Cluster.Builder.create(this, "MyCluster")
                            .vpc(vpc).build();

        // Create a load-balanced Fargate service and make it public
        ApplicationLoadBalancedFargateService.Builder.create(this, "MyFargateService")
                    .cluster(cluster)           // Required
                    .cpu(512)                   // Default is 256
                     .desiredCount(6)            // Default is 1
                     .taskImageOptions(
                             ApplicationLoadBalancedTaskImageOptions.builder()
                                     .image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample"))
                                     .build())
                     .memoryLimitMiB(2048)       // Default is 512
                     .publicLoadBalancer(true)   // Default is true
                     .build();
C#
            var vpc = new Vpc(this, "MyVpc", new VpcProps
            {
                MaxAzs = 3 // Default is all AZs in region
            });

            var cluster = new Cluster(this, "MyCluster", new ClusterProps
            {
                Vpc = vpc
            });

            // Create a load-balanced Fargate service and make it public
            new ApplicationLoadBalancedFargateService(this, "MyFargateService",
                new ApplicationLoadBalancedFargateServiceProps
                {
                    Cluster = cluster,          // Required
                    DesiredCount = 6,           // Default is 1
                    TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions
                    {
                        Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample")
                    },
                    MemoryLimitMiB = 2048,      // Default is 256
                    PublicLoadBalancer = true   // Default is true
                }
            );
anchoranchoranchoranchoranchor
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });

Successivamente, convalidiamo il nostro codice eseguendo quanto segue per sintetizzare il nostro stack:

cdk synth

Lo stack è composto da centinaia di righe, quindi non lo mostreremo qui. Lo stack deve contenere un'istanza predefinita, una sottorete privata e una sottorete pubblica per le tre zone di disponibilità e un gruppo di sicurezza.

Per distribuire lo stack, eseguiamo quanto segue:

cdk deploy

AWS CloudFormation mostra informazioni sulle dozzine di passaggi necessari per l'implementazione della nostra app.

Una volta completata la distribuzione, abbiamo creato con successo un servizio Amazon ECS basato su Fargate per eseguire un Docker immagine.

Eliminazione

Come best practice di manutenzione generale e per ridurre al minimo i costi non necessari, eliminiamo il nostro stack una volta completato:

cdk destroy

In questa pagina

PrivacyCondizioni del sitoPreferenze cookie
© 2025, Amazon Web Services, Inc. o società affiliate. Tutti i diritti riservati.