Este é o Guia do desenvolvedor do AWS CDK v2. O CDK v1 antigo 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á. # Identificadores e o AWS CDK Ao compilar aplicações do kit de desenvolvimento em nuvem da AWS (CDK da AWS), você usará vários tipos de identificadores e nomes. Para usar o AWS CDK forma eficaz e evitar erros, é importante entender os tipos de identificadores. Os identificadores devem ser exclusivos dentro do escopo em que foram criados; eles não precisam ser globalmente exclusivos em sua aplicação do AWS CDK. Se você tentar criar um identificador com o mesmo valor dentro do mesmo escopo, o AWS CDK gerará uma exceção. ## IDs de constructo O identificador mais comum, `id`, é o identificador passado como segundo argumento ao instanciar um objeto de constructo. Esse identificador, como todos os identificadores, só precisa ser exclusivo dentro do escopo em que foi criado, que é o primeiro argumento ao instanciar um objeto de constructo. **nota** O `id` de uma pilha também é o identificador que você usa para se referir a ela na [Referência da CLI do AWS CDK](cli.md). Vejamos um exemplo em que temos dois constructos com o identificador `MyBucket` em nossa aplicação. O primeiro é definido no escopo da pilha com o identificador `Stack1`. O segundo é definido no escopo de uma pilha com o identificador `Stack2`. Como eles são definidos em escopos diferentes, isso não causa nenhum conflito e eles podem coexistir na mesma aplicação sem problemas. **Example** ``` import { App, Stack, StackProps } from 'aws-cdk-lib'; import { Construct } from 'constructs'; import * as s3 from 'aws-cdk-lib/aws-s3'; class MyStack extends Stack { constructor(scope: Construct, id: string, props: StackProps = {}) { super(scope, id, props); new s3.Bucket(this, 'MyBucket'); } } const app = new App(); new MyStack(app, 'Stack1'); new MyStack(app, 'Stack2'); ``` ``` const { App , Stack } = require('aws-cdk-lib'); const s3 = require('aws-cdk-lib/aws-s3'); class MyStack extends Stack { constructor(scope, id, props = {}) { super(scope, id, props); new s3.Bucket(this, 'MyBucket'); } } const app = new App(); new MyStack(app, 'Stack1'); new MyStack(app, 'Stack2'); ``` ``` from aws_cdk import App, Construct, Stack, StackProps from constructs import Construct from aws_cdk import aws_s3 as s3 class MyStack(Stack): def __init__(self, scope: Construct, id: str, **kwargs): super().__init__(scope, id, **kwargs) s3.Bucket(self, "MyBucket") app = App() MyStack(app, 'Stack1') MyStack(app, 'Stack2') ``` ``` // MyStack.java package com.myorg; import software.amazon.awscdk.App; import software.amazon.awscdk.Stack; import software.amazon.awscdk.StackProps; import software.constructs.Construct; import software.amazon.awscdk.services.s3.Bucket; public class MyStack extends Stack { public MyStack(final Construct scope, final String id) { this(scope, id, null); } public MyStack(final Construct scope, final String id, final StackProps props) { super(scope, id, props); new Bucket(this, "MyBucket"); } } // Main.java package com.myorg; import software.amazon.awscdk.App; public class Main { public static void main(String[] args) { App app = new App(); new MyStack(app, "Stack1"); new MyStack(app, "Stack2"); } } ``` ``` using Amazon.CDK; using constructs; using Amazon.CDK.AWS.S3; public class MyStack : Stack { public MyStack(Construct scope, string id, IStackProps props) : base(scope, id, props) { new Bucket(this, "MyBucket"); } } class Program { static void Main(string[] args) { var app = new App(); new MyStack(app, "Stack1"); new MyStack(app, "Stack2"); } } ``` ## Caminhos Os constructos em uma aplicação do AWS CDK formam uma hierarquia enraizada na classe `App`. Nós nos referimos à coleção de IDs de um determinado constructo, seu constructo pai, seu avô e assim por diante até a raiz da árvore de constructo, como um *caminho*. O AWS CDK normalmente exibe caminhos em seus modelos como uma string. Os IDs dos níveis são separados por barras, começando no nó imediatamente abaixo da instância raiz `App`, que geralmente é uma pilha. Por exemplo, os caminhos dos dois recursos de bucket do Amazon S3 no exemplo de código anterior são `Stack1/MyBucket` e `Stack2/MyBucket`. É possível acessar o caminho de qualquer constructo de aneira programática, conforme mostrado no exemplo a seguir. Isso segue o caminho de `myConstruct` (ou `my_construct`, como escreveriam os desenvolvedores do Python). Como os IDs devem ser exclusivos dentro do escopo em que são criadas, seus caminhos são sempre exclusivos em uma aplicação do AWS CDK. **Example** ``` const path: string = myConstruct.node.path; ``` ``` const path = myConstruct.node.path; ``` ``` path = my_construct.node.path ``` ``` String path = myConstruct.getNode().getPath(); ``` ``` string path = myConstruct.Node.Path; ``` ## IDs exclusivos O AWS CloudFormation exige que todos os IDs lógicos em um modelo sejam exclusivos. Por isso, o AWS CDK deve ser capaz de gerar um identificador exclusivo para cada constructo em uma aplicação. Os recursos têm caminhos que são globalmente exclusivos (os nomes de todos os escopos da pilha até um recurso específico). Dessa forma, AWS CDK gera os identificadores exclusivos necessários concatenando os elementos do caminho e adicionando um hash de 8 dígitos. (O hash é necessário para distinguir caminhos distintos, como `A/B/C` e `A/BC`, que resultariam no mesmo identificador do AWS CloudFormation. Os identificadores do AWS CloudFormation são alfanuméricos e não podem conter barras ou outros caracteres separadores.) O AWS CDK chama essa string de *ID exclusivo* do constructo. Em geral, sua aplicação do AWS CDK não precisa saber sobre IDs exclusivos. No entanto, é possível acessar programaticamente o ID exclusivo de qualquer constructo, conforme mostrado no exemplo a seguir. **Example** ``` const uid: string = Names.uniqueId(myConstruct); ``` ``` const uid = Names.uniqueId(myConstruct); ``` ``` uid = Names.unique_id(my_construct) ``` ``` String uid = Names.uniqueId(myConstruct); ``` ``` string uid = Names.Uniqueid(myConstruct); ``` O *endereço* é outro tipo de identificador exclusivo que distingue de forma exclusiva os recursos do CDK. Derivado do hash SHA-1 do caminho, não é legível por humanos. No entanto, seu comprimento constante e relativamente curto (sempre 42 caracteres hexadecimais) o torna útil em situações em que o ID exclusivo “tradicional” pode ser muito longo. Alguns constructos podem usar o endereço no modelo sintetizado AWS CloudFormation em vez do ID exclusivo. Novamente, sua aplicação geralmente não precisa saber sobre os endereços de seus constructos, mas é possível recuperar o endereço de um constructo da maneira a seguir. **Example** ``` const addr: string = myConstruct.node.addr; ``` ``` const addr = myConstruct.node.addr; ``` ``` addr = my_construct.node.addr ``` ``` String addr = myConstruct.getNode().getAddr(); ``` ``` string addr = myConstruct.Node.Addr; ``` ## IDs lógicos Os IDs exclusivos servem como *identificadores lógicos* (ou *nomes lógicos*) dos recursos nos modelos do AWS CloudFormation gerados para constructos que representam recursos da AWS. Por exemplo, o bucket do Amazon S3 no exemplo anterior, criado dentro do `Stack2`, resulta em um recurso ` AWS::S3::Bucket`. O ID lógico do recurso é `Stack2MyBucket4DD88B4F` no modelo do AWS CloudFormation resultante. (Para obter detalhes sobre como esse identificador é gerado, consulte [IDs exclusivos](#identifiers-unique-ids).) ### Estabilidade de ID lógico Evite alterar o ID lógico de um recurso após sua criação. AWS O CloudFormation identifica os recursos por meio dos seus IDs lógicos. Portanto, se você alterar o ID lógico de um recurso, o AWS CloudFormation criará um novo recurso com o novo ID lógico e excluirá o existente. Dependendo do tipo de recurso, isso pode causar interrupção do serviço, perda de dados ou ambas.