Importe e use construções Níveis de construção Definindo construções Trabalhando com construções Trabalhando com construções de terceiros Saiba mais

AWS CDK Construções

As construções são os blocos de construção básicos dos AWS Cloud Development Kit (AWS CDK) aplicativos. Uma construção é um componente em seu aplicativo que representa um ou mais AWS CloudFormation recursos e sua configuração. Você constrói seu aplicativo, peça por peça, importando e configurando construções.

Importe e use construções

Construções são classes que você importa para seus CDK aplicativos da AWS Construct Library. Você também pode criar e distribuir suas próprias construções ou usar construções criadas por desenvolvedores terceirizados.

As construções fazem parte do Construct Programming Model (CPM). Eles estão disponíveis para uso com outras ferramentas, como CDK para Terraform (CDKtf), CDK para Kubernetes (CDK8s), e Projen.

Vários terceiros também publicaram construções compatíveis com o. AWS CDK Visite o Construct Hub para explorar o ecossistema do AWS CDK Construct Partner.

Níveis de construção

As construções da AWS Construct Library são categorizadas em três níveis. Cada nível oferece um nível crescente de abstração. Quanto maior a abstração, mais fácil de configurar, exigindo menos experiência. Quanto menor a abstração, mais personalização está disponível, exigindo mais experiência.

Construções de nível 1 (L1)

As construções L1, também conhecidas como CFNrecursos, são as construções de nível mais baixo e não oferecem abstração. Cada construção L1 é mapeada diretamente para um único AWS CloudFormation recurso. Com construções L1, você importa uma construção que representa um recurso específico AWS CloudFormation . Em seguida, você define as propriedades do recurso em sua instância de construção.

As construções L1 são ótimas para usar quando você está familiarizado AWS CloudFormation e precisa de controle total sobre a definição das propriedades de seus AWS recursos.

Na AWS Construct Library, as construções L1 são nomeadas começando comCfn, seguidas por um identificador para o AWS CloudFormation recurso que elas representam. Por exemplo, a CfnBucket construção é uma construção L1 que representa um AWS::S3::Bucket AWS CloudFormation recurso.

As construções L1 são geradas a partir da especificação do AWS CloudFormation recurso. Se um recurso existir em AWS CloudFormation, ele estará disponível no AWS CDK como uma construção L1. Novos recursos ou propriedades podem levar até uma semana para serem disponibilizados na AWS Construct Library. Para obter mais informações, consulte a referência de tipos de AWS recursos e propriedades no Guia AWS CloudFormation do usuário.

Construções de nível 2 (L2)

As construções L2, também conhecidas como construções curadas, são cuidadosamente desenvolvidas pela CDK equipe e geralmente são o tipo de construção mais amplamente usado. As construções L2 são mapeadas diretamente para AWS CloudFormation recursos individuais, semelhantes às construções L1. Em comparação com as construções L1, as construções L2 fornecem uma abstração de alto nível por meio de uma intuição baseada em intenção. API As construções L2 incluem configurações de propriedades padrão sensatas, políticas de segurança de melhores práticas e geram muito código padronizado e lógica de cola para você.

As construções L2 também fornecem métodos auxiliares para a maioria dos recursos que simplificam e agilizam a definição de propriedades, permissões, interações baseadas em eventos entre recursos e muito mais.

A s3.Bucket classe é um exemplo de uma construção L2 para um recurso de bucket do Amazon Simple Storage Service (Amazon S3).

A AWS Construct Library contém construções L2 que são designadas como estáveis e prontas para uso em produção. Para construções L2 em desenvolvimento, elas são designadas como experimentais e oferecidas em um módulo separado.

Construções de nível 3 (L3)

As construções L3, também conhecidas como padrões, são o nível mais alto de abstração. Cada construção L3 pode conter uma coleção de recursos que são configurados para trabalhar juntos para realizar uma tarefa ou serviço específico em seu aplicativo. As construções L3 são usadas para criar AWS arquiteturas inteiras para casos de uso específicos em seu aplicativo.

