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á.

# Projetos do AWS CDK
<a name="projects"></a>

Um projeto do kit de desenvolvimento em nuvem da AWS (CDK da AWS) representa os arquivos e pastas que contêm seu código do CDK. O conteúdo variará de acordo com sua linguagem de programação.

É possível criar seu projeto do AWS CDK manualmente ou com o comando `cdk init` da interface da linha de comandos do AWS CDK (CLI do AWS CDK). Neste tópico, nos referiremos à estrutura do projeto e às convenções de nomenclatura de arquivos e pastas criados pela CLI do AWS CDK. É possível personalizar e organizar seus projetos do CDK para atender às necessidades.

**nota**  
A estrutura do projeto criada pela CLI do AWS CDK pode variar entre as versões ao longo do tempo.

## Arquivos e pastas universais
<a name="projects-universal"></a><a name="projects-universal-git"></a>

 `.git`   
Se você tiver o `git` instalado, a CLI do AWS CDK inicializará automaticamente um repositório do Git para seu projeto. O diretório `.git` contém informações sobre o repositório.<a name="projects-universal-gitignore"></a>

 `.gitignore`   
Arquivo de texto usado pelo Git para especificar arquivos e pastas a serem ignorados.<a name="projects-universal-readme"></a>

 `README.md`   
Arquivo de texto que fornece orientações básicas e informações importantes para gerenciar seu projeto do AWS CDK. Modifique esse arquivo conforme necessário para documentar informações importantes sobre seu projeto do CDK.<a name="projects-universal-cdk"></a>

 `cdk.json`   
Arquivo de configuração para o AWS CDK. Esse arquivo fornece instruções à CLI do AWS CDK sobre como executar sua aplicação.

## Arquivos e pastas específicos de linguagem
<a name="projects-specific"></a>

Os arquivos e pastas a seguir são exclusivos para cada linguagem de programação compatível.

**Example**  
Veja a seguir um exemplo de projeto criado no diretório `my-cdk-ts-project` usando o comando `cdk init --language typescript`:  

```
my-cdk-ts-project
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│   └── my-cdk-ts-project.ts
├── cdk.json
├── jest.config.js
├── lib
│   └── my-cdk-ts-project-stack.ts
├── node_modules
├── package-lock.json
├── package.json
├── test
│   └── my-cdk-ts-project.test.ts
└── tsconfig.json
```  
 `.npmignore`   
Arquivo que especifica quais arquivos e pastas devem ser ignorados ao publicar um pacote no registro `npm`. Esse arquivo é semelhante ao `.gitignore`, mas é específico para pacotes `npm`.  
 `bin/my-cdk-ts-project.ts`   
O *arquivo da aplicação* define sua aplicação CDK. Os projetos do CDK contêm um ou mais arquivos de aplicações. Os arquivos da aplicação são armazenados na pasta `bin`.  
Veja a seguir um exemplo de um arquivo de aplicação básico que define uma aplicação do CDK:  

```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { MyCdkTsProjectStack } from '../lib/my-cdk-ts-project-stack';

const app = new cdk.App();
new MyCdkTsProjectStack(app, 'MyCdkTsProjectStack');
```  
 `jest.config.js`   
Arquivo de configuração para o Jest. * O Jest* é uma estrutura popular de testes de JavaScript.  
 `lib/my-cdk-ts-project-stack.ts`   
O *arquivo de pilha* define sua pilha do CDK. Na sua pilha, você define os recursos da AWS e as propriedades usando constructos.  
Veja a seguir um exemplo de um arquivo de pilha básico que define uma pilha do CDK:  

```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

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

  // code that defines your resources and properties go here
 }
}
```  
 `node_modules`   
Pasta comum em projetos Node.js que contêm dependências para seu projeto.  
 `package-lock.json`   
Arquivo de metadados que funcionam com o arquivo `package.json` para gerenciar versões de dependências.  
 `package.json`   
