Configurar recursos usando constructos Fazer referência a recursos Nomes físicos de recursos Passando identificadores de recursos exclusivos Concedendo permissões entre recursos Métricas de recursos e alarmes Tráfego de rede Processar eventos Políticas de remoção

Recursos e o AWS CDK

Recursos são o que você configura para usar AWS serviços em seus aplicativos. Os recursos são uma característica do AWS CloudFormation. Ao configurar recursos e suas propriedades em um AWS CloudFormation modelo, você pode implantar para AWS CloudFormation provisionar seus recursos. Com o AWS Cloud Development Kit (AWS CDK), você pode configurar recursos por meio de construções. Em seguida, você implanta seu aplicativo CDK, o que envolve sintetizar um AWS CloudFormation modelo e implantá-lo para AWS CloudFormation provisionar seus recursos.

Configurar recursos usando constructos

Conforme descrito em AWS CDK Constructs, o AWS CDK fornece uma rica biblioteca de classes de construções, chamadas construções, que representam todos os recursos. AWS

Para criar uma instância de um recurso usando seu constructo correspondente, passe o escopo como o primeiro argumento, o ID lógico do constructo e um conjunto de propriedades de configuração (props). Por exemplo, veja como criar uma fila do Amazon SQS com criptografia AWS KMS usando a sqs.Queue construção da Construct Library. AWS

exemplo

Alguns props de configuração são opcionais e, em muitos casos, têm valores padrão. Em alguns casos, todos os props são opcionais e o último argumento pode ser totalmente omitido.

Atributos de recursos

A maioria dos recursos na AWS Construct Library expõe atributos, que são resolvidos no momento da implantação por AWS CloudFormation. Os atributos são expostos na forma de propriedades nas classes de recursos com o nome do tipo como prefixo. O exemplo a seguir mostra como obter o URL de uma fila do Amazon SQS usando a propriedade queueUrl (Python: queue_url).

exemplo

Consulte Tokens e o AWS CDK para obter informações sobre como o AWS CDK codifica os atributos de tempo de implantação como cadeias de caracteres.

Fazer referência a recursos

Ao configurar recursos, muitas vezes você precisará referenciar propriedades de outro recurso. Veja os exemplos a seguir:

Um recurso do Amazon Elastic Container Service (Amazon ECS) requer uma referência ao cluster no qual é executado.
Uma CloudFront distribuição da Amazon exige uma referência ao bucket do Amazon Simple Storage Service (Amazon S3) contendo o código-fonte.

É possível fazer referência a recursos de qualquer uma das formas a seguir:

Ao passar um recurso definido em sua aplicação CDK, na mesma pilha ou em uma diferente
Ao passar um objeto proxy referenciando um recurso definido em sua AWS conta, criado a partir de um identificador exclusivo do recurso (como um ARN)

Se a propriedade de um constructo representa um constructo para outro recurso, seu tipo é o tipo de interface de constructo. Por exemplo, o constructo do Amazon ECS assume uma propriedade cluster do tipo ecs.ICluster. Outro exemplo é a construção CloudFront de distribuição que usa uma propriedade sourceBucket (Python:source_bucket) do tipos3.IBucket.

Você pode passar diretamente qualquer objeto de recurso do tipo adequado definido no mesmo aplicativo AWS CDK. O exemplo a seguir define um cluster do Amazon ECS e o usa para definir um serviço do Amazon ECS.

exemplo

Como fazer referência a recursos em uma pilha diferente

Você pode se referir aos recursos em uma pilha diferente, desde que eles estejam definidos no mesmo aplicativo. As pilhas podem estar no mesmo ambiente ou em AWS ambientes diferentes (contas e regiões). O seguinte padrão é geralmente usado:

Armazene uma referência ao constructo como um atributo da pilha que produz o recurso. (Para obter uma referência à pilha do constructo atual, use Stack.of(this).)
Passe essa referência ao construtor da pilha que consome o recurso como parâmetro ou propriedade. A pilha consumidora então a passa como uma propriedade para qualquer constructo que precise dela.

O exemplo a seguir define uma pilha stack1. Essa pilha define um bucket do Amazon S3 e armazena uma referência ao constructo do bucket como um atributo da pilha. Em seguida, o aplicativo define uma segunda pilhastack2, que aceita um bucket na instanciação. stack2pode, por exemplo, definir uma tabela de AWS cola que usa o bucket para armazenamento de dados.

exemplo

TypeScript


const prod = { account: '123456789012', region: 'us-east-1' };

const stack1 = new StackThatProvidesABucket(app, 'Stack1', { env: prod });

// stack2 will take a property { bucket: IBucket }
const stack2 = new StackThatExpectsABucket(app, 'Stack2', {
  bucket: stack1.bucket,
  env: prod
});

JavaScript


const prod = { account: '123456789012', region: 'us-east-1' };

const stack1 = new StackThatProvidesABucket(app, 'Stack1', { env: prod });

// stack2 will take a property { bucket: IBucket }
const stack2 = new StackThatExpectsABucket(app, 'Stack2', {
  bucket: stack1.bucket,
  env: prod
});

Python


prod = core.Environment(account="123456789012", region="us-east-1")

stack1 = StackThatProvidesABucket(app, "Stack1", env=prod)

# stack2 will take a property "bucket"
stack2 = StackThatExpectsABucket(app, "Stack2", bucket=stack1.bucket, env=prod)

Java


// Helper method to build an environment
static Environment makeEnv(String account, String region) {
    return Environment.builder().account(account).region(region)
            .build();
}

App app = new App();

Environment prod = makeEnv("123456789012", "us-east-1");

