Trabalhe com a biblioteca AWS CDK - AWS Cloud Development Kit (AWS CDK) v2

Este é o Guia do Desenvolvedor AWS CDK v2. A CDK v1 mais antiga entrou em manutenção em 1º de junho de 2022 e encerrou o suporte em 1º de junho de 2023.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Trabalhe com a biblioteca AWS CDK

Importe e use a biblioteca AWS Cloud Development Kit (AWS CDK) para definir sua infraestrutura Nuvem AWS com uma linguagem de programação compatível.

Importar a biblioteca AWS CDK

A biblioteca AWS CDK geralmente é chamada pelo nome do pacote TypeScript de aws-cdk-lib. O nome real do pacote varia de acordo com o idioma. Veja a seguir um exemplo de como instalar e importar a biblioteca CDK:

TypeScript
Instalar npm instale aws-cdk-lib
Import importe * como cdk de 'aws-cdk-lib';
JavaScript
Instalar npm instale aws-cdk-lib
Import const cdk = require('aws-cdk-lib');
Python
Instalar python -m pip instale aws-cdk-lib
Import importe aws_cdk como cdk
Java
Em pom.xml, adicione Group software.amazon.awscdk; artifact aws-cdk-lib
Import importe software.amazon.awscdk.app;
C#
Instalar dotnet adicione pacote Amazon.CDK.Lib
Import usando Amazon.cdk;
Go
Instalar acesse github.com/aws/aws-cdk-go/awscdk/v2
Import
import ( "github.com/aws/aws-cdk-go/awscdk/v2" )

A classe de base construct e o código de suporte estão na biblioteca constructs. Os constructos experimentais, nos quais a API ainda está sendo refinada, são distribuídos como módulos separados.

Uso de referência da API AWS CDK

Use a referência da API AWS CDK ao desenvolver com AWS CDK.

O material de referência de cada módulo é dividido nas seções a seguir.

  • Visão geral: material introdutório que você precisará conhecer para trabalhar com o serviço em AWS CDK, incluindo conceitos e exemplos.

  • Constructos: classes de biblioteca que representam um ou mais recursos AWS concretos. Esses são os recursos ou padrões “selecionados” (L2) (recursos L3) que fornecem uma interface de alto nível com padrões sensatos.

  • Classes: classes de não constructos que fornecem a funcionalidade usada por constructos no módulo.

  • Estruturas: estruturas de dados (pacotes de atributos) que definem a estrutura de valores compostos, como propriedades (o argumento props de constructos) e opções.

  • Interfaces: as interfaces, cujos nomes começam todos com “I”, definem a funcionalidade mínima absoluta para o constructo correspondente ou outra classe. O CDK usa interfaces de constructos para representar recursos AWS definidos fora do seu aplicativo AWS CDK e referenciados por métodos como Bucket.fromBucketArn().

  • Enums: coleções de valores nomeados para uso na especificação de determinados parâmetros de constructos. O uso de um valor enumerado permite que o CDK verifique a validade desses valores durante a síntese.

  • Recursos do CloudFormation: esses constructos L1, cujos nomes começam com “Cfn”, representam exatamente os recursos definidos na especificação do CloudFormation. Eles são gerados automaticamente a partir dessa especificação em cada versão do CDK. Cada constructo L2 ou L3 encapsula um ou mais recursos do CloudFormation.

  • Tipos de propriedades do CloudFormation: o conjunto de valores nomeados que definem as propriedades de cada recurso do CloudFormation.

Interfaces comparadas com classes de constructos

AWS CDK usa interfaces de uma forma específica que pode não ser óbvia, mesmo se você estiver familiarizado com interfaces como um conceito de programação.

AWS CDK suporta o uso de recursos definidos fora dos aplicativos do CDK usando métodos comoBucket.fromBucketArn(). Os recursos externos não podem ser modificados e podem não ter todas as funcionalidades disponíveis com os recursos definidos em seu aplicativo CDK usando, por exemplo, a classe Bucket. As interfaces, então, representam a funcionalidade mínima disponível no CDK para um determinado tipo de recurso AWS, incluindo recursos externos.

Ao instanciar recursos em seu aplicativo CDK, você deve sempre usar classes concretas, como Bucket. Ao especificar o tipo de argumento que você está aceitando em um de seus próprios constructos, use o tipo de interface, como IBucket, se estiver preparado para lidar com recursos externos (ou seja, não precisará alterá-los). Se você precisar de um constructo definido pelo CDK, especifique o tipo mais geral que você pode usar.

Algumas interfaces são versões mínimas de propriedades ou pacotes de opções associados a classes específicas, em vez de constructos. Essas interfaces podem ser úteis na criação de subclasses para aceitar argumentos que você passará para sua classe principal. Se você precisar de uma ou mais propriedades adicionais, convém implementar ou derivar dessa interface ou de um tipo mais específico.