Arquivo de metadados que é comumente usado em projetos Node.js. Esse arquivo contém informações sobre seu projeto do CDK, como nome do projeto, definições de script, dependências e outras informações de importação em nível de projeto.  
 `test/my-cdk-ts-project.test.ts`   
Uma pasta de teste é criada para organizar os testes do seu projeto do CDK. Um arquivo de teste de amostra também é criado.  
É possível escrever testes em TypeScript e usar o Jest para compilar seu código de TypeScript antes de executar testes.  
 `tsconfig.json`   
Arquivo de configuração usado em projetos do TypeScript que especifica as opções do compilador e as configurações do projeto.
Veja a seguir um exemplo de projeto criado no diretório `my-cdk-js-project` usando o comando `cdk init --language javascript`:  

```
my-cdk-js-project
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│   └── my-cdk-js-project.js
├── cdk.json
├── jest.config.js
├── lib
│   └── my-cdk-js-project-stack.js
├── node_modules
├── package-lock.json
├── package.json
└── test
    └── my-cdk-js-project.test.js
```  
 `.npmignore`   
Arquivo que especifica quais arquivos e pastas devem ser ignorados ao publicar um pacote no registro `npm`. Esse arquivo é semelhante ao `.gitignore`, mas é específico para pacotes `npm`.  
 `bin/my-cdk-js-project.js`   
O *arquivo da aplicação* define sua aplicação CDK. Os projetos do CDK contêm um ou mais arquivos de aplicações. Os arquivos da aplicação são armazenados na pasta `bin`.  
Veja a seguir um exemplo de um arquivo de aplicação básico que define uma aplicação do CDK:  

```
#!/usr/bin/env node

const cdk = require('aws-cdk-lib');
const { MyCdkJsProjectStack } = require('../lib/my-cdk-js-project-stack');

const app = new cdk.App();
new MyCdkJsProjectStack(app, 'MyCdkJsProjectStack');
```  
 `jest.config.js`   
Arquivo de configuração para o Jest. * O Jest* é uma estrutura popular de testes de JavaScript.  
 `lib/my-cdk-js-project-stack.js`   
O *arquivo de pilha* define sua pilha do CDK. Na sua pilha, você define os recursos da AWS e as propriedades usando constructos.  
Veja a seguir um exemplo de um arquivo de pilha básico que define uma pilha do CDK:  

```
const { Stack, Duration } = require('aws-cdk-lib');

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

  // code that defines your resources and properties go here
 }
}

module.exports = { MyCdkJsProjectStack }
```  
 `node_modules`   
Pasta comum em projetos Node.js que contêm dependências para seu projeto.  
 `package-lock.json`   
Arquivo de metadados que funcionam com o arquivo `package.json` para gerenciar versões de dependências.  
 `package.json`   
Arquivo de metadados que é comumente usado em projetos Node.js. Esse arquivo contém informações sobre seu projeto do CDK, como nome do projeto, definições de script, dependências e outras informações de importação em nível de projeto.  
 `test/my-cdk-js-project.test.js`   
Uma pasta de teste é criada para organizar os testes do seu projeto do CDK. Um arquivo de teste de amostra também é criado.  
É possível escrever testes em JavaScript e usar o Jest para compilar seu código de JavaScript antes de executar testes.
Veja a seguir um exemplo de projeto criado no diretório `my-cdk-py-project` usando o comando `cdk init --language python`:  

```
my-cdk-py-project
├── .git
├── .gitignore
├── .venv
├── README.md
├── app.py
├── cdk.json
├── my_cdk_py_project
│   ├── __init__.py
│   └── my_cdk_py_project_stack.py
├── requirements-dev.txt
├── requirements.txt
├── source.bat
└── tests
    ├── __init__.py
    └── unit
```  
 `.venv`   