Para fornecer projetos de sistema completos ou partes substanciais de um sistema maior, as construções L3 oferecem configurações de propriedades padrão opinativas. Eles são construídos em torno de uma abordagem específica para resolver um problema e fornecer uma solução. Com construções L3, você pode criar e configurar vários recursos rapidamente, com a menor quantidade de entrada e código.

A ecsPatterns.ApplicationLoadBalancedFargateService classe é um exemplo de uma construção L3 que representa um AWS Fargate serviço executado em um cluster do Amazon Elastic Container Service (AmazonECS) e liderado por um balanceador de carga de aplicativos.

Semelhantes às construções L2, as construções L3 que estão prontas para uso em produção estão incluídas na Construct Library. AWS Os que estão em desenvolvimento são oferecidos em módulos separados.

Definindo construções

Composição

A composição é o padrão chave para definir abstrações de alto nível por meio de construções. Uma construção de alto nível pode ser composta a partir de qualquer número de construções de nível inferior. De uma perspectiva de baixo para cima, você usa construções para organizar os AWS recursos individuais que deseja implantar. Você usa quaisquer abstrações que sejam convenientes para seu propósito, com quantos níveis você precisar.

Com a composição, você define componentes reutilizáveis e os compartilha como qualquer outro código. Por exemplo, uma equipe pode definir uma construção que implemente as melhores práticas da empresa para uma tabela do Amazon DynamoDB, incluindo backup, replicação global, escalabilidade automática e monitoramento. A equipe pode compartilhar a construção internamente com outras equipes ou publicamente.

As equipes podem usar construções como qualquer outro pacote de biblioteca. Quando a biblioteca é atualizada, os desenvolvedores têm acesso às melhorias e correções de erros da nova versão, de forma semelhante a qualquer outra biblioteca de código.

Inicialização

As estruturas são implementadas em classes que estendem a classe base Construct. Você define uma construção instanciando a classe. Todas as estruturas usam três parâmetros ao serem inicializadas:

escopo — O pai ou proprietário da construção. Isso pode ser uma pilha ou outra construção. O escopo determina o lugar da construção na árvore de construção. Você geralmente deve passar this (selfem Python), que representa o objeto atual, para o escopo.
id — Um identificador que deve ser exclusivo dentro do escopo. O identificador serve como um namespace para tudo o que está definido na construção. É usado para gerar identificadores exclusivos, como nomes de recursos e AWS CloudFormation lógicosIDs.

Os identificadores só precisam ser exclusivos dentro de um escopo. Isso permite que você instancie e reutilize construções sem se preocupar com as construções e identificadores que elas possam conter, além de permitir a composição de construções em abstrações de alto nível. Além disso, os escopos possibilitam a referência a grupos de construções de uma só vez. Os exemplos incluem a marcação ou a especificação de onde as construções serão implantadas.
props — Um conjunto de propriedades ou argumentos de palavras-chave, dependendo da linguagem, que definem a configuração inicial da construção. Construções de nível superior fornecem mais padrões e, se todos os elementos prop forem opcionais, você poderá omitir completamente o parâmetro props.

Configuração

A maioria das construções aceita props como terceiro argumento (ou, em Python, argumentos de palavra-chave), uma coleção de nome/valor que define a configuração da construção. O exemplo a seguir define um bucket com criptografia AWS Key Management Service (AWS KMS) e hospedagem estática de sites ativadas. Como não especifica explicitamente uma chave de criptografia, a Bucket construção define uma nova kms.Key e a associa ao bucket.

Interagindo com construções

Construções são classes que estendem a classe Construct base. Depois de instanciar uma construção, o objeto de construção expõe um conjunto de métodos e propriedades que permitem que você interaja com a construção e a transmita como referência para outras partes do sistema.

A AWS CDK estrutura não impõe nenhuma restrição às APIs construções. Os autores podem definir o API que quiserem. No entanto, as AWS construções incluídas na AWS Construct Library, por exemplos3.Bucket, seguem diretrizes e padrões comuns. Isso proporciona uma experiência consistente em todos os AWS recursos.

A maioria das AWS construções tem um conjunto de métodos de concessão que você pode usar para conceder permissões AWS Identity and Access Management (IAM) nessa construção a um diretor. O exemplo a seguir concede ao IAM grupo data-science permissão para ler do bucket do Amazon S3. raw-data