StackThatProvidesABucket stack1 = new StackThatProvidesABucket(app, "Stack1",
        StackProps.builder().env(prod).build());

// stack2 will take an argument "bucket"
StackThatExpectsABucket stack2 = new StackThatExpectsABucket(app, "Stack,",
        StackProps.builder().env(prod).build(), stack1.bucket);

C#


Amazon.CDK.Environment makeEnv(string account, string region)
{
    return new Amazon.CDK.Environment { Account = account, Region = region };
}

var prod = makeEnv(account: "123456789012", region: "us-east-1");

var stack1 = new StackThatProvidesABucket(app, "Stack1", new StackProps { Env = prod });

// stack2 will take a property "bucket"
var stack2 = new StackThatExpectsABucket(app, "Stack2", new StackProps { Env = prod,
    bucket = stack1.Bucket});

Se o AWS CDK determinar que o recurso está no mesmo ambiente, mas em uma pilha diferente, ele sintetiza automaticamente AWS CloudFormation as exportações na pilha de produção e na pilha consumidora para transferir essas informações de uma Fn::ImportValue pilha para a outra. Essa é uma referência forte — o comportamento padrão. Você pode controlar a força das referências entre pilhas para evitar impasses de dependência.

Força de referência

Cada referência de pilha cruzada tem uma força que determina o CloudFormation mecanismo usado e o acoplamento entre as pilhas:

Forte (padrão): A pilha de produção cria uma CloudFormation exportação e a pilha consumidora usa. Fn::ImportValue Isso significa que a pilha de produção não pode ser atualizada para remover a exportação enquanto algum consumidor ainda a importa. CloudFormation impõe essa restrição.
Fraco: A pilha consumidora é usada Fn::GetStackOutput para ler as saídas diretamente da pilha de produção. Nenhum acoplamento de exportação é criado; qualquer pilha pode ser atualizada ou excluída de forma independente.
Ambos: Um estado de transição para migrar do forte para o fraco. A pilha de produção retém sua exportação (para que os consumidores fortes existentes não sejam quebrados), enquanto a pilha consumidora muda para. Fn::GetStackOutput

O impasse da dependência (abraço mortal)

Referências fortes podem criar um impasse que impede as atualizações da pilha. Isso acontece porque CloudFormation não é possível remover uma exportação enquanto outra pilha ainda a importa — e a pilha consumidora não pode ser atualizada para interromper a importação até que a exportação já exista. Você pode ver um erro como:

Export Stack1:ExportsOutputFnGetAtt-****** cannot be deleted as it is in use by Stack2

Isso geralmente ocorre quando você tenta remover um recurso compartilhado ou reestruturar suas pilhas. Referências fracas evitam totalmente esse problema, porque não criam exportações.

Controle da força de referência

Você pode controlar a força de referência em três escopos: em todo o aplicativo, por recurso ou por uso.

App-wide padrão

Defina a seguinte chave de contexto cdk.json para alterar o padrão para todas as referências de pilha cruzada no aplicativo:


{
  "context": {
    "@aws-cdk/core:defaultCrossStackReferences": "weak"
  }
}

Per-resource

Substitua a força de todas as referências que apontam para um recurso específico usandoCrossStackReferences.of(resource).produce(strength):

exemplo

Todas as referências bucket de outras pilhas agora serão usadas Fn::GetStackOutput independentemente do padrão em todo o aplicativo.

Per-usage

Substitua a força de uma única referência no ponto de consumo usandoStack.consumeReference():

exemplo

TypeScript


declare const topic: sns.Topic;

const consumer = new Stack(app, 'Consumer', {
  env: { account: '123456789012', region: 'us-east-1' },
});
new sns.Subscription(consumer, 'Subscription', {
  topic: sns.Topic.fromTopicArn(consumer, 'Topic',
    Stack.consumeReference(topic.topicArn, ReferenceStrength.WEAK)),
  endpoint: 'https://example.com/webhook',
  protocol: sns.SubscriptionProtocol.HTTPS,
});

JavaScript


const { Stack, ReferenceStrength } = require('aws-cdk-lib');
const sns = require('aws-cdk-lib/aws-sns');
const subscriptions = require('aws-cdk-lib/aws-sns-subscriptions');

const consumer = new Stack(app, 'Consumer', {
  env: { account: '123456789012', region: 'us-east-1' },
});
new sns.Subscription(consumer, 'Subscription', {
  topic: sns.Topic.fromTopicArn(consumer, 'Topic',
    Stack.consumeReference(topic.topicArn, ReferenceStrength.WEAK)),
  endpoint: 'https://example.com/webhook',
  protocol: sns.SubscriptionProtocol.HTTPS,
});

Python


from aws_cdk import Stack, ReferenceStrength
import aws_cdk.aws_sns as sns

consumer = Stack(app, "Consumer",
    env=core.Environment(account="123456789012", region="us-east-1")
)
sns.Subscription(consumer, "Subscription",
    topic=sns.Topic.from_topic_arn(consumer, "Topic",
        Stack.consume_reference(topic.topic_arn, ReferenceStrength.WEAK)),
    endpoint="https://example.com/webhook",
    protocol=sns.SubscriptionProtocol.HTTPS
)

Java


import software.amazon.awscdk.Stack;
import software.amazon.awscdk.ReferenceStrength;
import software.amazon.awscdk.services.sns.*;

Stack consumer = new Stack(app, "Consumer", StackProps.builder()
        .env(Environment.builder().account("123456789012").region("us-east-1").build())
        .build());