nota

Algumas linguagens de programação suportadas por AWS CDK não têm um atributo de interface. Nessas linguagens, as interfaces são apenas classes comuns. Você pode identificá-las por seus nomes, que seguem o padrão de um “I” inicial seguido pelo nome de algum outro constructo (por exemplo, IBucket). As mesmas regras se aplicam.

Gerenciamento de dependências

As dependências do seu aplicativo ou biblioteca AWS CDK são gerenciadas usando ferramentas de gerenciamento de pacotes. Essas ferramentas são comumente usadas com as linguagens de programação.

Normalmente, AWS CDK suporta a ferramenta de gerenciamento de pacotes padrão ou oficial da linguagem, se houver uma. Caso contrário, o AWS CDK suportará a linguagem mais popular ou amplamente compatível. Você também poderá usar outras ferramentas, especialmente se elas funcionarem com as ferramentas compatíveis. No entanto, o suporte oficial para outras ferramentas é limitado.

AWS CDK é compatível com os seguintes gerenciadores de pacotes:

Idioma Ferramenta de gerenciamento de pacotes compatível
TypeScript/JavaScript NPM (Node Package Manager) ou Yarn
Python PIP (instalador de pacotes para Python)
Java Maven
C# NuGet
Go Módulos Go

Quando você cria um novo projeto usando o comando cdk init da AWS CDK CLI, as dependências das bibliotecas principais e constructos estáveis do CDK são especificadas automaticamente.

Para obter mais informações sobre o gerenciamento de dependências das linguagens de programação compatível, consulte o seguinte:

Comparação de AWS CDK em TypeScript com outras linguagens

O TypeScript foi a primeira linguagem suportada para o desenvolvimento de aplicativos AWS CDK. Portanto, uma quantidade substancial de exemplos de código CDK é escrita em TypeScript. Se você estiver desenvolvendo em outra linguagem, pode ser útil comparar como o código AWS CDK é implementado no TypeScript em comparação com a linguagem de sua escolha. Isso pode ajudá-lo a usar os exemplos em toda a documentação.

Importação de um módulo

TypeScript/JavaScript

O TypeScript suporta a importação de um namespace inteiro ou de objetos individuais de um namespace. Cada namespace inclui constructos e outras classes para uso com um determinado serviço AWS.

// Import main CDK library as cdk import * as cdk from 'aws-cdk-lib'; // ES6 import preferred in TS const cdk = require('aws-cdk-lib'); // Node.js require() preferred in JS // Import specific core CDK classes import { Stack, App } from 'aws-cdk-lib'; const { Stack, App } = require('aws-cdk-lib'); // Import AWS S3 namespace as s3 into current namespace import { aws_s3 as s3 } from 'aws-cdk-lib'; // TypeScript const s3 = require('aws-cdk-lib/aws-s3'); // JavaScript // Having imported cdk already as above, this is also valid const s3 = cdk.aws_s3; // Now use s3 to access the S3 types const bucket = s3.Bucket(...); // Selective import of s3.Bucket import { Bucket } from 'aws-cdk-lib/aws-s3'; // TypeScript const { Bucket } = require('aws-cdk-lib/aws-s3'); // JavaScript // Now use Bucket to instantiate an S3 bucket const bucket = Bucket(...);
Python

Assim como o TypeScript, o Python suporta importações de módulos com namespace e importações seletivas. Os namespaces em Python se parecem com aws_cdk.xxx, em que xxx representa um nome de serviço da AWS, como s3 para Amazon S3. (Amazon S3 é usado nesses exemplos).

# Import main CDK library as cdk import aws_cdk as cdk # Selective import of specific core classes from aws_cdk import Stack, App # Import entire module as s3 into current namespace import aws_cdk.aws_s3 as s3 # s3 can now be used to access classes it contains bucket = s3.Bucket(...) # Selective import of s3.Bucket into current namespace from aws_cdk.s3 import Bucket # Bucket can now be used to instantiate a bucket bucket = Bucket(...)
Java

As importações do Java funcionam de forma diferente das do TypeScript. Cada instrução de importação importa um único nome de classe de um determinado pacote ou todas as classes definidas nesse pacote (usando *). As classes podem ser acessadas usando o nome da classe por si só, se tiver sido importada, ou o nome da classe qualificada, incluindo seu pacote.

As bibliotecas têm o mesmo de software.amazon.awscdk.services.xxx para a Biblioteca de Constructos da AWS (a biblioteca principal é software.amazon.awscdk). O ID do grupo Maven para pacotes AWS CDK é software.amazon.awscdk.

