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á.
# Aplicações do CDK da AWS
A aplicação ou *app* do kit de desenvolvimento em nuvem da AWS (CDK da AWS) é uma coleção de uma ou mais [pilhas](stacks.md) do CDK. As pilhas são uma coleção de um ou mais [constructos](constructs.md) que definem os recursos e propriedades da AWS. Portanto, o agrupamento geral de suas pilhas e constructos é conhecido coma sua aplicação do CDK.
## Como criar uma aplicação do CDK
Você cria uma aplicação definindo uma instância da aplicação no arquivo do seu [projeto](projects.md). Para fazer isso, você importa e usa o constructo [App](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html) da Biblioteca de Constructos da AWS. O constructo `App` não requer nenhum argumento de inicialização. É o único constructo que pode ser usado como raiz.
As classes ` [App](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html) ` e ` [Stack](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html) ` da Biblioteca de Constructos AWS são constructos exclusivos. Em comparação com outros constructos, eles não configuram recursos da AWS sozinhos. Em vez disso, eles usados para fornecer contexto para seus outros constructos. Todos os constructos que representam recursos da AWS devem ser definidos, direta ou indiretamente, dentro do escopo de um constructo da `Stack`. Os constructos da `Stack` são definidos dentro do escopo do constructo de um `App`.
As aplicações são então sintetizadas para criar modelos do AWS CloudFormation para suas pilhas. Veja um exemplo a seguir:
**Example**
```
const app = new App();
new MyFirstStack(app, 'hello-cdk');
app.synth();
```
```
const app = new App();
new MyFirstStack(app, 'hello-cdk');
app.synth();
```
```
app = App()
MyFirstStack(app, "hello-cdk")
app.synth()
```
```
App app = new App();
new MyFirstStack(app, "hello-cdk");
app.synth();
```
```
var app = new App();
new MyFirstStack(app, "hello-cdk");
app.Synth();
```
```
app := awscdk.NewApp(nil)
MyFirstStack(app, "MyFirstStack", &MyFirstStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
```
As pilhas em uma única aplicação podem se referir facilmente aos recursos e propriedades umas das outras. O CDK da AWS infere dependências entre as pilhas para que elas possam ser implantadas na ordem correta. É possível implantar qualquer uma ou todas as pilhas em uma aplicação com um único comando `cdk deploy`.
## A árvore de constructos
Os constructos são definidos dentro de outros constructos usando o argumento `scope` que é passado para cada constructo, com a classe `App` como raiz. Dessa forma, uma aplicação do CDK da AWS define uma hierarquia de constructos, conhecida como *árvore de constructos*.
A raiz dessa árvore é sua aplicação, que é uma instância da classe `App`. Dentro da aplicação, você instancia uma ou mais pilhas. Nas pilhas, você instancia constructos, podendo eles mesmos instanciar recursos ou outros constructos, e assim por diante na árvore.
Os constructos são *sempre* definidos explicitamente dentro do escopo de outro constructo, o que cria relações entre os constructos. Quase sempre, você deve passar `this` (no Python, `self`) como escopo, indicando que o novo constructo é secundário do constructo atual. O padrão pretendido é que você derive seu constructo de [https://docs.aws.amazon.com/cdk/api/v2/docs/constructs.Construct.html](https://docs.aws.amazon.com/cdk/api/v2/docs/constructs.Construct.html) e, em seguida, instancie os constructos que ele usa em seu construtor.
Passar o escopo explicitamente permite que cada constructo se adicione à árvore, com esse comportamento inteiramente contido na [classe de base `Construct`](https://docs.aws.amazon.com/cdk/api/v2/docs/constructs.Construct.html). Isso funciona da mesma forma em todos as linguagens com suporte no CDK da AWS e não requer personalização adicional.
**Importante**
Tecnicamente, é possível passar algum escopo além de `this` ao instanciar um constructo. É possível adicionar constructos em qualquer lugar da árvore ou até mesmo em outra pilha na mesma aplicação. Por exemplo, você pode escrever uma função mixin-style que adiciona constructos a um escopo passado como argumento. A dificuldade prática aqui é que você não pode garantir facilmente que os IDs escolhidos para seus constructos sejam exclusivos dentro do escopo de outra pessoa. Essa prática também torna seu código mais difícil de entender, manter e reutilizar. Portanto, convém usar a estrutura geral da árvore de constructos.
O CDK da AWS usa os IDs de todos os constructos no caminho da raiz da árvore até cada constructo secundário para gerar os IDs exclusivos exigidos pelo AWS CloudFormation. Essa abordagem significa que os IDs de constructo só precisam ser exclusivos em seu escopo, e não em toda a pilha, como no AWS CloudFormation nativo. No entanto, se você mover um constructo para um escopo diferente, o ID exclusivo da pilha gerado será alterado, e o AWS CloudFormation não o considerará como o mesmo recurso.
A árvore de constructos é separada dos constructos que você define no seu código do CDK da AWS. No entanto, ela é acessível por meio de qualquer atributo `node` do constructo, o que é uma referência ao nó que representa esse constructo na árvore. Cada nó é uma instância de [https://docs.aws.amazon.com/cdk/api/v2/docs/constructs.Node.html](https://docs.aws.amazon.com/cdk/api/v2/docs/constructs.Node.html), cujos atributos fornecem acesso à raiz da árvore e aos escopos principais e secundários do nó.
1. `node.children`: constructos secundários diretos do constructo.
1. `node.id`: o identificador do constructo dentro de seu escopo.
1. `node.path`: o caminho completo do constructo, incluindo os IDs de todos os seus constructos principais.
1. `node.root`: a raiz da árvore de constructos (a aplicação).
1. `node.scope`: o escopo (principal) do constructo ou indefinido se o nó for a raiz.
1. `node.scopes`: todos os constructos principais do constructo, até a raiz.
1. `node.uniqueId`: o identificador alfanumérico exclusivo para esse constructo na árvore (por padrão, gerado a partir de `node.path` e um hash).
A árvore de constructos define uma ordem implícita na qual os constructos são sintetizados em recursos no modelo final do AWS CloudFormation. Onde um recurso deve ser criado antes do outro, o AWS CloudFormation ou a Biblioteca de Constructos da AWS geralmente infere a dependência. Em seguida, eles garantem que os recursos sejam criados na ordem correta.
Você também pode adicionar uma dependência explícita entre dois nós usando `node.addDependency()`. Para obter mais informações, consulte [Dependências](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html#dependencies) na *Referência de API do CDK da AWS*.
O CDK da AWS fornece uma maneira simples de visitar todos os nós na árvore de constructos e realizar uma operação em cada um. Para obter mais informações, consulte [Aspectos e o CDK da AWS](aspects.md).