Subscription.Builder.create(consumer, "Subscription")
        .topic(Topic.fromTopicArn(consumer, "Topic",
            Stack.consumeReference(topic.getTopicArn(), ReferenceStrength.WEAK)))
        .endpoint("https://example.com/webhook")
        .protocol(SubscriptionProtocol.HTTPS)
        .build();

C#


using Amazon.CDK;
using Amazon.CDK.AWS.SNS;

var consumer = new Stack(app, "Consumer", new StackProps
{
    Env = new Amazon.CDK.Environment { Account = "123456789012", Region = "us-east-1" }
});
new Subscription(consumer, "Subscription", new SubscriptionProps
{
    Topic = Topic.FromTopicArn(consumer, "Topic",
        Stack.ConsumeReference(topic.TopicArn, ReferenceStrength.WEAK)),
    Endpoint = "https://example.com/webhook",
    Protocol = SubscriptionProtocol.HTTPS
});

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/aws-cdk-go/awscdk/v2/awssns"
  "github.com/aws/jsii-runtime-go"
)

consumer := awscdk.NewStack(app, jsii.String("Consumer"), &awscdk.StackProps{
  Env: &awscdk.Environment{Account: jsii.String("123456789012"), Region: jsii.String("us-east-1")},
})
awssns.NewSubscription(consumer, jsii.String("Subscription"), &awssns.SubscriptionProps{
  Topic: awssns.Topic_FromTopicArn(consumer, jsii.String("Topic"),
    awscdk.Stack_ConsumeReference(topic.TopicArn(), awscdk.ReferenceStrength_WEAK)),
  Endpoint: jsii.String("https://example.com/webhook"),
  Protocol: awssns.SubscriptionProtocol_HTTPS,
})

Use Stack.consumeListReference() para referências de listas de strings.

Substituição com escopo

Você também pode definir a força de referência para uma subárvore de construções usando. CrossStackReferences.of(scope).consume(strength) Todas as referências de pilha cruzada consumidas dentro desse escopo usarão a força especificada.

Migrando de referências fortes para referências fracas

Se você já implantou pilhas com referências fortes, não pode mudar diretamente para fracas — CloudFormation falharia porque a exportação ainda está em uso. Em vez disso, use uma migração em duas fases através do estado de BOTH transição.

A API a ser usada depende do seu objetivo:

Remover uma única referência (mas manter as pilhas e o recurso no lugar) — use Stack.consumeReference() para enfraquecer somente esse uso específico.
Remover ou reestruturar o recurso de produção — use CrossStackReferences.of(producer).produce() para enfraquecer todas as referências que apontam para esse recurso de uma só vez.

Ambas as abordagens seguem o mesmo padrão de duas fases descrito abaixo. Os exemplos mostram a abordagem por recurso. Para cada uso, envolva a referência Stack.consumeReference(ref, ReferenceStrength.BOTH) na Fase 1 e Stack.consumeReference(ref, ReferenceStrength.WEAK) na Fase 2.

Fase 1: Implantar com `AMBOS`

Mude a intensidade de referência paraBOTH. Isso faz com que a pilha consumidora comece a usarFn::GetStackOutput, mas mantém a exportação na pilha de produção para que a transição seja segura:

exemplo

Implante as duas pilhas.

Fase 2: Implantar com `WEAK`

Agora que nenhum consumidor usaFn::ImportValue, a exportação pode ser removida com segurança. Mudar paraWEAK:

exemplo

Implante as duas pilhas. A exportação foi removida e a referência agora está totalmente fraca.

Após essa migração, você pode remover, mover ou reestruturar livremente o recurso sem se deparar com um abraço mortal.

Solução alternativa manual (antiga)

Se você ainda não estiver usando controles de força de referência, poderá contornar o impasse manualmente. Remova o uso do recurso compartilhado da pilha de consumo. Em seguida, adicione manualmente a mesma exportação à pilha de produção usando exatamente o mesmo ID lógico da exportação gerada automaticamente. Implante as duas pilhas para remover o. Fn::ImportValue Em seguida, remova a exportação manual (e o recurso compartilhado, se não for mais necessário) e implante as duas pilhas novamente. O método exportValue() da pilha é uma maneira conveniente de criar a exportação manual para essa finalidade.

Recursos de referência em seu AWS account

Suponha que você queira usar um recurso já disponível em sua AWS conta no seu aplicativo AWS CDK. Esse pode ser um recurso definido por meio do console, de um AWS SDK, diretamente com AWS CloudFormation ou em um aplicativo AWS CDK diferente. É possível transformar o ARN do recurso (ou outro atributo de identificação ou grupo de atributos) em um objeto proxy. O objeto proxy serve como referência ao recurso chamando um método estático de fábrica na classe do recurso.

Quando você cria esse proxy, o recurso externo não se torna parte do seu aplicativo AWS CDK. Portanto, as alterações feitas no proxy em seu aplicativo AWS CDK não afetam o recurso implantado. No entanto, o proxy pode ser passado para qualquer método AWS CDK que exija um recurso desse tipo.

O exemplo a seguir mostra como referenciar um bucket baseado em um bucket existente com o ARN arn:aws:s3:::amzn-s3-demo-bucket1 e uma Amazon Virtual Private Cloud com base em uma VPC existente com um ID específico.

exemplo

TypeScript


// Construct a proxy for a bucket by its name (must be same account)
s3.Bucket.fromBucketName(this, 'MyBucket', 'amzn-s3-demo-bucket1');

// Construct a proxy for a bucket by its full ARN (can be another account)
s3.Bucket.fromBucketArn(this, 'MyBucket', 'arn:aws:s3:::amzn-s3-demo-bucket1');