A CLI do CDK cria automaticamente um ambiente virtual para seu projeto. O diretório `.venv` se refere a esse ambiente virtual.  
 `app.py`   
O *arquivo da aplicação* define sua aplicação CDK. Os projetos do CDK contêm um ou mais arquivos de aplicações.  
Veja a seguir um exemplo de um arquivo de aplicação básico que define uma aplicação do CDK:  

```
#!/usr/bin/env python3
import os

import aws_cdk as cdk

from my_cdk_py_project.my_cdk_py_project_stack import MyCdkPyProjectStack

app = cdk.App()
MyCdkPyProjectStack(app, "MyCdkPyProjectStack")

app.synth()
```  
 `my_cdk_py_project`   
O diretório que contém seus *arquivos de pilha*. A CLI do CDK cria o seguinte aqui:  
+ \$1\$1init\$1\$1.py: Um arquivo de definição de pacote Python vazio.
+  `my_cdk_py_project`: arquivo que define sua pilha do CDK. Em seguida, você define recursos da AWS e propriedades na pilha usando constructos.
Este é um exemplo de um arquivo de pilha:  

```
from aws_cdk import Stack

from constructs import Construct

class MyCdkPyProjectStack(Stack):
 def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
  super().__init__(scope, construct_id, **kwargs)

  # code that defines your resources and properties go here
```  
 `requirements-dev.txt`   
Arquivo semelhante ao `requirements.txt`, mas usado para gerenciar dependências especificamente para fins de desenvolvimento em vez de produção.  
 `requirements.txt`   
Arquivo comum usado em projetos do Python para especificar e gerenciar dependências do projeto.  
 `source.bat`   
O arquivo de lote para o Windows que é usado para configurar o ambiente virtual do Python.  
 `tests`   
Diretório que contém testes para seu projeto do CDK.  
A seguir, veja um exemplo de um teste de unidade:  

```
import aws_cdk as core
import aws_cdk.assertions as assertions

from my_cdk_py_project.my_cdk_py_project_stack import MyCdkPyProjectStack

def test_sqs_queue_created():
 app = core.App()
 stack = MyCdkPyProjectStack(app, "my-cdk-py-project")
 template = assertions.Template.from_stack(stack)

 template.has_resource_properties("AWS::SQS::Queue", {
  "VisibilityTimeout": 300
 })
```
Veja a seguir um exemplo de projeto criado no diretório `my-cdk-java-project` usando o comando `cdk init --language java`:  

```
my-cdk-java-project
├── .git
├── .gitignore
├── README.md
├── cdk.json
├── pom.xml
└── src
    ├── main
    └── test
```  
 `pom.xml`   
Arquivo que contém informações de configuração e metadados sobre seu projeto do CDK. Este arquivo faz parte do Maven.  
 `src/main`   
Diretório contenda sua aplicação** e arquivos de *pilha*.  
Este é um exemplo de um arquivo de aplicação:  

```
package com.myorg;

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

import java.util.Arrays;

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

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

  app.synth();
 }
}
```
Este é um exemplo de um arquivo de pilha:  

```
package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;

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

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

  // code that defines your resources and properties go here
 }
}
```  
 `src/test`   
Diretório contendo seus arquivos de teste. Veja um exemplo a seguir:  

```
package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.assertions.Template;
import java.io.IOException;

import java.util.HashMap;

import org.junit.jupiter.api.Test;

public class MyCdkJavaProjectTest {

 @Test
 public void testStack() throws IOException {
  App app = new App();
  MyCdkJavaProjectStack stack = new MyCdkJavaProjectStack(app, "test");

  Template template = Template.fromStack(stack);

  template.hasResourceProperties("AWS::SQS::Queue", new HashMap<String, Number>() {{
   put("VisibilityTimeout", 300);
  }});
 }
}
```
Veja a seguir um exemplo de projeto criado no diretório `my-cdk-csharp-project` usando o comando `cdk init --language csharp`:  