// Make certain core classes available import software.amazon.awscdk.Stack; import software.amazon.awscdk.App; // Make all Amazon S3 construct library classes available import software.amazon.awscdk.services.s3.*; // Make only Bucket and EventType classes available import software.amazon.awscdk.services.s3.Bucket; import software.amazon.awscdk.services.s3.EventType; // An imported class may now be accessed using the simple class name (assuming that name // does not conflict with another class) Bucket bucket = Bucket.Builder.create(...).build(); // We can always use the qualified name of a class (including its package) even without an // import directive software.amazon.awscdk.services.s3.Bucket bucket = software.amazon.awscdk.services.s3.Bucket.Builder.create(...) .build(); // Java 10 or later can use var keyword to avoid typing the type twice var bucket = software.amazon.awscdk.services.s3.Bucket.Builder.create(...) .build();
C#

Em C#, você importa tipos com a diretiva using. Há dois estilos. Um fornece acesso a todos os tipos no namespace especificado usando seus nomes simples. Com o outro, você pode se referir ao próprio namespace usando um alias.

Os pacotes são nomeados da mesma forma que Amazon.CDK.AWS.xxx para os pacotes da Biblioteca de Constructos da AWS. (O módulo principal é Amazon.CDK.)

// Make CDK base classes available under cdk using cdk = Amazon.CDK; // Make all Amazon S3 construct library classes available using Amazon.CDK.AWS.S3; // Now we can access any S3 type using its name var bucket = new Bucket(...); // Import the S3 namespace under an alias using s3 = Amazon.CDK.AWS.S3; // Now we can access an S3 type through the namespace alias var bucket = new s3.Bucket(...); // We can always use the qualified name of a type (including its namespace) even without a // using directive var bucket = new Amazon.CDK.AWS.S3.Bucket(...)
Go

Cada módulo da Biblioteca de Constructos da AWS é fornecido como um pacote Go.

import ( "github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package "github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module ) // now instantiate a bucket bucket := awss3.NewBucket(...) // use aliases for brevity/clarity import ( cdk "github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module ) bucket := s3.NewBucket(...)

Criação da instância de uma estrutura

As classes de constructos AWS CDK têm o mesmo nome em todas as linguagens compatíveis. A maioria das linguagens usa a palavra-chave new para instanciar uma classe (Python e Go não). Além disso, na maioria das linguagens, a palavra-chave this se refere à instância atual. (Python usa self por convenção.) Você deve passar uma referência à instância atual como parâmetro scope para cada constructo criado.

O terceiro argumento para um constructo AWS CDK é props, um objeto contendo os atributos necessários para construir o constructo. Esse argumento pode ser opcional, mas quando necessário, as linguagens suportadas o tratam de forma idiomática. Os nomes dos atributos também são adaptados aos padrões de nomenclatura padrão da linguagem.

TypeScript/JavaScript
// Instantiate default Bucket const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket'); // Instantiate Bucket with bucketName and versioned properties const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', { bucketName: 'amzn-s3-demo-bucket', versioned: true, }); // Instantiate Bucket with websiteRedirect, which has its own sub-properties const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', { websiteRedirect: {host: 'aws.amazon.com'}});
Python

Python não usa uma palavra-chave new ao instanciar uma classe. O argumento de propriedades é representado usando argumentos de palavra-chave e os argumentos são nomeados usando snake_case.

Se um valor de props for em si um pacote de atributos, será representado por uma classe com o nome da propriedade, que aceita argumentos de palavra-chave para as subpropriedades.

Em Python, a instância atual é passada para os métodos como o primeiro argumento, que é nomeado self por convenção.

# Instantiate default Bucket bucket = s3.Bucket(self, "amzn-s3-demo-bucket") # Instantiate Bucket with bucket_name and versioned properties bucket = s3.Bucket(self, "amzn-s3-demo-bucket", bucket_name="amzn-s3-demo-bucket", versioned=true) # Instantiate Bucket with website_redirect, which has its own sub-properties bucket = s3.Bucket(self, "amzn-s3-demo-bucket", website_redirect=s3.WebsiteRedirect( host_name="aws.amazon.com"))
Java

Em Java, o argumento props é representado por uma classe chamada XxxxProps (por exemplo, BucketProps para as props de constructos Bucket). Você constrói o argumento props usando um padrão de construtor.

Cada classe XxxxProps tem um construtor. Também existe um construtor conveniente para cada constructo que constrói os props e o constructo em uma única etapa, conforme mostrado no exemplo a seguir.

Props são nomeados da mesma forma que no TypeScript, usando camelCase.

// Instantiate default Bucket Bucket bucket = Bucket(self, "amzn-s3-demo-bucket"); // Instantiate Bucket with bucketName and versioned properties Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket") .bucketName("amzn-s3-demo-bucket").versioned(true) .build(); # Instantiate Bucket with websiteRedirect, which has its own sub-properties Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket") .websiteRedirect(new websiteRedirect.Builder() .hostName("aws.amazon.com").build()) .build();
C#