// Construct a proxy for an existing VPC from its attribute(s)
ec2.Vpc.fromVpcAttributes(this, 'MyVpc', {
  vpcId: 'vpc-1234567890abcde',
});

JavaScript


// Construct a proxy for a bucket by its name (must be same account)
s3.Bucket.fromBucketName(this, 'MyBucket', 'amzn-s3-demo-bucket1');

// Construct a proxy for a bucket by its full ARN (can be another account)
s3.Bucket.fromBucketArn(this, 'MyBucket', 'arn:aws:s3:::amzn-s3-demo-bucket1');

// Construct a proxy for an existing VPC from its attribute(s)
ec2.Vpc.fromVpcAttributes(this, 'MyVpc', {
  vpcId: 'vpc-1234567890abcde'
});

Python


# Construct a proxy for a bucket by its name (must be same account)
s3.Bucket.from_bucket_name(self, "MyBucket", "amzn-s3-demo-bucket1")

# Construct a proxy for a bucket by its full ARN (can be another account)
s3.Bucket.from_bucket_arn(self, "MyBucket", "arn:aws:s3:::amzn-s3-demo-bucket1")

# Construct a proxy for an existing VPC from its attribute(s)
ec2.Vpc.from_vpc_attributes(self, "MyVpc", vpc_id="vpc-1234567890abcdef")

Java


// Construct a proxy for a bucket by its name (must be same account)
Bucket.fromBucketName(this, "MyBucket", "amzn-s3-demo-bucket1");

// Construct a proxy for a bucket by its full ARN (can be another account)
Bucket.fromBucketArn(this, "MyBucket",
        "arn:aws:s3:::amzn-s3-demo-bucket1");

// Construct a proxy for an existing VPC from its attribute(s)
Vpc.fromVpcAttributes(this, "MyVpc", VpcAttributes.builder()
        .vpcId("vpc-1234567890abcdef").build());

C#


// Construct a proxy for a bucket by its name (must be same account)
Bucket.FromBucketName(this, "MyBucket", "amzn-s3-demo-bucket1");

// Construct a proxy for a bucket by its full ARN (can be another account)
Bucket.FromBucketArn(this, "MyBucket", "arn:aws:s3:::amzn-s3-demo-bucket1");

// Construct a proxy for an existing VPC from its attribute(s)
Vpc.FromVpcAttributes(this, "MyVpc", new VpcAttributes
{
    VpcId = "vpc-1234567890abcdef"
});

Go


// Define a proxy for a bucket by its name (must be same account)
s3.Bucket_FromBucketName(stack, jsii.String("MyBucket"), jsii.String("amzn-s3-demo-bucket1"))

// Define a proxy for a bucket by its full ARN (can be another account)
s3.Bucket_FromBucketArn(stack, jsii.String("MyBucket"), jsii.String("arn:aws:s3:::amzn-s3-demo-bucket1"))

// Define a proxy for an existing VPC from its attributes
ec2.Vpc_FromVpcAttributes(stack, jsii.String("MyVpc"), &ec2.VpcAttributes{
  VpcId: jsii.String("vpc-1234567890abcde"),
})

Vamos examinar com mais cuidado o método Vpc.fromLookup(). Como o ec2.Vpc constructo é complexo, talvez você queira selecionar a VPC de várias maneiras para ser usada com sua aplicação CDK. Para resolver isso, a construção da VPC tem um método fromLookup estático (Python:from_lookup) que permite pesquisar a Amazon VPC desejada consultando sua AWS conta no momento da síntese.

Para usar o Vpc.fromLookup(), o sistema que sintetiza a pilha deve ter acesso à conta proprietária da Amazon VPC. Isso ocorre porque o Kit de Ferramentas CDK consulta a conta para encontrar a Amazon VPC certa no momento da síntese.

Além disso, Vpc.fromLookup() funciona somente em pilhas definidas com uma conta e uma região explícitas (consulte Ambientes para o AWS CDK). Se o AWS CDK tentar pesquisar uma Amazon VPC a partir de uma pilha independente do ambiente, o CDK Toolkit não saberá qual ambiente consultar para encontrar a VPC.

Você deve fornecer Vpc.fromLookup() atributos suficientes para identificar de forma exclusiva uma VPC em sua conta. AWS Por exemplo, só pode haver uma VPC padrão, então basta especificar a VPC como padrão.

exemplo

Você também pode usar a propriedade tags para consultar VPCs por tag. Você pode adicionar tags ao Amazon VPC no momento de sua criação usando AWS CloudFormation ou o AWS CDK. Você pode editar as tags a qualquer momento após a criação usando o AWS Management Console, a AWS CLI ou um AWS SDK. Além de todas as tags que você mesmo adicionar, o AWS CDK adiciona automaticamente as seguintes tags a todas as VPCs que ele cria.

Nome – O nome da VPC.
aws-cdk:subnet-name – O nome da sub-rede.
aws-cdk:subnet-type – O tipo de sub-rede: pública, privada ou isolada.

exemplo

Os resultados de Vpc.fromLookup() são armazenados em cache no arquivo cdk.context.json do projeto. (Consulte Valores de contexto e o AWS CDK.) Confirme esse arquivo com o controle de versão para que sua aplicação continue se referindo à mesma Amazon VPC. Isso funciona mesmo se você alterar posteriormente os atributos de suas VPCs de uma forma que resultaria na seleção de uma VPC diferente. Isso é particularmente importante se você estiver implantando a pilha em um ambiente que não tem acesso à AWS conta que define a VPC, como o CDK Pipelines.