Outro padrão comum é que AWS as construções definam um dos atributos do recurso a partir de dados fornecidos em outro lugar. Os atributos podem incluir nomes de recursos da Amazon (ARNs), nomes ouURLs.

O código a seguir define uma AWS Lambda função e a associa a uma fila do Amazon Simple Queue Service SQS (Amazon) por meio da fila URL em uma variável de ambiente.

TypeScript


const jobsQueue = new sqs.Queue(this, 'jobs');
const createJobLambda = new lambda.Function(this, 'create-job', {
  runtime: lambda.Runtime.NODEJS_18_X,
  handler: 'index.handler',
  code: lambda.Code.fromAsset('./create-job-lambda-code'),
  environment: {
    QUEUE_URL: jobsQueue.queueUrl
  }
});

JavaScript


const jobsQueue = new sqs.Queue(this, 'jobs');
const createJobLambda = new lambda.Function(this, 'create-job', {
  runtime: lambda.Runtime.NODEJS_18_X,
  handler: 'index.handler',
  code: lambda.Code.fromAsset('./create-job-lambda-code'),
  environment: {
    QUEUE_URL: jobsQueue.queueUrl
  }
});

Python


jobs_queue = sqs.Queue(self, "jobs")
create_job_lambda = lambda_.Function(self, "create-job",
    runtime=lambda_.Runtime.NODEJS_18_X,
    handler="index.handler",
    code=lambda_.Code.from_asset("./create-job-lambda-code"),
    environment=dict(
        QUEUE_URL=jobs_queue.queue_url
    )
)

Java


final Queue jobsQueue = new Queue(this, "jobs");
Function createJobLambda = Function.Builder.create(this, "create-job")
                .handler("index.handler")
                .code(Code.fromAsset("./create-job-lambda-code"))
                .environment(java.util.Map.of(   // Map.of is Java 9 or later
                    "QUEUE_URL", jobsQueue.getQueueUrl())
                .build();

C#


var jobsQueue = new Queue(this, "jobs");
var createJobLambda = new Function(this, "create-job", new FunctionProps
{
    Runtime = Runtime.NODEJS_18_X,
    Handler = "index.handler",
    Code = Code.FromAsset(@".\create-job-lambda-code"),
    Environment = new Dictionary<string, string>
    {
        ["QUEUE_URL"] = jobsQueue.QueueUrl
    }
});

Go


	createJobLambda := awslambda.NewFunction(stack, jsii.String("create-job"), &awslambda.FunctionProps{
		Runtime: awslambda.Runtime_NODEJS_18_X(),
		Handler: jsii.String("index.handler"),
		Code:    awslambda.Code_FromAsset(jsii.String(".\\create-job-lambda-code"), nil),
		Environment: &map[string]*string{
			"QUEUE_URL": jsii.String(*jobsQueue.QueueUrl()),
		},
	})

Para obter informações sobre os API padrões mais comuns na AWS Construct Library, consulteRecursos e o AWS CDK.

A construção do aplicativo e da pilha

As Stack classes App e da AWS Construct Library são construções exclusivas. Em comparação com outras construções, elas não configuram AWS recursos sozinhas. Em vez disso, eles são usados para fornecer contexto para suas outras construções. Todas as construções que representam AWS recursos devem ser definidas, direta ou indiretamente, dentro do escopo de uma Stack construção. Stackconstruções são definidas dentro do escopo de uma App construção.

Para saber mais sobre CDK aplicativos, consulteAWS CDK aplicativos. Para saber mais sobre CDK pilhas, consulteAWS CDK pilhas.

O exemplo a seguir define um aplicativo com uma única pilha. Dentro da pilha, uma construção L2 é usada para configurar um recurso de bucket do Amazon S3.

TypeScript


import { App, Stack, StackProps } from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';

class HelloCdkStack extends Stack {
  constructor(scope: App, id: string, props?: StackProps) {
    super(scope, id, props);

    new s3.Bucket(this, 'MyFirstBucket', {
      versioned: true
    });
  }
}

const app = new App();
new HelloCdkStack(app, "HelloCdkStack");

JavaScript


const { App , Stack } = require('aws-cdk-lib');
const s3 = require('aws-cdk-lib/aws-s3');

class HelloCdkStack extends Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    new s3.Bucket(this, 'MyFirstBucket', {
      versioned: true
    });
  }
}