Em C#, os props são especificados usando um inicializador de objeto para uma classe chamada XxxxProps (por exemplo, BucketProps para props do constructo Bucket).

Os props são nomeados de forma semelhante ao TypeScript, exceto usando PascalCase.

É conveniente usar a palavra-chave var ao instanciar um constructo, para que você não precise digitar o nome da classe duas vezes. No entanto, seu guia de estilo de código local pode variar.

// Instantiate default Bucket var bucket = Bucket(self, "amzn-s3-demo-bucket"); // Instantiate Bucket with BucketName and Versioned properties var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps { BucketName = "amzn-s3-demo-bucket", Versioned = true}); // Instantiate Bucket with WebsiteRedirect, which has its own sub-properties var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps { WebsiteRedirect = new WebsiteRedirect { HostName = "aws.amazon.com" }});
Go

Para criar um constructo em Go, chame a função NewXxxxxx em que Xxxxxxx é o nome do constructo. As propriedades dos constructos são definidas como uma estrutura.

Em Go, todos os parâmetros de constructos são ponteiros, incluindo valores como números, booleanos e cadeias de caracteres. Use as funções de conveniência, como jsii.String para criar esses ponteiros.

// Instantiate default Bucket bucket := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), nil) // Instantiate Bucket with BucketName and Versioned properties bucket1 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{ BucketName: jsii.String("amzn-s3-demo-bucket"), Versioned: jsii.Bool(true), }) // Instantiate Bucket with WebsiteRedirect, which has its own sub-properties bucket2 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{ WebsiteRedirect: &awss3.RedirectTarget{ HostName: jsii.String("aws.amazon.com"), }})

Acesso a membros

É comum se referir a atributos ou propriedades de constructos e outras classes AWS CDK e usar esses valores como, por exemplo, entradas para criar outros constructos. As diferenças de nomenclatura descritas anteriormente para os métodos também se aplicam aqui. Além disso, em Java, não é possível acessar os membros diretamente. Em vez disso, um método getter é fornecido.

TypeScript/JavaScript

Os nomes são camelCase.

bucket.bucketArn
Python

Os nomes são snake_case.

bucket.bucket_arn
Java

Um método getter é fornecido para cada propriedade; esses nomes são camelCase.

bucket.getBucketArn()
C#

Os nomes são PascalCase.

bucket.BucketArn
Go

Os nomes são PascalCase.

bucket.BucketArn

Constantes Enum

As constantes Enum têm como escopo uma classe e têm nomes em maiúsculas com sublinhados em todos os idiomas (às vezes chamadas de SCREAMING_SNAKE_CASE). Como os nomes das classes também usam a mesma letra maiúscula em todos os idiomas suportados, exceto Go, os nomes de enumeração qualificados também são os mesmos nesses idiomas.

s3.BucketEncryption.KMS_MANAGED

Em Go, as constantes enum são atributos do namespace do módulo e são escritas da seguinte forma.

awss3.BucketEncryption_KMS_MANAGED

Interfaces de objetos

AWS CDK usa interfaces de objetos TypeScript para indicar que uma classe implementa um conjunto esperado de métodos e propriedades. Você pode reconhecer uma interface de objeto porque seu nome começa com I. Uma classe concreta indica as interfaces que ela implementa usando a palavra-chave implements.

TypeScript/JavaScript
nota

O JavaScript não tem um atributo de interface. Você pode ignorar a palavra-chave implements e os nomes das classes que a seguem.

import { IAspect, IConstruct } from 'aws-cdk-lib'; class MyAspect implements IAspect { public visit(node: IConstruct) { console.log('Visited', node.node.path); } }
Python

O Python não tem um atributo de interface. No entanto, para AWS CDK, você pode indicar a implementação da interface decorando sua classe com @jsii.implements(interface).

from aws_cdk import IAspect, IConstruct import jsii @jsii.implements(IAspect) class MyAspect(): def visit(self, node: IConstruct) -> None: print("Visited", node.node.path)
Java
import software.amazon.awscdk.IAspect; import software.amazon.awscdk.IConstruct; public class MyAspect implements IAspect { public void visit(IConstruct node) { System.out.format("Visited %s", node.getNode().getPath()); } }
C#
using Amazon.CDK; public class MyAspect : IAspect { public void Visit(IConstruct node) { System.Console.WriteLine($"Visited ${node.Node.Path}"); } }
Go

As estruturas Go não precisam declarar explicitamente quais interfaces elas implementam. O compilador Go determina a implementação com base nos métodos e propriedades disponíveis na estrutura. Por exemplo, no código a seguir, MyAspect implementa a interface IAspect porque ela fornece um método Visit que usa um constructo.

type MyAspect struct { } func (a MyAspect) Visit(node constructs.IConstruct) { fmt.Println("Visited", *node.Node().Path()) }