Embora você possa usar um recurso externo em qualquer lugar em que usaria um recurso semelhante definido em seu aplicativo AWS CDK, não é possível modificá-lo. Por exemplo, chamar addToResourcePolicy (Python: add_to_resource_policy) em um s3.Bucket externo não faz nada.

Nomes físicos de recursos

Os nomes lógicos dos recursos em AWS CloudFormation são diferentes dos nomes dos recursos que são mostrados no AWS Management Console após serem implantados pelo AWS CloudFormation. O AWS CDK chama esses nomes finais de nomes físicos.

Por exemplo, AWS CloudFormation pode criar o bucket Amazon S3 com o ID lógico Stack2MyBucket4DD88B4F e o nome stack2MyBucket4dd88b4f-iuv1rbv9z3to físico.

É possível especificar um nome físico ao criar constructos que representam recursos usando a propriedade <resourceType>Name. O exemplo a seguir cria um bucket do Amazon S3 com o nome físico amzn-s3-demo-bucket.

exemplo

Atribuir nomes físicos aos recursos tem algumas desvantagens em AWS CloudFormation. Mais importante ainda, qualquer alteração nos recursos implantados que exija a substituição de um recurso, como alterações nas propriedades de um recurso que sejam imutáveis após a criação, falhará se um recurso tiver um nome físico atribuído. Se você acabar nesse estado, a única solução é excluir a AWS CloudFormation pilha e implantar o aplicativo AWS CDK novamente. Consulte a Documentação do AWS CloudFormation para obter detalhes.

Em alguns casos, como ao criar um aplicativo AWS CDK com referências entre ambientes, nomes físicos são necessários para que o AWS CDK funcione corretamente. Nesses casos, se você não quiser se preocupar em criar um nome físico sozinho, pode deixar que o AWS CDK o nomeie para você. Para isso, use o valor especial PhysicalName.GENERATE_IF_NEEDED, da forma a seguir.

exemplo

Passando identificadores de recursos exclusivos

Sempre que possível, você deve passar os recursos por referência, conforme descrito na seção anterior. No entanto, há casos em que você não tem outra escolha a não ser se referir a um recurso por meio de um de seus atributos. Alguns casos de uso incluem o seguinte:

Quando você está usando AWS CloudFormation recursos de baixo nível.
Quando você precisa expor recursos aos componentes de tempo de execução de um aplicativo AWS CDK, como quando se refere às funções do Lambda por meio de variáveis de ambiente.

Esses identificadores estão disponíveis como atributos nos recursos, como os seguintes.

exemplo

O exemplo a seguir mostra como passar um nome de bucket gerado para uma função do AWS Lambda.

exemplo

Concedendo permissões entre recursos

Higher-level as construções possibilitam permissões de menor privilégio oferecendo APIs simples e baseadas em intenção para expressar os requisitos de permissão. Por exemplo, muitas construções oferecem métodos de concessão que você pode usar para conceder permissão a uma entidade (como uma função ou usuário do IAM) para trabalhar com o recurso, sem precisar criar manualmente declarações de permissão do IAM.

Os métodos de concessão estão disponíveis por meio das classes Grants (como BucketGrants para buckets do Amazon S3). Essas classes funcionam com construções L1 e L2. As construções L2 expõem uma grants propriedade por conveniência, mas você também pode criar uma classe Grants diretamente de uma construção L1. Você pode combinar classes Grants com Mixins para obter L2-like conveniência nas construções L1.

O exemplo a seguir cria as permissões para permitir que a função de execução de uma função do Lambda leia e grave objetos em um determinado bucket do Amazon S3. Se o bucket do Amazon S3 for criptografado com uma chave AWS KMS, esse método também concederá permissões à função de execução da função Lambda para descriptografar com a chave.

exemplo

Os métodos de concessão retornam um objeto iam.Grant. Use o atributo success do objeto Grant para determinar se a concessão foi efetivamente aplicada (por exemplo, ela pode não ter sido aplicada em recursos externos). Você também pode usar o método assertSuccess (Python: assert_success) do objeto Grant para garantir que a concessão tenha sido aplicada com sucesso.

Se um método de concessão específico não estiver disponível para o caso de uso específico, será possível usar um método de concessão genérico para definir uma nova concessão com uma lista específica de ações.

O exemplo a seguir mostra como conceder a uma função do Lambda acesso à ação do Amazon DynamoDB CreateBackup.

exemplo

Muitos recursos, como as funções do Lambda, exigem que um perfil seja assumido ao executar o código. Uma propriedade de configuração permite que você especifique um iam.IRole. Se nenhum perfil for especificado, a função criará automaticamente um perfil específico para esse uso. Em seguida, você pode usar métodos de concessão nos recursos para adicionar declarações ao perfil.

Os métodos de concessão são criados usando APIs de nível inferior para lidar com as políticas do IAM. As políticas são modeladas como PolicyDocument objetos. Adicione declarações diretamente aos perfils (ou ao perfil anexado a um constructo) usando o método addToRolePolicy (Python: add_to_role_policy) ou à política de um recurso (como uma política Bucket) usando o método addToResourcePolicy (Python: add_to_resource_policy).

Métricas de recursos e alarmes

Muitos recursos emitem CloudWatch métricas que podem ser usadas para configurar painéis de monitoramento e alarmes. Higher-level as construções têm métodos métricos que permitem acessar as métricas sem procurar o nome correto a ser usado.

O exemplo a seguir mostra como definir um alarme quando o ApproximateNumberOfMessagesNotVisible de uma fila do Amazon SQS exceder 100.

exemplo

TypeScript


