这是 AWS CDK v2 开发者指南。旧版 CDK v1 于 2022 年 6 月 1 日进入维护阶段，并于 2023 年 6 月 1 日终止支持。
本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# AWS CDK 入门
通过安装和配置 CDK 命令行接口 (AWS CDK CLI) 开始使用 AWS 云开发套件 ( AWS CD AWS K)。然后，使用 CDK CLI 创建您的第一个 CDK 应用程序，引导您的 AWS 环境并部署您的应用程序。
## 先决条件
在开始使用 AWS CDK 之前，请完成所有先决条件。对于那些不熟悉编程 AWS 或不熟悉编程的人来说，这些先决条件是必需的。有关说明，请参阅 [AWS CDK 先决条件](prerequisites.md)。
我们建议您对 AWS CDK 有基本的了解。有关更多信息，请参阅[什么是 AWS CDK](home.md)？ 并[学习 AWS CDK 的核心概念](core-concepts.md)。
## 安装 AWS CDK CLI
使用 Node 程序包管理器安装 CDK CLI。我们建议您使用以下命令进行全局安装：
```
$ npm install -g aws-cdk
```
要安装 CDK CLI 的特定版本，请使用以下命令结构：
```
$ npm install -g aws-cdk@X.YY.Z
```
如果要使用多个版本的 AWS CDK，可以考虑在单个 CDK 项目中安装匹配版本的 CDK CLI。为此，请从 `npm install` 命令中删除 `-g` 选项。然后，使用 `npx aws-cdk` 调用 CDK CLI。这将运行本地版本（如有）。否则，将使用全局安装的版本。
**排查 CDK CLI 安装问题**
如果遇到权限错误，并且在系统上拥有管理员访问权限，请运行以下命令：
```
$ sudo npm install -g aws-cdk
```
如果收到错误消息，请运行以下命令以尝试卸载 CDK CLI：
```
$ npm uninstall -g aws-cdk
```
然后，重复步骤以重新安装 CDK CLI。
## 验证 CDK CLI 安装是否成功
运行以下命令，以验证安装是否成功。 AWS CDK CLI 应输出版本号：
```
$ cdk --version
```
## 配置 AWS CDK CLI
安装 CDK CLI 后，您可以开始使用它在本地机器上开发应用程序。要与 AWS之交互（例如部署应用程序），您必须在本地计算机上配置安全证书，并有权执行您启动的任何操作。
要在本地计算机上配置安全证书，请使用 AWS CLI。如何配置安全凭证取决于您如何管理用户。有关说明，请参阅《* AWS 命令行界面用户指南*》中的[身份验证和访问凭证](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html)。
CDK CLI 将自动使用您在 C AWS LI 中配置的安全证书。例如，如果您是 IAM Identity Center 用户，则可以使用 `aws configure sso` 命令配置安全凭证。如果您是 IAM 用户，则可以使用 `aws configure` 命令。 AWS CLI 将指导您在本地计算机上配置安全证书，并将必要信息保存在`config`和`credentials`文件中。然后，当您使用 CDK CLI 时（例如使用 `cdk deploy` 部署应用程序时），CDK CLI 将使用您配置的安全凭证。
就像 AWS CLI 一样，CDK CLI 将默认使用您的`default`个人资料。您可以使用 CDK CLI [`--profile`](ref-cli-cmd.md#ref-cli-cmd-options-profile) 选项指定配置文件。有关在 CDK CLI 中使用安全证书的更多信息，请参阅[为 CDK CL AWS I 配置安全凭证](configure-access.md)。
## （可选）安装其他 AWS CDK 工具
[AWS Toolkit for Visual Studio Code](https://aws.amazon.com/visualstudiocode/) 是适用于 Visual Studio Code 的开源插件，有助于您在 AWS上创建、调试和部署应用程序。该工具包为开发 AWS CDK 应用程序提供了集成体验。它包括 AWS CDK Explorer 功能，用于列出您的 AWS CDK 项目并浏览 CDK 应用程序的各个组件。有关说明，请参阅：
+ [安装适用于 Visual Studio 代码的 AWS 工具包](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html)。
+ [AWS VS Code 的 CDK](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/cdk-explorer.html)。
## 创建第一个 CDK 应用程序
现在，您可以通过创建自己的第一个 AWS CDK 应用程序开始使用 CDK 了。有关说明，请参阅[教程：创建您的第一个 AWS CDK 应用程序](hello-world.md)。
# 教程：创建你的第一个 AWS CDK 应用程序
开始使用 C AWS loud Development Kit (AWS AWS CDK)，使用 CDK 命令行界面 (CD AWS K CLI) 开发您的第一个 CDK 应用程序、引导 AWS 您的环境并在上部署应用程序。 AWS
## 先决条件
在开始本教程之前，请完成 [AWS CDK 入门](getting-started.md)中的所有设置步骤。
## 关于本教程
在本教程中，您将 AWS 使用 AWS CDK创建和部署一个简单的应用程序。该应用程序由一个 [AWS Lambda 函数](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)组成，调用该函数会返回一条 `Hello World!` 消息。该函数将通过 [Lambda 函数 URL](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html) 调用，该网址充当 Lambda 函数的专用 HTTP（S）端点。
在本教程中，您将执行以下操作：
+ **创建您的项目**：使用 CDK CLI `cdk init` 命令创建 CDK 项目。
+ **配置您的 AWS 环境**-配置要将应用程序部署到的 AWS 环境。
+ **引导您的 AWS 环境**-使用 CDK CLI 命令引导您的 AWS 环境，为部署做好准备。`cdk bootstrap`
+ **开发您的应用程序**-使用构造库中的构造来定义您的 AWS Lambda 函数和 Lambda 函数 URL 资源。
+ 为@@ **应用程序做好部署准备**-使用 CDK CLI 构建您的应用程序并合成模板。 AWS CloudFormation
+ **部署您的应用程序**-使用 CDK CLI `cdk deploy` 命令部署您的应用程序并配置您的 AWS 资源。
+ **与您的应用程序交互**- AWS 通过调用已部署的 Lambda 函数并接收响应，与该函数进行交互。
+ **修改应用程序**：修改 Lambda 函数并部署以实现更改。
+ **删除应用程序**：删除使用 CDK CLI `cdk destroy` 命令创建的所有资源。
## 步骤 1：创建 CDK 项目
在此步骤中，您将新建一个 CDK 项目。CDK 项目应位于自己的目录中，并具有自己的本地模块依赖关系。
**创建 CDK 项目**
1. 在您选择的起始目录中，创建并导航到名为 `hello-cdk` 的目录：
```
$ mkdir hello-cdk && cd hello-cdk
```
**重要**
请务必*完全按照此处所示*命名项目目录 `hello-cdk`。CDK CLI 使用此目录名命名 CDK 代码中的内容。如果您使用了其他目录名称，则在本教程中将遇到问题。
1. 在 `hello-cdk` 目录中，使用 CDK CLI`cdk init` 命令初始化新的 CDK 项目。使用以下 `--language` 选项指定 `app` 模板和首选编程语言：
**Example**
------
#### [ TypeScript ]
```
$ cdk init app --language typescript
```
------
#### [ JavaScript ]
```
$ cdk init app --language javascript
```
------
#### [ Python ]
```
$ cdk init app --language python
```
创建应用程序后，还应输入以下两条命令。它们会激活应用程序的 Python 虚拟环境并安装 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
```
如果您使用的是 IDE，现在可以打开或导入项目了。例如，在 Eclipse 中，依次选择**文件** > **导入** > **Maven** > **现有的 Maven 项目**。确保将项目设置设为使用 Java 8（1.8）。
------
#### [ C\$1 ]
```
$ cdk init app --language csharp
```
如果您使用的是 Visual Studio，请在 `src` 目录中打开解决方案文件。
------
#### [ Go ]
```
$ cdk init app --language go
```
创建应用程序后，还要输入以下命令来安装该应用程序所需的 AWS 构造库模块。
```
$ go get
```
------
`cdk init` 命令会在 `hello-cdk` 目录中创建文件和文件夹的结构，以帮助组织 CDK 应用程序的源代码。这种文件和文件夹的结构称为 CDK *项目*。花点时间探索 CDK 项目。
如果您已安装 Git，则使用 `cdk init` 创建的每个项目也会初始化为 Git 存储库。
在项目初始化过程中，CDK CLI 会创建一个包含单个 CDK 堆栈的 CDK 应用程序。CDK 应用程序实例是使用 [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) 构造创建的。以下内容是 CDK 应用程序文件的一部分相关代码：
**Example**
位于 `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', {
});
```
位于 `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', {
});
```
位于 `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()
```
位于 `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();
}
}
```
位于 `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();
}
}
}
```
位于 `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)
}
// ...
```
CDK 堆栈是使用 [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) 构造创建的。以下内容是 CDK 堆栈文件的一部分相关代码：
**Example**
位于 `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
}
}
```
位于 `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 }
```
位于 `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
```
位于 `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
}
}
```
位于 `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
}
}
}
```
位于 `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
}
// ...
```
## 步骤 2：配置您的 AWS 环境
在此步骤中，您将为 CDK 堆栈配置 AWS 环境。通过这样做，您可以指定要将 CDK 堆栈部署到哪个环境。
首先，确定要使用的 AWS 环境。 AWS 环境由 AWS 账户和 AWS 区域组成。
使用 AWS CLI 在本地计算机上配置安全证书时，可以使用 AWS CLI 获取特定配置文件的 AWS 环境信息。
**使用 AWS CLI 获取您的 AWS 账户 ID**
1. 运行以下 AWS CLI 命令以获取您的`default`个人资料的 AWS 账户 ID：
```
$ aws sts get-caller-identity --query "Account" --output text
```
1. 如果您更喜欢使用命名配置文件，请使用 `--profile` 选项提供配置文件的名称：
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```
**使用 AWS CLI 获取您的 AWS 区域**
1. 运行以下 AWS CLI 命令以获取您为`default`个人资料配置的区域：
```
$ aws configure get region
```
1. 如果您更喜欢使用命名配置文件，请使用 `--profile` 选项提供配置文件的名称：
```
$ aws configure get region --profile your-profile-name
```
接下来，您将通过修改*应用程序文件*中的`HelloCdkStack`实例来配置 CDK 堆栈的 AWS 环境。在本教程中，您将对 AWS 环境信息进行硬编码。不建议在生产环境中这样做。有关配置环境的其他方法的信息，请参阅[配置要与 AWS CDK 配合使用的环境](configure-env.md)。
**为您的 CDK 堆栈配置环境**
1. 在*应用程序文件*中，使用 `Stack` 构造的 `env` 属性配置环境。以下是示例：
**Example**
------
#### [ TypeScript ]
位于 `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 ]
位于 `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 ]
位于 `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 ]
位于 `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 ]
位于 `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 ]
位于 `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"),
}
}
```
------
## 第 3 步：引导您的环境 AWS
在此步骤中，您将引导您在上一步中配置的 AWS 环境。这会让您的环境为 CDK 部署做好准备。
要引导环境，请从 CDK 项目的根目录运行以下命令：
```
$ cdk bootstrap
```
通过从 CDK 项目的根目录进行引导，您无需提供任何其他信息。CDK CLI 会从项目中获取环境信息。在 CDK 项目之外进行引导时，必须使用 `cdk bootstrap` 命令提供环境信息。有关更多信息，请参阅[引导您的环境以与 AWS CDK 配合使用](bootstrapping-env.md)。
## 步骤 4：构建 CDK 应用程序
在大多数编程环境中，都是在进行更改后生成或编译代码。对于 CDK 来说，这不是必需的，因为 AWS CDK CLI 会自动执行此步骤。但是，当您想捕获语法和类型错误时，仍然可以手动构建。以下是示例：
**Example**
```
$ npm run build
> hello-cdk@0.1.0 build
> tsc
```
无需执行任何构建步骤。
无需执行任何构建步骤。
```
$ mvn compile -q
```
或者`Control-B`在 Eclipse 中按（其他 Java IDEs 可能会有所不同）
```
$ dotnet build src
```
或者在 Visual Studio 中按 F6
```
$ go build
```
## 步骤 5 ：列出应用程序中的 CDK 堆栈
此时，您应该有一个包含单个 CDK 堆栈的 CDK 应用程序。要进行验证，请使用 CDK CLI `cdk list` 命令显示堆栈。输出应显示名为 `HelloCdkStack` 的单个堆栈：
```
$ cdk list
HelloCdkStack
```
如果您看不到此输出，请验证您所在的项目工作目录是否正确，然后重试。如果仍然看不到堆栈，请重复[步骤 1：创建 CDK 项目](#hello-world-create)，然后重试。
## 步骤 6：定义 Lambda 函数
在此步骤中，您将从 AWS 构造库中导入[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)模块并使用 [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 构造。
按如下方式修改 CDK 堆栈文件：
**Example**
位于 `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!'),
};
};
`),
});
}
}
```
位于 `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 }
```
位于 `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!'),
};
};
"""
),
)
```
位于 `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();
}
}
```
位于 `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!'),
};
};
"),
});
}
}
}
```
位于 `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
}
// ...
```
让我们详细了解一下 `Function` 构造。像所有构造一样，`Function` 类采用三个参数：
+ **scope**：将 `Stack` 实例定义为 `Function` 构造的父级。所有定义 AWS 资源的构造都是在堆栈的范围内创建的。您可以在构造内部定义构造，从而创建层次结构（树）。在这里以及大多数情况下，作用域是 `this`（Python 中为 `self`）。
+ **ID** — 您的 AWS CDK 应用程序`Function`中的构造 ID。此 ID 加上基于函数在堆栈中的位置的哈希值，可在部署过程中唯一标识函数。当您在应用程序中更新构造并重新部署以更新已部署的资源时， AWS CDK 也会引用此 ID。在本例中，构造 ID 是 `HelloWorldFunction`。函数也可以有一个名称，使用 `functionName` 属性指定。它不同于构造 ID。
+ **props**：一组定义函数属性的值。在本例中，您将定义 `runtime`、`handler` 和 `code` 属性。
在 AWS CDK 支持的语言中，道具的表示方式有所不同。
+ 在 and 中 TypeScript JavaScript，`props`是单个参数，您可以传入一个包含所需属性的对象。
+ 在 Python 中，props 作为关键字参数传递。
+ 在 Java 中，提供生成器用于传递 props。有两种 props：一个用于 `FunctionProps`，第二个用于 `Function`，以便您一步构建构造及其 props 对象。示例代码使用了后者。
+ 在 C\$1 中，您将使用对象初始化程序实例化 `FunctionProps` 对象，并将其作为第三个参数传递。
如果构造的 props 是可选的，则可以完全省略 `props` 参数。
所有构造都采用相同的三个参数，因此在了解新构造时很容易明确方向。如您预期的那样，您可以对任何构造子类化，对其进行扩展以适合您的需求，也可更改其默认值。
## 步骤 7：定义 Lambda 函数 URL
在此步骤中，您将使用 `Function` 构造的 `addFunctionUrl` 助手方法定义 Lambda 函数 URL。要在部署时输出此 URL 的值，您需要使用[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)构造创建 AWS CloudFormation 输出。
在 CDK 堆栈文件中添加以下内容：
**Example**
位于 `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,
})
}
}
```
位于 `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 }
```
位于 `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)
```
位于 `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();
}
}
```
位于 `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
});
}
}
}
```
位于 `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
}
// ...
```
**警告**
为了简化本教程，Lambda 函数 URL 是在不进行身份验证的情况下定义的。部署后，它将创建一个可公开访问的端点，该端点可用于调用函数。完成本教程后，请按照[步骤 12：删除应用程序](#hello-world-delete)删除这些资源。
## 第 8 步：合成模板 CloudFormation
在此步骤中，您将通过使用 CDK CLI `cdk synth` 命令合成 CloudFormation 模板来准备部署。此命令对您的 CDK 代码执行基本验证，运行您的 CDK 应用程序，并从 CDK 堆栈生成 CloudFormation 模板。
如果应用程序包含多个堆栈，则必须指定要使用哪些堆栈进行合成。由于应用程序包含单个堆栈，CDK CLI 会自动检测该堆栈以进行合成。
如果您没有合成模板，CDK CLI 将在您部署时自动执行此步骤。但是，建议您在每次部署之前运行此步骤，以检查是否存在合成错误。
在合成模板之前，您可以选择构建应用程序，以捕获语法和类型错误。有关说明，请参阅[步骤 4：构建 CDK 应用程序](#hello-world-build)。
要合成 CloudFormation 模板，请从项目的根目录运行以下命令：
```
$ cdk synth
```
**注意**
如果您收到如下错误，请确认您是否位于 `hello-cdk` 目录中并重试：
```
--app is required either in command-line, in cdk.json or in ~/.cdk.json
```
如果成功，CDK CLI 会将`YAML`格式化 CloudFormation 模板输出到项目目录中，`stdout`并将`JSON`格式化模板保存在项目`cdk.out`目录中。
以下是 CloudFormation 模板的输出示例：
### AWS CloudFormation 模板
```
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.
```
**注意**
每个生成的模板默认都包含一个 ` AWS::CDK::Metadata` 资源。 AWS CDK 团队使用这些元数据来深入了解 AWS CDK 的使用情况，并找到改进的方法。有关详细信息，包括如何选择退出版本报告，请参阅[版本报告](cli.md#version-reporting)。
通过定义单个 L2 结构， AWS CDK 创建了一个包含您的 Lambda 资源以及您的资源在应用程序中进行交互所需的权限和粘合逻辑的广泛 CloudFormation 模板。
## 步骤 9：部署 CDK 堆栈
在此步骤中，您将使用 CDK CLI `cdk deploy` 命令部署 CDK 堆栈。此命令检索您生成的 CloudFormation 模板并通过该模板进行部署 AWS CloudFormation，该模板会将您的资源配置为堆栈的一部分。 CloudFormation
在项目的根目录中运行以下命令。如果系统提示，请确认更改：
```
$ 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
```
与之类似`cdk synth`，您无需指定 AWS CDK 堆栈，因为该应用程序包含单个堆栈。
部署过程中，CDK CLI 会在部署堆栈时显示进度信息。完成后，您可以前往 [AWS CloudFormation 控制台](https://console.aws.amazon.com/cloudformation/home)查看 `HelloCdkStack` 堆栈。您也可以前往 Lambda 控制台查看 `HelloWorldFunction` 资源。
部署完成后，CDK CLI 将输出端点 URL。复制此 URL 以供下一步使用。以下是示例：
```
...
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
```
## 第 10 步：在上与您的应用程序进行交互 AWS
在此步骤中，您可以 AWS 通过函数 URL 调用 Lambda 函数，从而与应用程序进行交互。访问网址时，Lambda 函数会返回 `Hello World!` 消息。
要调用函数，请通过浏览器或命令行访问函数 URL。以下是示例：
```
$ curl https://.lambda-url..on.aws/
"Hello World!"%
```
## 步骤 11：修改应用程序
在此步骤中，您将修改调用 Lambda 函数时返回的消息。您可以使用 CDK CLI `cdk diff` 命令执行 diiff，以预览更改并部署，从而更新应用程序。然后，您可以与应用程序进行交互 AWS 以查看您的新消息。
按如下方式修改 CDK 堆栈文件中的 `myFunction` 实例：
**Example**
位于 `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!'),
};
};
`),
});
// ...
}
}
```
位于 `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 }
```
位于 `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!'),
};
};
"""
),
)
# ...
```
位于 `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!'),
};
};
`)),
})
// ...
}
```
目前，您的代码更改尚未对已部署的 Lambda 资源执行任何直接更新。您的代码定义了所需的资源的状态。要修改已部署的资源，您将使用 CDK CLI 将所需状态合成到新 AWS CloudFormation 模板中。然后，您将新 CloudFormation 模板部署为更改集。更改集仅进行必要的更改，以达到新的所需状态。
要预览您的更改，请运行 `cdk diff` 命令。以下是示例：
```
$ 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
```
要创建此差异，CDK CLI 会向您的 AWS 账户查询堆栈的最新 AWS CloudFormation 模板。`HelloCdkStack`然后，它将最新的模板与刚从应用程序中合成的模板进行比较。
要实现您的更改，请运行 `cdk deploy` 命令。以下是示例：
```
$ 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
```
要与应用程序交互，请重复[步骤 10：在 AWS上与应用程序交互](#hello-world-interact)。以下是示例：
```
$ curl https://.lambda-url..on.aws/
"Hello CDK!"%
```
## 步骤 12：删除应用程序
在此步骤中，您将使用 CDK CLI `cdk destroy` 命令删除应用程序。此命令删除与您的 CDK CloudFormation 堆栈关联的堆栈，其中包括您创建的资源。
要删除应用程序，请运行 `cdk destroy` 命令并确认删除应用程序的请求。以下是示例：
```
$ cdk destroy
Are you sure you want to delete: HelloCdkStack (y/n)? y
HelloCdkStack: destroying... [1/1]
✅ HelloCdkStack: destroyed
```
## 后续步骤
恭喜您！您已完成本教程，并已使用 AWS CDK 成功创建、修改和删除 AWS 云端资源。现在，您可以开始使用 AWS CDK 了。
要了解有关以首选编程语言使用 AWS CDK 的更多信息，请参阅[使用 AWS CDK 库](work-with.md)。
有关其他资源，请参阅以下资源：
+ 试用 [CDK Workshop](https://cdkworkshop.com/)，通过更复杂的项目更深入地学习。
+ 请参阅 [API 参考资料](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html)，开始探索可用于您最喜欢的 AWS 服务的 CDK 结构。
+ 访问 C [onstruc](https://constructs.dev/search?q=&cdk=aws-cdk&cdkver=2&sort=downloadsDesc&offset=0) t Hub，发现由 AWS 和其他人创建的构造。
+ 浏览使用 AWS CDK 的[示例](https://github.com/aws-samples/aws-cdk-examples)。
AWS CDK 是一个开源项目。要做出贡献，请参阅为 C [AWS loud Development Kit 做出贡献 (AWS CDK)](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md)。