const app = new App();
new HelloCdkStack(app, "HelloCdkStack");

Python


from aws_cdk import App, Stack
import aws_cdk.aws_s3 as s3
from constructs import Construct

class HelloCdkStack(Stack):

    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        s3.Bucket(self, "MyFirstBucket", versioned=True)

app = App()
HelloCdkStack(app, "HelloCdkStack")

Java

Pilha definida no HelloCdkStack.java arquivo:


import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.services.s3.*;

public class HelloCdkStack extends Stack {
    public HelloCdkStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        Bucket.Builder.create(this, "MyFirstBucket")
            .versioned(true).build();
    }
}

Aplicativo definido no HelloCdkApp.java arquivo:


import software.amazon.awscdk.App;
import software.amazon.awscdk.StackProps;

public class HelloCdkApp {
    public static void main(final String[] args) {
        App app = new App();

        new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
                .build());

        app.synth();
    }
}

C#


using Amazon.CDK;
using Amazon.CDK.AWS.S3;

namespace HelloCdkApp
{
    internal static class Program
    {
        public static void Main(string[] args)
        {
            var app = new App();
            new HelloCdkStack(app, "HelloCdkStack");
            app.Synth();
        }
    }
    
    public class HelloCdkStack : Stack
    {
        public HelloCdkStack(Construct scope, string id, IStackProps props=null) : base(scope, id, props)
        {
            new Bucket(this, "MyFirstBucket", new BucketProps { Versioned = true });
        }
    }
}

Go


func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	stack := awscdk.NewStack(scope, &id, &sprops)

	awss3.NewBucket(stack, jsii.String("MyFirstBucket"), &awss3.BucketProps{
		Versioned: jsii.Bool(true),
	})

	return stack
}

Trabalhando com construções

Trabalhando com construções L1

L1 constrói mapas diretamente para recursos individuais AWS CloudFormation . Você deve fornecer a configuração necessária do recurso.

Neste exemplo, criamos um bucket objeto usando a construção CfnBucket L1:

Propriedades de construção que não são simples booleanos, cadeias de caracteres, números ou contêineres são tratadas de forma diferente nas linguagens suportadas.

TypeScript


const bucket = new s3.CfnBucket(this, "amzn-s3-demo-bucket", {
  bucketName: "amzn-s3-demo-bucket",
  corsConfiguration: {
    corsRules: [{
          allowedOrigins: ["*"],
          allowedMethods: ["GET"]
    }]
  }
});

JavaScript


const bucket = new s3.CfnBucket(this, "amzn-s3-demo-bucket", {
  bucketName: "amzn-s3-demo-bucket",
  corsConfiguration: {
    corsRules: [{
          allowedOrigins: ["*"],
          allowedMethods: ["GET"]
    }]
  }
});

Python

Em Python, essas propriedades são representadas por tipos definidos como classes internas da construção L1. Por exemplo, a propriedade opcional cors_configuration de a CfnBucket requer um invólucro do tipoCfnBucket.CorsConfigurationProperty. Aqui estamos definindo cors_configuration em uma CfnBucket instância.


bucket = CfnBucket(self, "amzn-s3-demo-bucket", bucket_name="amzn-s3-demo-bucket",
    cors_configuration=CfnBucket.CorsConfigurationProperty(
        cors_rules=[CfnBucket.CorsRuleProperty(
            allowed_origins=["*"],
            allowed_methods=["GET"]
        )]
    )
)

Java

Em Java, essas propriedades são representadas por tipos definidos como classes internas da construção L1. Por exemplo, a propriedade opcional corsConfiguration de a CfnBucket requer um invólucro do tipoCfnBucket.CorsConfigurationProperty. Aqui estamos definindo corsConfiguration em uma CfnBucket instância.