import * as cw from '@aws-cdk/aws-cloudwatch';
import * as sqs from '@aws-cdk/aws-sqs';
import { Duration } from '@aws-cdk/core';

const queue = new sqs.Queue(this, 'MyQueue');

const metric = queue.metricApproximateNumberOfMessagesNotVisible({
  label: 'Messages Visible (Approx)',
  period: Duration.minutes(5),
  // ...
});
metric.createAlarm(this, 'TooManyMessagesAlarm', {
  comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
  threshold: 100,
  // ...
});

JavaScript


const cw = require('@aws-cdk/aws-cloudwatch');
const sqs = require('@aws-cdk/aws-sqs');
const { Duration } = require('@aws-cdk/core');

const queue = new sqs.Queue(this, 'MyQueue');

const metric = queue.metricApproximateNumberOfMessagesNotVisible({
  label: 'Messages Visible (Approx)',
  period: Duration.minutes(5)
  // ...
});
metric.createAlarm(this, 'TooManyMessagesAlarm', {
  comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
  threshold: 100
  // ...
});

Python


import aws_cdk.aws_cloudwatch as cw
import aws_cdk.aws_sqs as sqs
from aws_cdk.core import Duration

queue = sqs.Queue(self, "MyQueue")
metric = queue.metric_approximate_number_of_messages_not_visible(
    label="Messages Visible (Approx)",
    period=Duration.minutes(5),
    # ...
)
metric.create_alarm(self, "TooManyMessagesAlarm",
    comparison_operator=cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
    threshold=100,
    # ...
)

Java


import software.amazon.awscdk.core.Duration;
import software.amazon.awscdk.services.sqs.Queue;
import software.amazon.awscdk.services.cloudwatch.Metric;
import software.amazon.awscdk.services.cloudwatch.MetricOptions;
import software.amazon.awscdk.services.cloudwatch.CreateAlarmOptions;
import software.amazon.awscdk.services.cloudwatch.ComparisonOperator;

Queue queue = new Queue(this, "MyQueue");

Metric metric = queue
        .metricApproximateNumberOfMessagesNotVisible(MetricOptions.builder()
                .label("Messages Visible (Approx)")
                .period(Duration.minutes(5)).build());

metric.createAlarm(this, "TooManyMessagesAlarm", CreateAlarmOptions.builder()
                .comparisonOperator(ComparisonOperator.GREATER_THAN_THRESHOLD)
                .threshold(100)
                // ...
                .build());

C#


using cdk = Amazon.CDK;
using cw = Amazon.CDK.AWS.CloudWatch;
using sqs = Amazon.CDK.AWS.SQS;

var queue = new sqs.Queue(this, "MyQueue");
var metric = queue.MetricApproximateNumberOfMessagesNotVisible(new cw.MetricOptions
{
    Label = "Messages Visible (Approx)",
    Period = cdk.Duration.Minutes(5),
    // ...
});
metric.CreateAlarm(this, "TooManyMessagesAlarm", new cw.CreateAlarmOptions
{
    ComparisonOperator = cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
    Threshold = 100,
    // ..
});

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  cw "github.com/aws/aws-cdk-go/awscdk/v2/awscloudwatch"
  sqs "github.com/aws/aws-cdk-go/awscdk/v2/awssqs"
)

queue := sqs.NewQueue(this, jsii.String("MyQueue"), &sqs.QueueProps{})
metric := queue.MetricApproximateNumberOfMessagesNotVisible(&cw.MetricOptions{
  Label: jsii.String("Messages Visible (Approx)"),
  Period: awscdk.Duration_Minutes(jsii.Number(5)),
})

metric.CreateAlarm(this, jsii.String("TooManyMessagesAlarm"), &cw.CreateAlarmOptions{
  ComparisonOperator: cw.ComparisonOperator_GREATER_THAN_THRESHOLD,
  Threshold: jsii.Number(100),
})

Se não houver um método para uma métrica específica, será possível usar o método métrico geral para especificar o nome da métrica manualmente.

As métricas também podem ser adicionadas aos CloudWatch painéis. Consulte CloudWatch.

Tráfego de rede

Em muitos casos, você deve habilitar permissões em uma rede para que uma aplicação funcione, como quando a infraestrutura computacional precisa acessar a camada de persistência. Recursos que estabelecem ou escutam conexões expõem métodos que permitem fluxos de tráfego, incluindo a definição de regras de grupos de segurança ou ACLs de rede.

Os recursos IConnectable têm uma propriedade connections que é o gateway para a configuração das regras de tráfego de rede.

Você permite que os dados fluam em um determinado caminho de rede usando métodos allow. O exemplo a seguir permite conexões HTTPS com a web e conexões de entrada do grupo Amazon EC2 Auto Scaling fleet2.

exemplo

TypeScript


import * as asg from '@aws-cdk/aws-autoscaling';
import * as ec2 from '@aws-cdk/aws-ec2';

const fleet1: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/);

// Allow surfing the (secure) web
fleet1.connections.allowTo(new ec2.Peer.anyIpv4(), new ec2.Port({ fromPort: 443, toPort: 443 }));

const fleet2: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/);
fleet1.connections.allowFrom(fleet2, ec2.Port.AllTraffic());

JavaScript


const asg = require('@aws-cdk/aws-autoscaling');
const ec2 = require('@aws-cdk/aws-ec2');

const fleet1 = asg.AutoScalingGroup();

// Allow surfing the (secure) web
fleet1.connections.allowTo(new ec2.Peer.anyIpv4(), new ec2.Port({ fromPort: 443, toPort: 443 }));

