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á.
# Começando com o AWS CDK
Comece a usar o AWS Cloud Development Kit (AWS CDK) instalando e configurando a AWS CDK Command Line Interface (CDK AWS CLI). Em seguida, use a CLI do CDK para criar seu primeiro aplicativo CDK, inicializar AWS seu ambiente e implantar seu aplicativo.
## Pré-requisitos
Antes de começar a usar o AWS CDK, preencha todos os pré-requisitos. Esses pré-requisitos são necessários para aqueles que são novatos AWS ou iniciantes em programação. Para obter instruções, consulte [Pré-requisitos do AWS CDK](prerequisites.md).
Recomendamos que você tenha uma compreensão básica do que é o AWS CDK. Para obter mais informações, consulte [O que é o AWS CDK](home.md)? e [aprenda os principais conceitos do AWS CDK](core-concepts.md).
## Instale a CLI do AWS CDK
Use o gerenciador de pacotes Node para instalar a CLI do CDK. Recomendamos que você o instale globalmente usando o seguinte comando:
```
$ npm install -g aws-cdk
```
Para instalar uma versão específica da CLI do CDK, use a estrutura de comando a seguir:
```
$ npm install -g aws-cdk@X.YY.Z
```
Se você quiser usar várias versões do AWS CDK, considere instalar uma versão correspondente da CLI do CDK em projetos individuais do CDK. Para fazer isso, remova a opção `-g` do comando `npm install`. Em seguida, use `npx aws-cdk` para invocar a CLI do CDK. Isso executará uma versão local, se ela existir. Caso contrário, a versão instalada globalmente será usada.
**Solução de problemas de instalação da CLI do CDK**
Se você receber um erro de permissão e tiver acesso de administrador em seu sistema, execute o seguinte:
```
$ sudo npm install -g aws-cdk
```
Se você receber uma mensagem de erro, tente desinstalar a CLI do CDK executando o seguinte:
```
$ npm uninstall -g aws-cdk
```
Em seguida, repita as etapas para reinstalar a CLI do CDK.
## Verifique se a instalação da CLI do CDK teve êxito
Execute os comandos a seguir para verificar se a instalação desse Java foi bem-sucedida. A CLI do AWS CDK deve gerar o número da versão:
```
$ cdk --version
```
## Configurar a CLI do AWS CDK
Depois de instalar a CLI do CDK, será possível começar a usá-la para desenvolver aplicações em sua máquina local. Para interagir com AWS, por exemplo, implantar aplicativos, você deve ter credenciais de segurança configuradas em sua máquina local com permissões para realizar qualquer ação que você iniciar.
Para configurar as credenciais de segurança em sua máquina local, você usa a AWS CLI. A forma como você configura as credenciais de segurança depende de como você gerencia os usuários. Para obter instruções, consulte [Autenticação e credenciais de acesso](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html) no *Guia do usuário da interface de linha de AWS comando*.
A CLI do CDK usará automaticamente as credenciais de segurança que você configura com a CLI. AWS Por exemplo, se você for usuário da Central de Identidade IAM, poderá usar o comando `aws configure sso` para configurar credenciais de segurança. Se você for um usuário do IAM, poderá usar o comando `aws configure`. A AWS CLI o guiará na configuração das credenciais de segurança em sua máquina local e salvará as informações necessárias em seus arquivos e. `config` `credentials` Então, ao usar a CLI do CDK, como ao implantar uma aplicação com `cdk deploy`, a CLI do CDK usará suas credenciais de segurança configuradas.
Assim como a AWS CLI, a CLI do CDK `default` usará seu perfil por padrão. É possível especificar um perfil usando a opção [`--profile`](ref-cli-cmd.md#ref-cli-cmd-options-profile) da CLI do CDK. Para obter mais informações sobre o uso de credenciais de segurança com a CLI do CDK, consulte [Configurar credenciais de segurança para](configure-access.md) a CLI do CDK. AWS
## (Opcional) Instale ferramentas AWS CDK adicionais
O [kit de ferramentas da AWS para Visual Studio Code](https://aws.amazon.com/visualstudiocode/) é um plugin de código aberto para o Visual Studio Code que ajuda você a criar, depurar e implantar aplicações na AWS. O kit de ferramentas fornece uma experiência integrada para o desenvolvimento de aplicativos AWS CDK. Ele inclui o recurso AWS CDK Explorer para listar seus projetos AWS CDK e navegar pelos vários componentes do aplicativo CDK. Para instruções, consulte:
+ [Instalando o AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html).
+ [AWS CDK para VS Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/cdk-explorer.html).
## Crie seu primeira aplicação CDK
Agora você está pronto para começar a usar o AWS CDK criando seu primeiro aplicativo CDK. Para obter instruções, consulte [Tutorial: Crie seu primeiro aplicativo AWS CDK](hello-world.md).
# Tutorial: Crie seu primeiro aplicativo AWS CDK
Comece a usar o AWS Cloud Development Kit (AWS CDK) usando a AWS CDK Command Line Interface (AWS CDK CLI) para desenvolver seu primeiro aplicativo CDK, inicializar seu ambiente e implantar AWS seu aplicativo nele. AWS
## Pré-requisitos
Antes de iniciar este tutorial, conclua todas as etapas de configuração em [Introdução ao AWS CDK](getting-started.md).
## Sobre este tutorial
Neste tutorial, você criará e implantará um aplicativo simples AWS usando o AWS CDK. A aplicação consiste em uma [função do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) que retorna uma mensagem `Hello World!` quando invocada. A função será invocada por meio de um URL de [função do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html) que serve como um endpoint HTTP(S) dedicado para sua função do Lambda.
Usando este tutorial, você fará o seguinte:
+ **Crie seu projeto**: crie um projeto do CDK usando o comando `cdk init` da CLI do CDK.
+ **Configure seu AWS ambiente** — configure o AWS ambiente no qual você implantará seu aplicativo.
+ **Inicialize seu AWS ambiente** — Prepare seu AWS ambiente para implantação inicializando-o usando o comando CLI do CDK. `cdk bootstrap`
+ **Desenvolva seu aplicativo** — Use construções da AWS Construct Library para definir sua função Lambda e os recursos de URL da função Lambda.
+ **Prepare seu aplicativo para implantação** — Use a CLI do CDK para criar seu aplicativo e AWS CloudFormation sintetizar um modelo.
+ **Implante seu aplicativo** — Use o comando CDK `cdk deploy` CLI para implantar seu aplicativo e AWS provisionar seus recursos.
+ **Interaja com seu aplicativo** — Interaja com sua função AWS Lambda implantada invocando-a e recebendo uma resposta.
+ **Modifique sua aplicação** — Modifique sua função do Lambda e implante para implementar suas alterações.
+ **Exclua sua aplicação**: exclua todos os recursos que você criou usando o comando `cdk destroy` da CLI do CDK.
## Etapa 1: criar seu projeto do CDK
Nesta etapa, você cria um novo projeto do CDK. Um projeto do CDK deve estar em seu próprio diretório, com suas próprias dependências de módulos locais.
**Para criar um projeto do CDK**
1. Em um diretório inicial de sua escolha, crie e navegue até um diretório chamado `hello-cdk`:
```
$ mkdir hello-cdk && cd hello-cdk
```
**Importante**
Certifique-se de nomear o diretório do seu projeto `hello-cdk`, *exatamente como mostrado aqui*. A CLI do CDK usa esse nome de diretório para nomear coisas dentro do seu código do CDK. Se você escolher outro nome de diretório, você terá problemas durante este tutorial.
1. A partir do diretório `hello-cdk`, inicialize um novo projeto do CDK usando o comando `cdk init` da CLI do CDK. Especifique o modelo `app` e sua linguagem de programação preferida com a opção `--language`:
**Example**
------
#### [ TypeScript ]
```
$ cdk init app --language typescript
```
------
#### [ JavaScript ]
```
$ cdk init app --language javascript
```
------
#### [ Python ]
```
$ cdk init app --language python
```
Depois que a aplicação for criado, insira também os dois comandos a seguir. Eles ativam o ambiente virtual Python do aplicativo e instalam as dependências principais do AWS CDK.
```
$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead
$ python -m pip install -r requirements.txt
```
------
#### [ Java ]
```
$ cdk init app --language java
```
Se você estiver usando um IDE, agora você pode abrir ou importar o projeto. No Eclipse, por exemplo, escolha **Arquivo** > **Importar** > **Maven** > **Projetos existentes do Maven**. Certifique-se de que as configurações do projeto estejam definidas para usar o Java 8 (1.8).
------
#### [ C\$1 ]
```
$ cdk init app --language csharp
```
Se você estiver usando o Visual Studio, abra o arquivo da solução no diretório `src`.
------
#### [ Go ]
```
$ cdk init app --language go
```
Depois que o aplicativo for criado, insira também o comando a seguir para instalar os módulos do AWS Construct Library que o aplicativo exige.
```
$ go get
```
------
O comando `cdk init` cria uma estrutura de arquivos e pastas dentro do diretório `hello-cdk` para ajudar a organizar o código-fonte da sua aplicação CDK. Essa estrutura de arquivos e pastas é chamada de *projeto do CDK*. Reserve um momento para explorar seu projeto do CDK.
Se você instalou o Git, cada projeto que você cria usando também `cdk init` é inicializado como um repositório Git.
Durante a inicialização do projeto, a CLI do CDK cria uma aplicação do CDK contendo uma única pilha do CDK. A instância da aplicação do CDK é criada usando o constructo [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html). A seguir está uma parte desse código do seu arquivo de aplicação CDK:
**Example**
Localizado em `bin/hello-cdk.ts`:
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});
```
Localizado em `bin/hello-cdk.js`:
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});
```
Localizado em `app.py`:
```
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from hello_cdk.hello_cdk_stack import HelloCdkStack
app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",)
app.synth()
```
Localizado em `src/main/java/…/HelloCdkApp.java`:
```
package com.myorg;
import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;
import java.util.Arrays;
public class HelloCdkApp {
public static void main(final String[] args) {
App app = new App();
new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
.build());
app.synth();
}
}
```
Localizado em `src/HelloCdk/Program.cs`:
```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace HelloCdk
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new HelloCdkStack(app, "HelloCdkStack", new StackProps
{});
app.Synth();
}
}
}
```
Localizado em `hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
// ...
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
// ...
```
A pilha do CDK é criada usando o constructo [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html). A seguir está uma parte desse código do seu arquivo de pilha CDK:
**Example**
Localizado em `lib/hello-cdk-stack.ts`:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define your constructs here
}
}
```
Localizado em `lib/hello-cdk-stack.js`:
```
const { Stack } = require('aws-cdk-lib');
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define your constructs here
}
}
module.exports = { HelloCdkStack }
```
Localizado em `hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
Stack,
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define your constructs here
```
Localizado em `src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
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);
// Define your constructs here
}
}
```
Localizado em `src/HelloCdk/HelloCdkStack.cs`:
```
using Amazon.CDK;
using Constructs;
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define your constructs here
}
}
}
```
Localizado em `hello-cdk.go`:
```
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 HelloCdkStackProps struct {
awscdk.StackProps
}
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)
return stack
}
// ...
```
## Etapa 2: configurar seu AWS ambiente
Nesta etapa, você configura o AWS ambiente para sua pilha de CDK. Ao fazer isso, você especifica em qual ambiente sua pilha do CDK será implantada.
Primeiro, determine o AWS ambiente que você deseja usar. Um AWS ambiente consiste em uma AWS conta e uma AWS região.
Ao usar a AWS CLI para configurar as credenciais de segurança em sua máquina local, você pode usar a AWS CLI para obter informações de AWS ambiente para um perfil específico.
**Para usar a AWS CLI para obter o ID da sua conta AWS **
1. Execute o seguinte comando da AWS CLI para obter o ID da AWS conta do seu `default` perfil:
```
$ aws sts get-caller-identity --query "Account" --output text
```
1. Se você preferir usar um perfil nomeado, forneça o nome do seu perfil usando a opção `--profile`:
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```
**Para usar a AWS CLI para obter sua região AWS **
1. Execute o seguinte comando da AWS CLI para obter a região que você configurou para seu `default` perfil:
```
$ aws configure get region
```
1. Se você preferir usar um perfil nomeado, forneça o nome do seu perfil usando a opção `--profile`:
```
$ aws configure get region --profile your-profile-name
```
*Em seguida, você configurará o AWS ambiente para sua pilha de CDK modificando a `HelloCdkStack` instância no arquivo do aplicativo.* Neste tutorial, você codificará as informações do seu AWS ambiente. Isso não é recomendado para ambientes de produção. Para obter informações sobre outras formas de configurar ambientes, consulte [Configurar ambientes para uso com o AWS CDK](configure-env.md).
**Configurar o ambiente para sua pilha do CDK**
1. No seu *arquivo da aplicação*, use a propriedade `env` do constructo `Stack` para configurar seu ambiente. Este é um exemplo:
**Example**
------
#### [ TypeScript ]
Localizado em `bin/hello-cdk.ts`:
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
env: { account: '123456789012', region: 'us-east-1' },
});
```
------
#### [ JavaScript ]
Localizado em `bin/hello-cdk.js`:
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
env: { account: '123456789012', region: 'us-east-1' },
});
```
------
#### [ Python ]
Localizado em `app.py`:
```
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from hello_cdk.hello_cdk_stack import HelloCdkStack
app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",
env=cdk.Environment(account='123456789012', region='us-east-1'),
)
app.synth()
```
------
#### [ Java ]
Localizado em `src/main/java/…/HelloCdkApp.java`:
```
package com.myorg;
import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;
import java.util.Arrays;
public class HelloCdkApp {
public static void main(final String[] args) {
App app = new App();
new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
.env(Environment.builder()
.account("123456789012")
.region("us-east-1")
.build())
.build());
app.synth();
}
}
```
------
#### [ C\$1 ]
Localizado em `src/HelloCdk/Program.cs`:
```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace HelloCdk
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new HelloCdkStack(app, "HelloCdkStack", new StackProps
{
Env = new Amazon.CDK.Environment
{
Account = "123456789012",
Region = "us-east-1",
}
});
app.Synth();
}
}
}
```
------
#### [ Go ]
Localizado em `hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
// ...
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
func env() *awscdk.Environment {
return &awscdk.Environment{
Account: jsii.String("123456789012"),
Region: jsii.String("us-east-1"),
}
}
```
------
## Etapa 3: inicialize seu ambiente AWS
Nesta etapa, você inicializa o AWS ambiente que você configurou na etapa anterior. Isso prepara seu ambiente para implantações do CDK.
Para inicializar seu ambiente, execute o seguinte a partir da raiz do seu projeto do CDK:
```
$ cdk bootstrap
```
Ao fazer o bootstrapping a partir da raiz do seu projeto do CDK, você não precisa fornecer nenhuma informação adicional. A CLI do CDK obtém informações sobre o ambiente do seu projeto. Ao fazer o bootstrapping fora de um projeto do CDK, é necessário fornecer informações do ambiente com o comando `cdk bootstrap`. Para obter mais informações, consulte [Inicialize seu ambiente para uso com o AWS CDK](bootstrapping-env.md).
## Etapa 4: compilar sua aplicação do CDK
Na maioria dos ambientes de programação, você cria ou compila o código depois de fazer alterações. Isso não é necessário com o AWS CDK, pois a CLI do CDK executará automaticamente essa etapa. No entanto, você ainda pode criar manualmente quando quiser detectar erros de sintaxe e tipo. Este é um exemplo:
**Example**
```
$ npm run build
> hello-cdk@0.1.0 build
> tsc
```
Nenhuma etapa de compilação é necessária.
Nenhuma etapa de compilação é necessária.
```
$ mvn compile -q
```
Ou pressione `Control-B` no Eclipse (outros Java IDEs podem variar)
```
$ dotnet build src
```
Ou pressione F6 no Visual Studio
```
$ go build
```
## Etapa 5: listar as pilhas do CDK em sua aplicação
Neste momento, é preciso ter uma aplicação CDK contendo uma única pilha do CDK. Para verificar, use o comando `cdk list` da CLI do CDK para exibir suas pilhas. A saída deve exibir uma única pilha chamada `HelloCdkStack`:
```
$ cdk list
HelloCdkStack
```
Se não vir essa saída, verifique se você está no diretório de trabalho correto do projeto e tente novamente. Se você ainda não vir sua pilha, repita a [Etapa 1: criação do seu projeto do CDK](#hello-world-create) e tente novamente.
## Etapa 6: definir sua função do Lambda
Nesta etapa, você importa o [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)módulo da AWS Construct Library e usa a construção [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)L2.
Modifique seu arquivo de pilha do CDK da seguinte forma:
**Example**
Localizado em `lib/hello-cdk-stack.ts`:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import the Lambda module
import * as lambda from 'aws-cdk-lib/aws-lambda';
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`),
});
}
}
```
Localizado em `lib/hello-cdk-stack.js`:
```
const { Stack } = require('aws-cdk-lib');
// Import the Lambda module
const lambda = require('aws-cdk-lib/aws-lambda');
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`),
});
}
}
module.exports = { HelloCdkStack }
```
Localizado em `hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
Stack,
aws_lambda as _lambda, # Import the Lambda module
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
my_function = _lambda.Function(
self, "HelloWorldFunction",
runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
handler = "index.handler",
code = _lambda.Code.from_inline(
"""
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
"""
),
)
```
Localizado em `src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
// Import Lambda function
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;
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);
// Define the Lambda function resource
Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
.runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
.handler("index.handler")
.code(Code.fromInline(
"exports.handler = async function(event) {" +
" return {" +
" statusCode: 200," +
" body: JSON.stringify('Hello World!')" +
" };" +
"};"))
.build();
}
}
```
Localizado em `src/main/java/…/HelloCdkStack.java`:
```
using Amazon.CDK;
using Constructs;
// Import the Lambda module
using Amazon.CDK.AWS.Lambda;
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
Handler = "index.handler",
Code = Code.FromInline(@"
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
"),
});
}
}
}
```
Localizado em `hello-cdk.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
// Import the Lambda module
"github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
)
type HelloCdkStackProps struct {
awscdk.StackProps
}
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)
// Define the Lambda function resource
myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
Handler: jsii.String("index.handler"),
Code: awslambda.Code_FromInline(jsii.String(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`)),
})
return stack
}
// ...
```
Vamos analisar o constructo `Function` mais de perto. Como todos os constructos, a classe `Function` usa três parâmetros:
+ **escopo** — Define sua instância `Stack` como pai do constructo `Function`. Todas as construções que definem AWS recursos são criadas dentro do escopo de uma pilha. É possível definir constructos dentro de constructos, criando uma hierarquia (árvore). Aqui, e na maioria dos casos, o escopo é `this` (`self` em Python).
+ **Id** — O ID de construção do `Function` dentro do seu aplicativo AWS CDK. Esse ID, mais um hash baseado na localização da função na pilha, identifica exclusivamente a função durante a implantação. O AWS CDK também faz referência a essa ID quando você atualiza a construção em seu aplicativo e reimplanta para atualizar o recurso implantado. Aqui, seu ID de constructo é `HelloWorldFunction`. As funções também podem ter um nome, especificado com a propriedade `functionName`. Isto é diferente do ID do constructo.
+ **props** — Um pacote de valores que define as propriedades da função. Aqui você define as propriedades `runtime`, `handler` e `code`.
Os adereços são representados de forma diferente nas linguagens suportadas pelo AWS CDK.
+ In TypeScript and JavaScript, `props` é um único argumento e você passa um objeto contendo as propriedades desejadas.
+ No Python, os props são passados como argumentos de palavras-chave.
+ No Java, um Construtor é fornecido para passar os props. Existem dois: um para o `FunctionProps` e um segundo para o `Function` para permitir que você construa o constructo e seu objeto de props em uma única etapa. Esse código usa o último.
+ Em C\$1, você instancia um objeto `FunctionProps` usando um inicializador de objetos e o passa como terceiro parâmetro.
Se os props de um constructo forem opcionais, será possível omitir totalmente o parâmetro `props`.
Todos os constructos usam esses mesmos três argumentos, então é fácil se manter orientado à medida que você aprende sobre argumentos novos. E, como era de se esperar, você pode subclassificar qualquer constructo para estendê-lo de acordo com suas necessidades ou se quiser alterar seus padrões.
## Etapa 7: Definir seu URL da função do Lambda
Nesta etapa, você usa o método auxiliar `addFunctionUrl` do constructo `Function` para definir o URL de uma função do Lambda. Para gerar o valor dessa URL na implantação, você criará uma AWS CloudFormation saída usando a [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)construção.
Adicione o seguinte ao seu arquivo de pilha CDK:
**Example**
Localizado em `lib/hello-cdk-stack.ts`:
```
// ...
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new cdk.CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
```
Localizado em `lib/hello-cdk-stack.js`:
```
const { Stack, CfnOutput } = require('aws-cdk-lib'); // Import CfnOutput
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
module.exports = { HelloCdkStack }
```
Localizado em `hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
# ...
CfnOutput # Import CfnOutput
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
# ...
# Define the Lambda function URL resource
my_function_url = my_function.add_function_url(
auth_type = _lambda.FunctionUrlAuthType.NONE,
)
# Define a CloudFormation output for your URL
CfnOutput(self, "myFunctionUrlOutput", value=my_function_url.url)
```
Localizado em `src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
// ...
// Import Lambda function URL
import software.amazon.awscdk.services.lambda.FunctionUrl;
import software.amazon.awscdk.services.lambda.FunctionUrlAuthType;
import software.amazon.awscdk.services.lambda.FunctionUrlOptions;
// Import CfnOutput
import software.amazon.awscdk.CfnOutput;
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);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
FunctionUrl myFunctionUrl = myFunction.addFunctionUrl(FunctionUrlOptions.builder()
.authType(FunctionUrlAuthType.NONE)
.build());
// Define a CloudFormation output for your URL
CfnOutput.Builder.create(this, "myFunctionUrlOutput")
.value(myFunctionUrl.getUrl())
.build();
}
}
```
Localizado em `src/main/java/…/HelloCdkStack.java`:
```
// ...
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
var myFunctionUrl = myFunction.AddFunctionUrl(new FunctionUrlOptions
{
AuthType = FunctionUrlAuthType.NONE
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", new CfnOutputProps
{
Value = myFunctionUrl.Url
});
}
}
}
```
Localizado em `hello-cdk.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)
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
myFunctionUrl := myFunction.AddFunctionUrl(&awslambda.FunctionUrlOptions{
AuthType: awslambda.FunctionUrlAuthType_NONE,
})
// Define a CloudFormation output for your URL
awscdk.NewCfnOutput(stack, jsii.String("myFunctionUrlOutput"), &awscdk.CfnOutputProps{
Value: myFunctionUrl.Url(),
})
return stack
}
// ...
```
**Atenção**
Para manter esse tutorial simples, o URL da função do Lambda é definido sem autenticação. Quando implantado, isso cria um endpoint acessível ao público que pode ser usado para invocar sua função. Ao concluir este tutorial, siga a [Etapa 12: exclusão da sua aplicação](#hello-world-delete) para excluir esses recursos.
## Etapa 8: sintetizar um modelo CloudFormation
Nesta etapa, você se prepara para a implantação sintetizando um CloudFormation modelo com o comando CLI `cdk synth` do CDK. Esse comando executa a validação básica do seu código CDK, executa seu aplicativo CDK e gera um CloudFormation modelo da sua pilha de CDK.
Se sua aplicação contiver mais de uma pilha, você deverá especificar quais pilhas sintetizar. Como sua aplicação contém uma única pilha, a CLI do CDK detecta automaticamente a pilha a sintetizar.
Se você não sintetizar um modelo, a CLI do CDK executará automaticamente essa etapa quando você implantar. No entanto, recomendamos executar essa etapa antes de cada implantação para verificar se há erros de síntese.
Antes de sintetizar um modelo, você pode, opcionalmente, criar sua aplicação para capturar erros de sintaxe e de tipo. Para obter instruções, consulte [Etapa 4: compilação da sua aplicação do CDK](#hello-world-build).
Para sintetizar um CloudFormation modelo, execute o seguinte a partir da raiz do seu projeto:
```
$ cdk synth
```
**nota**
Se você receber um erro como o seguinte, verifique se você está no diretório `hello-cdk` e tente novamente:
```
--app is required either in command-line, in cdk.json or in ~/.cdk.json
```
Se for bem-sucedida, a CLI do CDK exibirá `YAML` um modelo CloudFormation —formatado e salvará `JSON` um modelo `stdout` —formatado no diretório do seu projeto. `cdk.out`
Veja a seguir um exemplo de saída do CloudFormation modelo:
### AWS CloudFormation modelo
```
Resources:
HelloWorldFunctionServiceRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Statement:
- Action: sts:AssumeRole
Effect: Allow
Principal:
Service: lambda.amazonaws.com
Version: "2012-10-17"
ManagedPolicyArns:
- Fn::Join:
- ""
- - "arn:"
- Ref: AWS::Partition
- :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/ServiceRole/Resource
HelloWorldFunction:
Type: AWS::Lambda::Function
Properties:
Code:
ZipFile: "
\ exports.handler = async function(event) {
\ return {
\ statusCode: 200,
\ body: JSON.stringify('Hello World!'),
\ };
\ };
\ "
Handler: index.handler
Role:
Fn::GetAtt:
- HelloWorldFunctionServiceRole
- Arn
Runtime: nodejs20.x
DependsOn:
- HelloWorldFunctionServiceRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
HelloWorldFunctionFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: NONE
TargetFunctionArn:
Fn::GetAtt:
- HelloWorldFunction
- Arn
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
HelloWorldFunctioninvokefunctionurl:
Type: AWS::Lambda::Permission
Properties:
Action: lambda:InvokeFunctionUrl
FunctionName:
Fn::GetAtt:
- HelloWorldFunction
- Arn
FunctionUrlAuthType: NONE
Principal: "*"
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Analytics: v2:deflate64:
Metadata:
aws:cdk:path: HelloCdkStack/CDKMetadata/Default
Condition: CDKMetadataAvailable
Outputs:
myFunctionUrlOutput:
Value:
Fn::GetAtt:
- HelloWorldFunctionFunctionUrl
- FunctionUrl
Parameters:
BootstrapVersion:
Type: AWS::SSM::Parameter::Value
Default: /cdk-bootstrap//version
Description: Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]
Rules:
CheckBootstrapVersion:
Assertions:
- Assert:
Fn::Not:
- Fn::Contains:
- - "1"
- "2"
- "3"
- "4"
- "5"
- Ref: BootstrapVersion
AssertDescription: CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI.
```
**nota**
Cada modelo gerado contém um recurso ` AWS::CDK::Metadata` por padrão. A equipe do AWS CDK usa esses metadados para obter informações sobre o uso do AWS CDK e encontrar maneiras de melhorá-lo. Para obter detalhes, incluindo como optar por não receber relatórios de versão, consulte [Relatórios de versão](cli.md#version-reporting).
Ao definir uma única construção L2, o AWS CDK cria um CloudFormation modelo extenso contendo seus recursos do Lambda, junto com as permissões e a lógica de colagem necessárias para que seus recursos interajam com seu aplicativo.
## Etapa 9: Implantar sua pilha do CDK
Nesta etapa, você usa o comando `cdk deploy` da CLI do CDK para implantar sua pilha do CDK. Esse comando recupera seu CloudFormation modelo gerado e o implanta por meio dele AWS CloudFormation, que provisiona seus recursos como parte de uma CloudFormation pilha.
Da raiz do seu projeto, execute o seguinte. Confirme as alterações, se solicitado:
```
$ cdk deploy
✨ Synthesis time: 2.69s
HelloCdkStack: start: Building :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
This deployment will make potentially sensitive changes according to your current security approval level (--require-approval broadening).
Please confirm you intend to make the following modifications:
IAM Statement Changes
┌───┬───────────────────────────────────────┬────────┬──────────────────────────┬──────────────────────────────┬───────────┐
│ │ Resource │ Effect │ Action │ Principal │ Condition │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction.Arn} │ Allow │ lambda:InvokeFunctionUrl │ * │ │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction/ServiceRole.Arn} │ Allow │ sts:AssumeRole │ Service:lambda.amazonaws.com │ │
└───┴───────────────────────────────────────┴────────┴──────────────────────────┴──────────────────────────────┴───────────┘
IAM Policy Changes
┌───┬───────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐
│ │ Resource │ Managed Policy ARN │
├───┼───────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤
│ + │ ${HelloWorldFunction/ServiceRole} │ arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole │
└───┴───────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)
Do you wish to deploy these changes (y/n)? y
```
Da mesma forma`cdk synth`, você não precisa especificar a pilha AWS CDK, pois o aplicativo contém uma única pilha.
Durante a implantação, a CLI do CDK exibirá informações de andamento à medida que sua pilha é implantada. Quando terminar, você pode acessar o [console do AWS CloudFormation ](https://console.aws.amazon.com/cloudformation/home) para ver sua pilha `HelloCdkStack`. Você também pode acessar o console Lambda para ver seu recurso `HelloWorldFunction`.
Quando a implantação for concluída, a CLI do CDK exibirá o URL do seu endpoint. Copie esse URL para a próxima etapa. Este é um exemplo:
```
...
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 41.65s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 44.34s
```
## Etapa 10: Interaja com seu aplicativo em AWS
Nesta etapa, você interage com seu aplicativo AWS invocando sua função Lambda por meio do URL da função. Quando você acessa o URL, sua função do Lambda retorna a mensagem `Hello World!`.
Para invocar sua função, acesse o URL da função pelo navegador ou pela linha de comando. Este é um exemplo:
```
$ curl https://.lambda-url..on.aws/
"Hello World!"%
```
## Etapa 11: Modificar sua aplicação
Nesta etapa, você modifica a mensagem que a função do Lambda retorna quando invocada. Você executa uma comparação usando o comando `cdk diff` da CLI do CDK para visualizar suas alterações e implantar para atualizar sua aplicação. Em seguida, você interage com seu aplicativo AWS para ver sua nova mensagem.
Modifique a instância `myFunction` em seu arquivo de pilha do CDK da seguinte forma:
**Example**
Localizado em `lib/hello-cdk-stack.ts`:
```
// ...
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Modify the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`),
});
// ...
}
}
```
Localizado em `lib/hello-cdk-stack.js`:
```
// ...
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Modify the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`),
});
// ...
}
}
module.exports = { HelloCdkStack }
```
Localizado em `hello_cdk/hello_cdk_stack.py`:
```
# ...
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Modify the Lambda function resource
my_function = _lambda.Function(
self, "HelloWorldFunction",
runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
handler = "index.handler",
code = _lambda.Code.from_inline(
"""
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
"""
),
)
# ...
```
Localizado em `src/main/java/…/HelloCdkStack.java`:
```
// ...
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);
// Modify the Lambda function resource
Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
.runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
.handler("index.handler")
.code(Code.fromInline(
"exports.handler = async function(event) {" +
" return {" +
" statusCode: 200," +
" body: JSON.stringify('Hello CDK!')" +
" };" +
"};"))
.build();
// ...
}
}
```
```
// ...
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Modify the Lambda function resource
var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
Handler = "index.handler",
Code = Code.FromInline(@"
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
"),
});
// ...
}
}
}
```
```
// ...
type HelloCdkStackProps struct {
awscdk.StackProps
}
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)
// Modify the Lambda function resource
myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
Handler: jsii.String("index.handler"),
Code: awslambda.Code_FromInline(jsii.String(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`)),
})
// ...
}
```
Atualmente, suas alterações de código não fizeram nenhuma atualização direta em seu recurso Lambda implantado. Seu código define o estado desejado do seu recurso. Para modificar seu recurso implantado, você usará a CLI do CDK para sintetizar o estado desejado em um novo modelo. AWS CloudFormation Em seguida, você implantará seu novo CloudFormation modelo como um conjunto de alterações. Os conjuntos de alterações fazem somente as alterações necessárias para alcançar o novo estado desejado.
Para visualizar suas alterações, execute o comando `cdk diff`. Este é um exemplo:
```
$ cdk diff
Stack HelloCdkStack
Hold on while we create a read-only change set to get a diff with accurate replacement information (use --no-change-set to use a less accurate but faster template-only diff)
Resources
[~] AWS::Lambda::Function HelloWorldFunction HelloWorldFunction
└─ [~] Code
└─ [~] .ZipFile:
├─ [-]
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
└─ [+]
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
✨ Number of stacks with differences: 1
```
Para criar essa diferença, a CLI do CDK consulta sua AWS conta para obter o modelo mais recente AWS CloudFormation para a pilha. `HelloCdkStack` Em seguida, ele compara o modelo mais recente com o modelo que acabou de sintetizar da sua aplicação.
Para implementar suas alterações, execute o comando `cdk deploy`. Este é um exemplo:
```
$ cdk deploy
✨ Synthesis time: 2.12s
HelloCdkStack: start: Building :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 26.96s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 29.07s
```
Para interagir com sua aplicação, repita a [Etapa 10: interação com sua aplicação na AWS](#hello-world-interact). Este é um exemplo:
```
$ curl https://.lambda-url..on.aws/
"Hello CDK!"%
```
## Etapa 12: Excluir sua aplicação
Nesta etapa, você usa o comando `cdk destroy` da CLI do CDK para excluir sua aplicação. Esse comando exclui a CloudFormation pilha associada à sua pilha CDK, que inclui os recursos que você criou.
Para excluir sua aplicação, execute o comando `cdk destroy` e confirme sua solicitação para excluir a aplicação. Este é um exemplo:
```
$ cdk destroy
Are you sure you want to delete: HelloCdkStack (y/n)? y
HelloCdkStack: destroying... [1/1]
✅ HelloCdkStack: destroyed
```
## Próximas etapas
Parabéns\$1 Você concluiu este tutorial e usou o AWS CDK para criar, modificar e excluir recursos na AWS nuvem com sucesso. Agora você está pronto para começar a usar o AWS CDK.
Para saber mais sobre como usar o AWS CDK em sua linguagem de programação preferida, consulte [Trabalhar com a biblioteca AWS CDK](work-with.md).
Para recursos adicionais, consulte o seguinte:
+ Experimente o [CDK Workshop](https://cdkworkshop.com/) para um tour mais aprofundado envolvendo um projeto mais complexo.
+ Consulte a [referência da API](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) para começar a explorar as construções de CDK disponíveis para seus serviços favoritos AWS .
+ Visite o [Construct Hub](https://constructs.dev/search?q=&cdk=aws-cdk&cdkver=2&sort=downloadsDesc&offset=0) para descobrir construções criadas por AWS e outros.
+ Explore [exemplos](https://github.com/aws-samples/aws-cdk-examples) de uso do AWS CDK.
O AWS CDK é um projeto de código aberto. Para contribuir, consulte [Contribuindo com o AWS Cloud Development Kit (AWS CDK)](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md).