CfnBucket bucket = CfnBucket.Builder.create(this, "amzn-s3-demo-bucket")
                        .bucketName("amzn-s3-demo-bucket")
                        .corsConfiguration(new CfnBucket.CorsConfigurationProperty.Builder()
                            .corsRules(Arrays.asList(new CfnBucket.CorsRuleProperty.Builder()
                                .allowedOrigins(Arrays.asList("*"))
                                .allowedMethods(Arrays.asList("GET"))
                                .build()))
                            .build())
                        .build();

C#

Em C#, essas propriedades são representadas por tipos definidos como classes internas da construção L1. Por exemplo, a propriedade opcional CorsConfiguration de a CfnBucket requer um invólucro do tipoCfnBucket.CorsConfigurationProperty. Aqui estamos definindo CorsConfiguration em uma CfnBucket instância.


var bucket = new CfnBucket(this, "amzn-s3-demo-bucket", new CfnBucketProps
{
    BucketName = "amzn-s3-demo-bucket",
    CorsConfiguration = new CfnBucket.CorsConfigurationProperty
    {
        CorsRules = new object[] {
            new CfnBucket.CorsRuleProperty
            {
                AllowedOrigins = new string[] { "*" },
                AllowedMethods = new string[] { "GET" },
            }
        }
    }
});

Go

Em Go, esses tipos são nomeados usando o nome da construção L1, um sublinhado e o nome da propriedade. Por exemplo, a propriedade opcional CorsConfiguration de a CfnBucket requer um invólucro do tipoCfnBucket_CorsConfigurationProperty. Aqui estamos definindo CorsConfiguration em uma CfnBucket instância.


	awss3.NewCfnBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.CfnBucketProps{
		BucketName: jsii.String("amzn-s3-demo-bucket"),
		CorsConfiguration: &awss3.CfnBucket_CorsConfigurationProperty{
			CorsRules: []awss3.CorsRule{
				awss3.CorsRule{
					AllowedOrigins: jsii.Strings("*"),
					AllowedMethods: &[]awss3.HttpMethods{"GET"},
				},
			},
		},
	})

Importante

Você não pode usar tipos de propriedade L2 com construções L1 ou vice-versa. Ao trabalhar com construções L1, sempre use os tipos definidos para a construção L1 que você está usando. Não use tipos de outras construções L1 (algumas podem ter o mesmo nome, mas não são do mesmo tipo).

Algumas de nossas API referências específicas de linguagem atualmente têm erros nos caminhos para os tipos de propriedades L1 ou não documentam essas classes. Esperamos corrigir isso em breve. Enquanto isso, lembre-se de que esses tipos são sempre classes internas da construção L1 com a qual são usados.

Trabalhando com construções L2

No exemplo a seguir, definimos um bucket do Amazon S3 criando um objeto a partir da construção BucketL2:

MyFirstBucketnão é o nome do bucket que AWS CloudFormation cria. É um identificador lógico fornecido à nova construção no contexto do seu CDK aplicativo. O physicalNamevalor será usado para nomear o AWS CloudFormation recurso.

Trabalhando com construções de terceiros

O Construct Hub é um recurso para ajudá-lo a descobrir construções adicionais de AWS terceiros e da comunidade de código abertoCDK.

Escrevendo suas próprias construções

Além de usar construções existentes, você também pode escrever suas próprias construções e permitir que qualquer pessoa as use em seus aplicativos. Todas as construções são iguais no AWS CDK. As construções da AWS Construct Library são tratadas da mesma forma que uma construção de uma biblioteca de terceiros publicada via NPM, Maven, ou PyPI. As construções publicadas no repositório interno de pacotes da sua empresa também são tratadas da mesma forma.

Para declarar uma nova construção, crie uma classe que estenda a classe base Construct no constructs pacote e siga o padrão dos argumentos do inicializador.

O exemplo a seguir mostra como declarar uma construção que representa um bucket do Amazon S3. O bucket do S3 envia uma notificação do Amazon Simple Notification Service (AmazonSNS) toda vez que alguém carrega um arquivo nele.

TypeScript


export interface NotifyingBucketProps {
  prefix?: string;
}

export class NotifyingBucket extends Construct {
  constructor(scope: Construct, id: string, props: NotifyingBucketProps = {}) {
    super(scope, id);
    const bucket = new s3.Bucket(this, 'bucket');
    const topic = new sns.Topic(this, 'topic');
    bucket.addObjectCreatedNotification(new s3notify.SnsDestination(topic),
      { prefix: props.prefix });
  }
}