const fleet2 = asg.AutoScalingGroup();
fleet1.connections.allowFrom(fleet2, ec2.Port.AllTraffic());

Python


import aws_cdk.aws_autoscaling as asg
import aws_cdk.aws_ec2 as ec2

fleet1 = asg.AutoScalingGroup( ... )

# Allow surfing the (secure) web
fleet1.connections.allow_to(ec2.Peer.any_ipv4(),
  ec2.Port(PortProps(from_port=443, to_port=443)))

fleet2 = asg.AutoScalingGroup( ... )
fleet1.connections.allow_from(fleet2, ec2.Port.all_traffic())

Java


import software.amazon.awscdk.services.autoscaling.AutoScalingGroup;
import software.amazon.awscdk.services.ec2.Peer;
import software.amazon.awscdk.services.ec2.Port;

AutoScalingGroup fleet1 = AutoScalingGroup.Builder.create(this, "MyFleet")
        /* ... */.build();

// Allow surfing the (secure) Web
fleet1.getConnections().allowTo(Peer.anyIpv4(),
        Port.Builder.create().fromPort(443).toPort(443).build());

AutoScalingGroup fleet2 = AutoScalingGroup.Builder.create(this, "MyFleet2")
        /* ... */.build();
fleet1.getConnections().allowFrom(fleet2, Port.allTraffic());

C#


using cdk = Amazon.CDK;
using asg = Amazon.CDK.AWS.AutoScaling;
using ec2 = Amazon.CDK.AWS.EC2;

// Allow surfing the (secure) Web
var fleet1 = new asg.AutoScalingGroup(this, "MyFleet", new asg.AutoScalingGroupProps { /* ... */ });
fleet1.Connections.AllowTo(ec2.Peer.AnyIpv4(), new ec2.Port(new ec2.PortProps
  { FromPort = 443, ToPort = 443 }));

var fleet2 = new asg.AutoScalingGroup(this, "MyFleet2", new asg.AutoScalingGroupProps { /* ... */ });
fleet1.Connections.AllowFrom(fleet2, ec2.Port.AllTraffic());

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  autoscaling "github.com/aws/aws-cdk-go/awscdk/v2/awsautoscaling"
  ec2 "github.com/aws/aws-cdk-go/awscdk/v2/awsec2"
)

fleet1 := autoscaling.NewAutoScalingGroup(this, jsii.String("MyFleet1"), &autoscaling.AutoScalingGroupProps{})
fleet1.Connections().AllowTo(ec2.Peer_AnyIpv4(),ec2.NewPort(&ec2.PortProps{ FromPort: jsii.Number(443), ToPort: jsii.Number(443) }),jsii.String("secure web"))

fleet2 := autoscaling.NewAutoScalingGroup(this, jsii.String("MyFleet2"), &autoscaling.AutoScalingGroupProps{})
fleet1.Connections().AllowFrom(fleet2, ec2.Port_AllTraffic(),jsii.String("all traffic"))

Alguns recursos têm portas padrão associadas a eles. Os exemplos incluem o receptor de um balanceador de carga na porta pública e as portas nas quais o mecanismo de banco de dados aceita conexões para instâncias de um banco de dados do Amazon RDS. Nesses casos, você pode aplicar um controle rígido da rede sem precisar especificar manualmente a porta. Para fazer isso, use os métodos allowDefaultPortFrom e allowToDefaultPort (Python: allow_default_port_from, allow_to_default_port).

O exemplo a seguir mostra como habilitar conexões de qualquer endereço IPV4 e uma conexão de um grupo do Auto Scaling para acessar um banco de dados.

exemplo

Processar eventos

Alguns recursos podem atuar como fontes de eventos. Use o método addEventNotification (Python: add_event_notification) para registrar um destino de evento para um determinado tipo de evento emitido pelo recurso. Além disso, os métodos addXxxNotification oferecem uma maneira simples de registrar um manipulador para tipos de eventos comuns.

O exemplo a seguir mostra como acionar uma função do Lambda quando um objeto é adicionado a um bucket do Amazon S3.

exemplo

TypeScript


import * as s3nots from '@aws-cdk/aws-s3-notifications';

const handler = new lambda.Function(this, 'Handler', { /*…*/ });
const bucket = new s3.Bucket(this, 'Bucket');
bucket.addObjectCreatedNotification(new s3nots.LambdaDestination(handler));

JavaScript


const s3nots = require('@aws-cdk/aws-s3-notifications');

const handler = new lambda.Function(this, 'Handler', { /*…*/ });
const bucket = new s3.Bucket(this, 'Bucket');
bucket.addObjectCreatedNotification(new s3nots.LambdaDestination(handler));

Python


import aws_cdk.aws_s3_notifications as s3_nots

handler = lambda_.Function(self, "Handler", ...)
bucket = s3.Bucket(self, "Bucket")
bucket.add_object_created_notification(s3_nots.LambdaDestination(handler))

Java


import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.s3.notifications.LambdaDestination;

Function handler = Function.Builder.create(this, "Handler")/* ... */.build();
Bucket bucket = new Bucket(this, "Bucket");
bucket.addObjectCreatedNotification(new LambdaDestination(handler));

C#


using lambda = Amazon.CDK.AWS.Lambda;
using s3 = Amazon.CDK.AWS.S3;
using s3Nots = Amazon.CDK.AWS.S3.Notifications;

var handler = new lambda.Function(this, "Handler", new lambda.FunctionProps { .. });
var bucket = new s3.Bucket(this, "Bucket");
bucket.AddObjectCreatedNotification(new s3Nots.LambdaDestination(handler));

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3"
  s3nots "github.com/aws/aws-cdk-go/awscdk/v2/awss3notifications"
)

