Questa è la AWS CDK v2 Developer Guide. 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à.
# Esempio: creazione di un servizio AWS Fargate utilizzando il CDK AWS
In questo esempio, ti mostriamo come creare un servizio AWS Fargate in esecuzione su un cluster Amazon Elastic Container Service (Amazon ECS) gestito da un Application Load Balancer con accesso a Internet da un'immagine su Amazon ECR.
Amazon ECS è un servizio di gestione dei container rapido e altamente scalabile che consente di eseguire, arrestare e gestire container Docker in 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 avete utilizzato la Console di AWS gestione per creare un servizio Fargate, sapete 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:
+ [Come distribuire contenitori Docker - AWS](https://aws.amazon.com/getting-started/tutorials/deploy-docker-containers)
+ [Configurazione con Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/get-set-up-for-amazon-ecs.html)
+ [Guida introduttiva ad Amazon ECS con Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_GetStarted.html)
Questo esempio crea un servizio Fargate simile utilizzando il 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, in cui il AWS CDK applica l'ordine corretto di creazione del 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 il AWS CDK è in grado di 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. Il AWS CDK fornisce un metodo che ci consente di scalare automaticamente le istanze quando utilizziamo un cluster Amazon EC2 . Ciò avviene automaticamente quando utilizziamo un'istanza in un cluster Fargate.
Inoltre, il 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'immagine Docker.
**Importante**
`ApplicationLoadBalancedFargateService`I costrutti che utilizzeremo 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 codice AWS CDK, inclusa la nostra app CDK.
**Example**
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript
```
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language javascript
```
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language python
source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead
pip install -r requirements.txt
```
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language java
```
Ora possiamo importare il progetto Maven nel nostro IDE.
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language csharp
```
Ora possiamo aprire `src/MyEcsConstruct.sln` in Visual Studio.
Successivamente, eseguiamo l'app e confermiamo che crea uno stack vuoto.
```
cdk synth
```
## Creare un servizio Fargate
Esistono due modi diversi per eseguire le 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:*
**Example**
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";
```
Archivio: `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");
```
Archivio: `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)
```
Archivio: `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.*;
```
Archivio: `src/MyEcsConstruct/MyEcsConstructStack.cs`
```
using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECS.Patterns;
```
All'interno del nostro stack, aggiungiamo il seguente codice:
**Example**
```
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
});
```
```
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
});
```
```
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
```
```
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();
```
```
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
}
);
```
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 l'implementazione, abbiamo creato con successo un servizio Amazon ECS basato su Fargate per eseguire un'immagine Docker.
## 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
```