JavaScript


class NotifyingBucket extends Construct {
  constructor(scope, id, props = {}) {
    super(scope, id);
    const bucket = new s3.Bucket(this, 'bucket');
    const topic = new sns.Topic(this, 'topic');
    bucket.addObjectCreatedNotification(new s3notify.SnsDestination(topic),
      { prefix: props.prefix });
  }
}

module.exports = { NotifyingBucket }

Python


class NotifyingBucket(Construct):

    def __init__(self, scope: Construct, id: str, *, prefix=None):
        super().__init__(scope, id)
        bucket = s3.Bucket(self, "bucket")
        topic = sns.Topic(self, "topic")
        bucket.add_object_created_notification(s3notify.SnsDestination(topic),
            s3.NotificationKeyFilter(prefix=prefix))

Java


public class NotifyingBucket extends Construct {

    public NotifyingBucket(final Construct scope, final String id) {
        this(scope, id, null, null);
    }
    
    public NotifyingBucket(final Construct scope, final String id, final BucketProps props) {
        this(scope, id, props, null);
    }
    
    public NotifyingBucket(final Construct scope, final String id, final String prefix) {
        this(scope, id, null, prefix);
    }

    public NotifyingBucket(final Construct scope, final String id, final BucketProps props, final String prefix) {
        super(scope, id);

        Bucket bucket = new Bucket(this, "bucket");
        Topic topic = new Topic(this, "topic");
        if (prefix != null)
            bucket.addObjectCreatedNotification(new SnsDestination(topic),
                NotificationKeyFilter.builder().prefix(prefix).build());
     }
}

C#


public class NotifyingBucketProps : BucketProps
{
    public string Prefix { get; set; }
}

public class NotifyingBucket : Construct
{
    public NotifyingBucket(Construct scope, string id, NotifyingBucketProps props = null) : base(scope, id)
    {
        var bucket = new Bucket(this, "bucket");
        var topic = new Topic(this, "topic");
        bucket.AddObjectCreatedNotification(new SnsDestination(topic), new NotificationKeyFilter
        {
            Prefix = props?.Prefix
        });
    }
}

Go


type NotifyingBucketProps struct {
	awss3.BucketProps
	Prefix *string
}

func NewNotifyingBucket(scope constructs.Construct, id *string, props *NotifyingBucketProps) awss3.Bucket {
	var bucket awss3.Bucket
	if props == nil {
		bucket = awss3.NewBucket(scope, jsii.String(*id+"Bucket"), nil)
	} else {
		bucket = awss3.NewBucket(scope, jsii.String(*id+"Bucket"), &props.BucketProps)
	}
	topic := awssns.NewTopic(scope, jsii.String(*id+"Topic"), nil)
	if props == nil {
		bucket.AddObjectCreatedNotification(awss3notifications.NewSnsDestination(topic))
	} else {
		bucket.AddObjectCreatedNotification(awss3notifications.NewSnsDestination(topic), &awss3.NotificationKeyFilter{
			Prefix: props.Prefix,
		})
	}
	return bucket
}

nota

Nossa NotifyingBucket construção herda não deBucket, mas sim deConstruct. Estamos usando composição, não herança, para agrupar um bucket do Amazon S3 e um tópico da Amazon. SNS Em geral, a composição é preferida à herança ao desenvolver AWS CDK construções.

O NotifyingBucket construtor tem uma assinatura de construção típica: scopeid, e. props O último argumento,props, é opcional (obtém o valor padrão{}) porque todos os adereços são opcionais. (A Construct classe base não aceita props argumentos.) Você pode definir uma instância dessa construção em seu aplicativo semprops, por exemplo:

Ou você pode usar props (em Java, um parâmetro adicional) para especificar o prefixo do caminho a ser filtrado, por exemplo:

Normalmente, você também gostaria de expor algumas propriedades ou métodos em suas construções. Não é muito útil ter um tópico escondido atrás de sua construção, porque os usuários de sua construção não conseguem se inscrever nela. Adicionar uma topic propriedade permite que os consumidores acessem o tópico interno, conforme mostrado no exemplo a seguir:

TypeScript


export class NotifyingBucket extends Construct {
  public readonly topic: sns.Topic;

  constructor(scope: Construct, id: string, props: NotifyingBucketProps) {
    super(scope, id);
    const bucket = new s3.Bucket(this, 'bucket');
    this.topic = new sns.Topic(this, 'topic');
    bucket.addObjectCreatedNotification(new s3notify.SnsDestination(this.topic), { prefix: props.prefix });
  }
}

JavaScript


class NotifyingBucket extends Construct {

  constructor(scope, id, props) {
    super(scope, id);
    const bucket = new s3.Bucket(this, 'bucket');
    this.topic = new sns.Topic(this, 'topic');
    bucket.addObjectCreatedNotification(new s3notify.SnsDestination(this.topic), { prefix: props.prefix });
  }
}

module.exports = { NotifyingBucket };

Python


class NotifyingBucket(Construct):

    def __init__(self, scope: Construct, id: str, *, prefix=None, **kwargs):
        super().__init__(scope, id)
        bucket = s3.Bucket(self, "bucket")
        self.topic = sns.Topic(self, "topic")
        bucket.add_object_created_notification(s3notify.SnsDestination(self.topic),
            s3.NotificationKeyFilter(prefix=prefix))

Java


public class NotifyingBucket extends Construct {

    public Topic topic = null;
    
    public NotifyingBucket(final Construct scope, final String id) {
        this(scope, id, null, null);
    }
    
    public NotifyingBucket(final Construct scope, final String id, final BucketProps props) {
        this(scope, id, props, null);
    }
    
    public NotifyingBucket(final Construct scope, final String id, final String prefix) {
        this(scope, id, null, prefix);
    }

    public NotifyingBucket(final Construct scope, final String id, final BucketProps props, final String prefix) {
        super(scope, id);

        Bucket bucket = new Bucket(this, "bucket");
        topic = new Topic(this, "topic");
        if (prefix != null)
            bucket.addObjectCreatedNotification(new SnsDestination(topic),
                NotificationKeyFilter.builder().prefix(prefix).build());
     }
}

C#


public class NotifyingBucket : Construct
{
    public readonly Topic topic;

    public NotifyingBucket(Construct scope, string id, NotifyingBucketProps props = null) : base(scope, id)
    {
        var bucket = new Bucket(this, "bucket");
        topic = new Topic(this, "topic");
        bucket.AddObjectCreatedNotification(new SnsDestination(topic), new NotificationKeyFilter
        {
            Prefix = props?.Prefix
        });
    }
}

Go

Para fazer isso em Go, precisaremos de um pouco mais de encanamento. Nossa NewNotifyingBucket função original retornou umawss3.Bucket. Precisaremos estender Bucket para incluir um topic membro criando uma NotifyingBucket estrutura. Nossa função então retornará esse tipo.


type NotifyingBucket struct {
	awss3.Bucket
	topic awssns.Topic
}

func NewNotifyingBucket(scope constructs.Construct, id *string, props *NotifyingBucketProps) NotifyingBucket {
	var bucket awss3.Bucket
	if props == nil {
		bucket = awss3.NewBucket(scope, jsii.String(*id+"Bucket"), nil)
	} else {
		bucket = awss3.NewBucket(scope, jsii.String(*id+"Bucket"), &props.BucketProps)
	}
	topic := awssns.NewTopic(scope, jsii.String(*id+"Topic"), nil)
	if props == nil {
		bucket.AddObjectCreatedNotification(awss3notifications.NewSnsDestination(topic))
	} else {
		bucket.AddObjectCreatedNotification(awss3notifications.NewSnsDestination(topic), &awss3.NotificationKeyFilter{
			Prefix: props.Prefix,
		})
	}
	var nbucket NotifyingBucket
	nbucket.Bucket = bucket
	nbucket.topic = topic
	return nbucket
}

Agora, os consumidores podem se inscrever no tópico, por exemplo:

Saiba mais

O vídeo a seguir fornece uma visão geral abrangente das CDK construções e explica como você pode usá-las em seus CDK aplicativos.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Pilhas

Ambientes do