handler := lambda.NewFunction(this, jsii.String("MyFunction"), &lambda.FunctionProps{})
bucket := s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{})
bucket.AddObjectCreatedNotification(s3nots.NewLambdaDestination(handler), nil)

Políticas de remoção

Recursos que mantêm dados persistentes, como bancos de dados, buckets do Amazon S3 e registros do Amazon ECR, têm uma política de remoção. A política de remoção indica se os objetos persistentes devem ser excluídos quando a pilha de AWS CDK que os contém for destruída. Os valores que especificam a política de remoção estão disponíveis por meio da RemovalPolicy enumeração no módulo CDK. AWS core

nota

Recursos além daqueles que armazenam dados de forma persistente também podem ter um removalPolicy que é usado para uma finalidade diferente. Por exemplo, uma versão da função do Lambda usa um atributo removalPolicy para determinar se uma determinada versão é retida quando uma nova versão é implantada. Eles têm significados e padrões diferentes em comparação com a política de remoção em um bucket do Amazon S3 ou uma tabela do DynamoDB.

Valor	Significado
`RemovalPolicy.RETAIN`	Manter o conteúdo do recurso ao destruir a pilha (padrão). O recurso fica órfão da pilha e deve ser excluído manualmente. Se você tentar reimplantar a pilha enquanto o recurso ainda existe, você receberá uma mensagem de erro devido a um conflito de nomes.
`RemovalPolicy.DESTROY`	O recurso será destruído junto com a pilha.

AWS CloudFormation não remove buckets do Amazon S3 que contêm arquivos, mesmo que sua política de remoção esteja definida como. DESTROY Tentar fazer isso é um AWS CloudFormation erro. Para que o AWS CDK exclua todos os arquivos do bucket antes de destruí-lo, defina a autoDeleteObjects propriedade do bucket como. true

Veja a seguir um exemplo de criação de um bucket do Amazon S3 com RemovalPolicy de DESTROY e autoDeleteOjbects definido como true.

exemplo

TypeScript


import * as cdk from '@aws-cdk/core';
import * as s3 from '@aws-cdk/aws-s3';

export class CdkTestStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const bucket = new s3.Bucket(this, 'Bucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true
    });
  }
}

JavaScript


const cdk = require('@aws-cdk/core');
const s3 = require('@aws-cdk/aws-s3');

class CdkTestStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    const bucket = new s3.Bucket(this, 'Bucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true
    });
  }
}

module.exports = { CdkTestStack }

Python


import aws_cdk.core as cdk
import aws_cdk.aws_s3 as s3

class CdkTestStack(cdk.stack):
    def __init__(self, scope: cdk.Construct, id: str, **kwargs):
        super().__init__(scope, id, **kwargs)

        bucket = s3.Bucket(self, "Bucket",
            removal_policy=cdk.RemovalPolicy.DESTROY,
            auto_delete_objects=True)

Java


software.amazon.awscdk.core.*;
import software.amazon.awscdk.services.s3.*;

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

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

        Bucket.Builder.create(this, "Bucket")
                .removalPolicy(RemovalPolicy.DESTROY)
                .autoDeleteObjects(true).build();
    }
}

C#


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

public CdkTestStack(Construct scope, string id, IStackProps props) : base(scope, id, props)
{
    new Bucket(this, "Bucket", new BucketProps {
        RemovalPolicy = RemovalPolicy.DESTROY,
        AutoDeleteObjects = true
    });
}

Go


import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3"
)

s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{
  RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
  AutoDeleteObjects: jsii.Bool(true),
})

Você também pode aplicar uma política de remoção diretamente ao AWS CloudFormation recurso subjacente por meio do applyRemovalPolicy() método. Esse método está disponível em alguns recursos com estado que não têm uma propriedade removalPolicy nas propriedades do recurso L2. Os exemplos incluem:

AWS CloudFormation pilhas
Grupos de usuários do Amazon Cognito
Instâncias de banco de dados do Amazon DocumentDB
Volumes do Amazon EC2
OpenSearch Domínios do Amazon Service
Sistemas de arquivos do Amazon FSx
Filas do Amazon SQS

exemplo

nota

O AWS CDK's RemovalPolicy se traduz em s. AWS CloudFormation DeletionPolicy No entanto, o padrão no AWS CDK é reter os dados, o que é o oposto do AWS CloudFormation padrão.

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

Bootstrapping

Identificadores

Recursos e o AWS CDK

Configurar recursos usando constructos

exemplo

Atributos de recursos

exemplo

Fazer referência a recursos

exemplo

Como fazer referência a recursos em uma pilha diferente

exemplo

Força de referência

O impasse da dependência (abraço mortal)

Controle da força de referência

App-wide padrão

Per-resource

exemplo

Per-usage

exemplo

Substituição com escopo

Migrando de referências fortes para referências fracas

Fase 1: Implantar com AMBOS

exemplo

Fase 2: Implantar com WEAK

exemplo

Solução alternativa manual (antiga)

Recursos de referência em seu AWS account

exemplo

exemplo

exemplo

Nomes físicos de recursos

exemplo

exemplo

Passando identificadores de recursos exclusivos

exemplo

exemplo

Concedendo permissões entre recursos

exemplo

exemplo

Métricas de recursos e alarmes

exemplo

Tráfego de rede

exemplo

exemplo

Processar eventos

exemplo

Políticas de remoção

nota

exemplo

exemplo

nota

Fase 1: Implantar com `AMBOS`

Fase 2: Implantar com `WEAK`