這是 AWS CDK v2 開發人員指南。較舊的 CDK v1 已於 2022 年 6 月 1 日進入維護，並於 2023 年 6 月 1 日結束支援。 本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。 # AWS CDK 入門 安裝和設定 AWS CDK 命令列界面 (AWS CDK CLI)，開始使用 AWS 雲端開發套件 (AWS CDK)。然後，使用 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 會自動使用您使用 CLI AWS 設定的安全登入資料。例如，如果您是 IAM Identity Center 使用者，您可以使用 `aws configure sso`命令來設定安全登入資料。如果您是 IAM 使用者，您可以使用 `aws configure`命令。CLI AWS 將引導您在本機電腦上設定安全登入資料，並將必要資訊儲存在 `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 使用安全登入資料的詳細資訊，請參閱[設定 AWS CDK CLI 的安全登入資料](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 應用程式的各種元件。如需詳細說明，請參閱下列主題： + [安裝 AWS Toolkit for Visual Studio 程式碼](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html)。 + [AWS VS 程式碼的 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 應用程式 開始使用 AWS 雲端開發套件 (AWS CDK)，方法是使用 AWS CDK 命令列界面 (AWS CDK 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 函數專用 HTTP(S) 端點的 Lambda 函數 URL](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html) 叫用。 透過本教學課程，您將執行下列動作： + **建立專案** – 使用 CDK CLI `cdk init`命令建立 CDK 專案。 + **設定您的 AWS 環境** – 設定您要部署應用程式 AWS 的環境。 + **引導您的 AWS 環境** – 使用 CDK CLI `cdk bootstrap`命令引導 AWS 環境以準備部署環境。 + **開發您的應用程式** – 使用 AWS 建構程式庫中的建構來定義您的 Lambda 函數和 Lambda 函數 URL 資源。 + **準備您的應用程式進行部署** – 使用 CDK CLI 建置您的應用程式並合成 an 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 Construct Library 模組。 ``` $ 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`類別需要三個參數： + **範圍** – 將`Stack`執行個體定義為`Function`建構的父系。定義 AWS 資源的所有建構會在堆疊的範圍內建立。您可以在建構內部定義建構，建立階層 （樹）。在這裡，在大多數情況下，範圍為 `this`(`self`在 Python 中為 )。 + **Id** – AWS CDK 應用程式`Function`內 的建構 ID。此 ID 加上根據函數在堆疊中的位置的雜湊，可在部署期間唯一識別函數。當您更新應用程式中的建構並重新部署以更新部署的資源時， AWS CDK 也會參考此 ID。在這裡，您的建構 ID 為 `HelloWorldFunction`。函數也可以有使用 `functionName` 屬性指定的名稱。這與建構 ID 不同。 + **props** – 定義函數屬性的一組值。您可以在這裡定義 `runtime`、 `handler`和 `code` 屬性。 Props 會以不同的方式以 AWS CDK 支援的語言表示。 + 在 TypeScript 和 JavaScript 中， `props` 是單一引數，您會傳入包含所需屬性的物件。 + 在 Python 中，prop 會以關鍵字引數傳遞。 + 在 Java 中，提供建置器以傳遞道具。有兩個：一個用於 `FunctionProps`，另一個用於 `Function`，可讓您在一個步驟中建置建構結構及其道具物件。此程式碼使用後者。 + 在 C\$1 中，您可以使用`FunctionProps`物件初始化器來執行個體化物件，並將其做為第三個參數傳遞。 如果建構的道具是選用的，您可以完全省略 `props` 參數。 所有建構都採用這三個相同的引數，因此當您了解新的引數時，很容易保持方向。而且，如您預期，您可以對任何建構進行子類別，以擴展以符合您的需求，或者如果您想要變更其預設值。 ## 步驟 7：定義您的 Lambda 函數 URL 在此步驟中，您會使用建構的`addFunctionUrl`協助程式方法來定義 Lambda `Function` 函數 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 用量，並尋找改善 CDK 用量的方法。如需詳細資訊，包括如何選擇退出版本報告，請參閱[版本報告](cli.md#version-reporting)。 透過定義單一 L2 建構， AWS CDK 會建立廣泛的 CloudFormation 範本，其中包含您的 Lambda 資源，以及資源在應用程式中互動所需的許可和黏附邏輯。 ## 步驟 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 在此步驟中，您可以透過函數 URL AWS 叫用 Lambda 函數，在 上與應用程式互動。當您存取 URL 時，Lambda 函數會傳回 `Hello World!` 訊息。 若要叫用函數，請透過瀏覽器或從命令列存取函數 URL。以下是範例： ``` $ curl https://.lambda-url..on.aws/ "Hello World!"% ``` ## 步驟 11：修改您的應用程式 在此步驟中，您會修改叫用 Lambda 函數時傳回的訊息。您可以使用 CDK CLI `cdk diff`命令執行差異來預覽變更，並部署 來更新您的應用程式。然後，您會在 上與應用程式互動 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 您的帳戶，以取得`HelloCdkStack`堆疊的最新 AWS CloudFormation 範本。然後，它會比較最新的範本與其剛從您的應用程式合成的範本。 若要實作變更，請執行 `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 研討會](https://cdkworkshop.com/)，深入了解涉及更複雜專案的導覽。 + 請參閱 [API 參考](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html)，開始探索您最愛的 AWS 服務可用的 CDK 建構。 + 請造訪 [Construct Hub](https://constructs.dev/search?q=&cdk=aws-cdk&cdkver=2&sort=downloadsDesc&offset=0) 以探索 AWS 和其他 建立的建構。 + 探索使用 AWS CDK [的範例](https://github.com/aws-samples/aws-cdk-examples)。 AWS CDK 是開放原始碼專案。若要貢獻，請參閱[貢獻至 AWS 雲端開發套件 (AWS CDK)](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md)。