```
my-cdk-csharp-project
├── .git
├── .gitignore
├── README.md
├── cdk.json
└── src
    ├── MyCdkCsharpProject
    └── MyCdkCsharpProject.sln
```  
 `src/MyCdkCsharpProject`   
Diretório contenda sua aplicação** e arquivos de *pilha*.  
Este é um exemplo de um arquivo de aplicação:  

```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;

namespace MyCdkCsharpProject
{
 sealed class Program
 {
  public static void Main(string[] args)
  {
   var app = new App();
   new MyCdkCsharpProjectStack(app, "MyCdkCsharpProjectStack", new StackProps{});
   app.Synth();
  }
 }
}
```
Este é um exemplo de um arquivo de pilha:  

```
using Amazon.CDK;
using Constructs;

namespace MyCdkCsharpProject
{
 public class MyCdkCsharpProjectStack : Stack
 {
  internal MyCdkCsharpProjectStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
  {
   // code that defines your resources and properties go here
  }
 }
}
```
Esse diretório também contém o seguinte:  
  
+  `GlobalSuppressions.cs` — Arquivo usado para suprimir avisos ou erros específicos do compilador em seu projeto.
+  `.csproj`: arquivo baseado em XML usado para definir configurações de projeto, dependências e configurações de compilação. ---  
 `src/MyCdkCsharpProject.sln`   
 Microsoft Visual Studio Solution File usado para organizar e gerenciar projetos relacionados.
Veja a seguir um exemplo de projeto criado no diretório `my-cdk-go-project` usando o comando `cdk init --language go`:  

```
my-cdk-go-project
├── .git
├── .gitignore
├── README.md
├── cdk.json
├── go.mod
├── my-cdk-go-project.go
└── my-cdk-go-project_test.go
```  
 `go.mod`   
Arquivo que contém informações do módulo e é usado para gerenciar dependências e versionamento do seu projeto Go.  
 `my-cdk-go-project.go`   
Arquivo que define sua aplicação e suas pilhas do CDK.  
Veja um exemplo a seguir:  

```
package main
import (
 "github.com/aws/aws-cdk-go/awscdk/v2"
 "github.com/aws/constructs-go/constructs/v10"
 "github.com/aws/jsii-runtime-go"
)

type MyCdkGoProjectStackProps struct {
 awscdk.StackProps
}

func NewMyCdkGoProjectStack(scope constructs.Construct, id string, props *MyCdkGoProjectStackProps) awscdk.Stack {
 var sprops awscdk.StackProps
 if props != nil {
  sprops = props.StackProps
 }
 stack := awscdk.NewStack(scope, &id, &sprops)
 // The code that defines your resources and properties go here

  return stack
}

func main() {
 defer jsii.Close()
 app := awscdk.NewApp(nil)
 NewMyCdkGoProjectStack(app, "MyCdkGoProjectStack", &MyCdkGoProjectStackProps{
  awscdk.StackProps{
   Env: env(),
  },
 })
 app.Synth(nil)
}

func env() *awscdk.Environment {

 return nil
}
```  
 `my-cdk-go-project_test.go`   
Arquivo que define um teste de amostra.  
Veja um exemplo a seguir:  

```
package main

import (
 "testing"

 "github.com/aws/aws-cdk-go/awscdk/v2"
 "github.com/aws/aws-cdk-go/awscdk/v2/assertions"
 "github.com/aws/jsii-runtime-go"
)

func TestMyCdkGoProjectStack(t *testing.T) {

 // GIVEN
 app := awscdk.NewApp(nil)

 // WHEN
 stack := NewMyCdkGoProjectStack(app, "MyStack", nil)

 // THEN
 template := assertions.Template_FromStack(stack, nil)
 template.HasResourceProperties(jsii.String("AWS::SQS::Queue"), map[string]interface{}{
  "VisibilityTimeout": 300,
 })
}
```