教學課程：建立您的第一個 AWS CDK 應用程式

焦點模式

教學課程：建立您的第一個 AWS CDK 應用程式 - AWS Cloud Development Kit (AWS CDK) v2

先決條件關於本教學步驟 1：建立 CDK 專案步驟 2：設定您的 AWS 環境步驟 3：引導您的 AWS 環境步驟 4：建置您的 CDK 應用程式步驟 5：列出應用程式中的 CDK 堆疊步驟 6：定義您的 Lambda 函數步驟 7：定義您的 Lambda 函數 URL 步驟 8：合成 CloudFormation 範本步驟 9：部署 CDK 堆疊步驟 10：在上與您的應用程式互動 AWS 步驟 11：修改您的應用程式步驟 12：刪除您的應用程式後續步驟

這是 AWS CDK v2 開發人員指南。較舊的 CDK v1 已於 2022 年 6 月 1 日進入維護，並於 2023 年 6 月 1 日結束支援。

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

這是 AWS CDK v2 開發人員指南。較舊的 CDK v1 已於 2022 年 6 月 1 日進入維護，並於 2023 年 6 月 1 日結束支援。

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

開始使用 AWS Cloud Development Kit (AWS CDK) ，方法是使用 AWS CDK 命令列界面 (AWS CDK CLI) 開發您的第一個 CDK 應用程式、引導您的 AWS 環境，以及在其中部署您的應用程式 AWS。

先決條件

開始本教學課程之前，請先完成中的所有設定步驟開始使用 AWS CDK。

關於本教學

在本教學課程中，您將 AWS 使用在上建立和部署簡單的應用程式 AWS CDK。應用程式由函數組成，該AWS Lambda 函數會在叫用時傳回Hello World!訊息。函數將透過 Lambda 函數 URL 叫用，該 URL 做為 Lambda 函數的專用 HTTP(S) 端點。

透過本教學課程，您將執行下列動作：

建立專案 – 使用 CDK CLIcdk init命令建立 CDK 專案。
設定您的 AWS 環境 – 設定您要部署應用程式 AWS 的環境。
引導您的 AWS 環境 – 使用 CDK CLIcdk bootstrap命令引導您的 AWS 環境以準備部署。
開發您的應用程式 – 使用 AWS 建構程式庫中的建構來定義您的 Lambda 函數和 Lambda 函數 URL 資源。
準備您的應用程式以進行部署 – 使用 CDK CLI建置您的應用程式並合成 AWS CloudFormation 範本。
部署您的應用程式 – 使用 CDK CLIcdk deploy命令來部署您的應用程式並佈建您的 AWS 資源。
與您的應用程式互動 – 透過叫用並接收回應 AWS ，在上與您部署的 Lambda 函數互動。
修改您的應用程式 – 修改您的 Lambda 函數並部署以實作您的變更。
刪除您的應用程式 – 刪除您使用 CDK CLIcdk destroy命令建立的所有資源。

步驟 1：建立 CDK 專案

在此步驟中，您會建立新的 CDK 專案。CDK 專案應該位於自己的目錄中，具有自己的本機模組相依性。

建立 CDK 專案

從您選擇的開始目錄中，建立並導覽至名為的目錄hello-cdk：
```
$ mkdir hello-cdk && cd hello-cdk
```
重要
請務必將您的專案目錄命名為 hello-cdk，如此處所示。CDK CLI使用此目錄名稱來命名 CDK 程式碼中的物件。如果您使用不同的目錄名稱，您會在本教學課程中遇到問題。
從 hello-cdk目錄中，使用 CDK CLIcdk init命令初始化新的 CDK 專案。使用 --language選項指定app範本和您偏好的程式設計語言：
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#
```
$ cdk init app --language csharp
```
如果您使用的是 Visual Studio，請在 src目錄中開啟解決方案檔案。
Go
```
$ cdk init app --language go
```
建立應用程式之後，也請輸入下列命令來安裝應用程式所需的 AWS 建構程式庫模組。
```
$ go get
```
anchor anchor anchor anchor anchor anchor
$ cdk init app --language typescript

cdk init 命令會在 hello-cdk目錄中建立檔案和資料夾的結構，以協助組織 CDK 應用程式的原始程式碼。此檔案和資料夾結構稱為 CDK 專案。花點時間探索您的 CDK 專案。

如果您Git已安裝，您使用建立的每個專案cdk init也會初始化為Git儲存庫。

在專案初始化期間，CDK CLI會建立包含單一 CDK 堆疊的 CDK 應用程式。CDK 應用程式執行個體是使用 App 建構模組建立的。以下是 CDK 應用程式檔案中此程式碼的一部分：

anchor anchor anchor anchor anchor anchor

位於： 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', {
});

CDK 堆疊是使用 Stack 建構模組建立的。以下是 CDK 堆疊檔案中此程式碼的一部分：

TypeScript

位於： 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

  }
}

JavaScript

位於： 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 }

Python

位於： 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

Java

位於： 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
  }
}

C#

位於： 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
    }
  }
}

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"
)

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
}

// ...

anchor anchor anchor anchor anchor anchor

位於： 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

  }
}

步驟 2：設定您的 AWS 環境

在此步驟中，您會為 CDK 堆疊設定 AWS 環境。執行此操作後，您可以指定要部署 CDK 堆疊的環境。

首先，決定您要使用 AWS 的環境。 AWS 環境包含 AWS 帳戶和 AWS 區域。

當您使用 AWS CLI 在本機電腦上設定安全登入資料時，您可以使用 AWS CLI 來取得特定設定檔 AWS 的環境資訊。

使用 AWS CLI 取得您的 AWS 帳戶 ID

執行下列 AWS CLI 命令以取得default設定檔的 AWS 帳戶 ID：
```
$ aws sts get-caller-identity --query "Account" --output text
```

如果您偏好使用具名設定檔，請使用 --profile選項提供設定檔的名稱：


$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text

使用 AWS CLI 取得您的 AWS 區域

執行下列 AWS CLI 命令，以取得您為default設定檔設定的區域：
```
$ aws configure get region
```
如果您偏好使用具名設定檔，請使用 --profile選項提供設定檔的名稱：
```
$ aws configure get region --profile your-profile-name
```

接著，您將修改應用程式檔案中的HelloCdkStack執行個體，為 CDK 堆疊設定 AWS 環境。在本教學課程中，您將硬式編碼您的 AWS 環境資訊。這建議用於生產環境。如需設定環境的其他方式資訊，請參閱設定環境以搭配使用 AWS CDK。

設定 CDK 堆疊的環境

在您的應用程式檔案中，使用 Stack 建構的 env 屬性來設定您的環境。以下是範例：

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#

位於： 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"),
	}
}

anchor anchor anchor anchor anchor anchor

位於 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' },
});

步驟 3：引導您的 AWS 環境

在此步驟中，您會引導您在上一個步驟中設定 AWS 的環境。這可讓您的環境準備好進行 CDK 部署。

若要引導您的環境，請從 CDK 專案的根目錄執行下列命令：


$ cdk bootstrap

透過從 CDK 專案的根目錄引導，您不需要提供任何額外資訊。CDK 會從專案CLI取得環境資訊。當您在 CDK 專案外部引導時，您必須使用 cdk bootstrap命令提供環境資訊。如需詳細資訊，請參閱引導您的環境以搭配使用 AWS CDK。

步驟 4：建置您的 CDK 應用程式

在大多數程式設計環境中，您會在進行變更後建置或編譯程式碼。使用不需要這麼做， AWS CDK 因為 CDK CLI 會自動執行此步驟。不過，當您想要擷取語法和類型錯誤時，您仍然可以手動建置。以下是範例：

anchor anchor anchor anchor anchor anchor


$ npm run build
            
> hello-cdk@0.1.0 build
> tsc

步驟 5：列出應用程式中的 CDK 堆疊

此時，您應該有一個包含單一 CDK 堆疊的 CDK 應用程式。若要驗證，請使用 CDK CLIcdk list命令來顯示您的堆疊。輸出應會顯示名為的單一堆疊HelloCdkStack：


$ cdk list
HelloCdkStack

如果您沒有看到此輸出，請確認您位於專案的正確工作目錄中，然後再試一次。如果您仍然看不到堆疊，請重複步驟 1：建立 CDK 專案，然後再試一次。

步驟 6：定義您的 Lambda 函數

在此步驟中，您可以從 AWS 建構程式庫匯入aws_lambda模組，並使用 Function L2 建構。

修改 CDK 堆疊檔案，如下所示：

TypeScript

位於： 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!'),
          };
        };
      `),
    });
  }
}

JavaScript

位於： 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 }

Python

位於： 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!'),
          };
        };
        """
      ),
    )

Java

位於： 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();

  }
}

C#

位於： 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!'),
            };
          };
        "),
      });
    }
  }
}

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"
  // 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
}

// ...

anchor anchor anchor anchor anchor anchor

位於： 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!'),
          };
        };
      `),
    });
  }
}

讓我們進一步了解Function建構。如同所有建構， Function類別需要三個參數：

scope – 將Stack執行個體定義為Function建構的父系。定義 AWS 資源的所有建構會在堆疊範圍內建立。您可以在建構內部定義建構，建立階層（樹）。在這裡，在大多數情況下，範圍為 this(self 中的 Python)。
ID – Function應用程式中 AWS CDK 的建構 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#，您可以使用FunctionProps物件初始化器來執行個體化物件，並將其做為第三個參數傳遞。
如果建構的道具是選用的，您可以完全省略 props 參數。

所有建構都採用這三個相同的引數，因此當您了解新的引數時，很容易保持方向。而且，如您預期，您可以對任何建構進行子類別，以擴展以符合您的需求，或者如果您想要變更其預設值。

步驟 7：定義您的 Lambda 函數 URL

在此步驟中，您會使用建構的addFunctionUrl協助程式方法來定義 Lambda Function 函數 URL。若要在部署時輸出此 URL 的值，您將使用 CfnOutput 建構模組建立 AWS CloudFormation 輸出。

將下列項目新增至 CDK 堆疊檔案：

TypeScript

位於： 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,
    })

  }
}

JavaScript

位於： 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 }

Python

位於： 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)

Java

位於： 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();
  }
}

C#

位於： 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
      });
    }
  }
}

Go

位於： 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
}

// ...

anchor anchor anchor anchor anchor anchor

位於： 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,
    })

  }
}

警告

為了讓本教學課程保持簡單，您的 Lambda 函數 URL 已定義，無需身分驗證。部署時，這會建立可公開存取的端點，可用來叫用您的函數。完成本教學課程後，請遵循步驟 12：刪除您的應用程式刪除這些資源。

步驟 8：合成 CloudFormation 範本

在此步驟中，您會使用 CDK CLIcdk synth命令合成 CloudFormation 範本，以準備部署。此命令會執行 CDK 程式碼的基本驗證、執行 CDK 應用程式，以及從 CDK 堆疊產生 CloudFormation 範本。

如果您的應用程式包含多個堆疊，您必須指定要合成的堆疊。由於您的應用程式包含單一堆疊，因此 CDK CLI會自動偵測要合成的堆疊。

如果您不合成範本，CDK CLI會在您部署時自動執行此步驟。不過，我們建議您在每次部署之前執行此步驟，以檢查合成錯誤。

在合成範本之前，您可以選擇建置應用程式以擷取語法和類型錯誤。如需說明，請參閱步驟 4：建置您的 CDK 應用程式。

若要合成 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 範本的範例輸出：


Resources:
  HelloWorldFunctionServiceRoleunique-identifier:
    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
  HelloWorldFunctionunique-identifier:
    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:
          - HelloWorldFunctionServiceRoleunique-identifier
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRoleunique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
  HelloWorldFunctionFunctionUrlunique-identifier:
    Type: AWS::Lambda::Url
    Properties:
      AuthType: NONE
      TargetFunctionArn:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
  HelloWorldFunctioninvokefunctionurlunique-identifier:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunctionUrl
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
      FunctionUrlAuthType: NONE
      Principal: "*"
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties:
      Analytics: v2:deflate64:unique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/CDKMetadata/Default
    Condition: CDKMetadataAvailable
Outputs:
  myFunctionUrlOutput:
    Value:
      Fn::GetAtt:
        - HelloWorldFunctionFunctionUrlunique-identifier
        - FunctionUrl
Parameters:
  BootstrapVersion:
    Type: AWS::SSM::Parameter::Value<String>
    Default: /cdk-bootstrap/unique-identifier/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 CloudFormation 範本


Resources:
  HelloWorldFunctionServiceRoleunique-identifier:
    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
  HelloWorldFunctionunique-identifier:
    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:
          - HelloWorldFunctionServiceRoleunique-identifier
          - Arn
      Runtime: nodejs20.x
    DependsOn:
      - HelloWorldFunctionServiceRoleunique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
  HelloWorldFunctionFunctionUrlunique-identifier:
    Type: AWS::Lambda::Url
    Properties:
      AuthType: NONE
      TargetFunctionArn:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
  HelloWorldFunctioninvokefunctionurlunique-identifier:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunctionUrl
      FunctionName:
        Fn::GetAtt:
          - HelloWorldFunctionunique-identifier
          - Arn
      FunctionUrlAuthType: NONE
      Principal: "*"
    Metadata:
      aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
  CDKMetadata:
    Type: AWS::CDK::Metadata
    Properties:
      Analytics: v2:deflate64:unique-identifier
    Metadata:
      aws:cdk:path: HelloCdkStack/CDKMetadata/Default
    Condition: CDKMetadataAvailable
Outputs:
  myFunctionUrlOutput:
    Value:
      Fn::GetAtt:
        - HelloWorldFunctionFunctionUrlunique-identifier
        - FunctionUrl
Parameters:
  BootstrapVersion:
    Type: AWS::SSM::Parameter::Value<String>
    Default: /cdk-bootstrap/unique-identifier/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 用量，並尋找改善用量的方法。如需詳細資訊，包括如何選擇退出版本報告，請參閱版本報告。

透過定義單一 L2 建構模組，會 AWS CDK 建立廣泛的 CloudFormation 範本，其中包含您的 Lambda 資源，以及資源在應用程式中互動所需的許可和黏附邏輯。

步驟 9：部署 CDK 堆疊

在此步驟中，您會使用 CDK CLIcdk deploy命令來部署 CDK 堆疊。此命令會擷取您產生的 CloudFormation 範本，並透過進行部署 AWS CloudFormation，這會佈建您的資源做為 CloudFormation 堆疊的一部分。

從專案的根目錄執行下列動作。出現提示時確認變更：


$ cdk deploy

✨  Synthesis time: 2.69s

HelloCdkStack:  start: Building unique-identifier:current_account-current_region
HelloCdkStack:  success: Built unique-identifier:current_account-current_region
HelloCdkStack:  start: Publishing unique-identifier:current_account-current_region
HelloCdkStack:  success: Published unique-identifier: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 主控台檢視您的HelloCdkStack堆疊。您也可以前往 Lambda 主控台來檢視您的HelloWorldFunction資源。

部署完成時，CDK CLI將輸出您的端點 URL。複製此 URL 以進行下一個步驟。以下是範例：


...
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...

 ✅  HelloCdkStack

✨  Deployment time: 41.65s

Outputs:
HelloCdkStack.myFunctionUrlOutput = https://<api-id>.lambda-url.<Region>.on.aws/
Stack ARN:
arn:aws:cloudformation:Region:account-id:stack/HelloCdkStack/unique-identifier

✨  Total time: 44.34s

步驟 10：在上與您的應用程式互動 AWS

在此步驟中，您可以透過函數 URL AWS 叫用 Lambda 函數，在上與您的應用程式互動。當您存取 URL 時，您的 Lambda 函數會傳回 Hello World! 訊息。

若要叫用函數，請透過瀏覽器或從命令列存取函數 URL。以下是範例：


$ curl https://<api-id>.lambda-url.<Region>.on.aws/
"Hello World!"%

步驟 11：修改您的應用程式

在此步驟中，您會修改 Lambda 函數在叫用時傳回的訊息。您可以使用 CDK CLIcdk diff命令來執行差異，以預覽變更並部署以更新應用程式。然後，您會在上與應用程式互動 AWS ，以查看新訊息。

修改 CDK 堆疊檔案中的myFunction執行個體，如下所示：

TypeScript

位於： 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!'),
          };
        };
      `),
    });

    // ...

JavaScript

位於： 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 }

Python

位於： 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!'),
          };
        };
        """
      ),
    )

    # ...

Java

位於： 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();

    // ...
  }
}

C#


// ...

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!'),
            };
          };
        "),
      });

      // ...
    }
  }
}

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)

  // 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!'),
        };
      };
    `)),
  })

// ...

anchor anchor anchor anchor anchor anchor

位於： 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!'),
          };
        };
      `),
    });

    // ...

目前，您的程式碼變更尚未直接更新已部署的 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 HelloWorldFunctionunique-identifier
 └─ [~] 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 unique-identifier:current_account-current_region
HelloCdkStack:  success: Built unique-identifier:current_account-current_region
HelloCdkStack:  start: Publishing unique-identifier:current_account-current_region
HelloCdkStack:  success: Published unique-identifier:current_account-current_region
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...

 ✅  HelloCdkStack

✨  Deployment time: 26.96s

Outputs:
HelloCdkStack.myFunctionUrlOutput = https://unique-identifier.lambda-url.<Region>.on.aws/
Stack ARN:
arn:aws:cloudformation:Region:account-id:stack/HelloCdkStack/unique-identifier

✨  Total time: 29.07s

若要與您的應用程式互動，請重複步驟 10：在上與您的應用程式互動 AWS。以下是範例：


$ curl https://<api-id>.lambda-url.<Region>.on.aws/
"Hello CDK!"%

步驟 12：刪除您的應用程式

在此步驟中，您會使用 CDK CLIcdk 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 程式庫。

如需其他資源，請參閱下列內容：

請嘗試 CDK 研討會，深入了解涉及更複雜專案的導覽。
請參閱 API 參考，開始探索您喜愛的 AWS 服務可用的 CDK 建構。
請造訪 Construct Hub 以探索 AWS 和其他建立的建構。
探索使用的範例 AWS CDK。

AWS CDK 是開放原始碼專案。若要貢獻，請參閱貢獻 AWS Cloud Development Kit (AWS CDK)。

您的瀏覽器已停用或無法使用 Javascript。

您必須啟用 Javascript，才能使用 AWS 文件。請參閱您的瀏覽器說明頁以取得說明。

文件慣用形式

開始使用

使用 CDK 程式庫

下一個主題：

使用 CDK 程式庫

上一個主題：

開始使用

需要協助？

在本頁面

此頁面是否有幫助？

提供意見回饋

隱私權網站條款 Cookie 偏好設定

選取您的 Cookie 偏好設定

自訂 Cookie 偏好設定

必要

效能

功能

廣告

無法儲存 Cookie 偏好設定

教學課程：建立您的第一個 AWS CDK 應用程式

先決條件

關於本教學

步驟 1：建立 CDK 專案

建立 CDK 專案

重要

步驟 2：設定您的 AWS 環境

使用 AWS CLI 取得您的 AWS 帳戶 ID

使用 AWS CLI 取得您的 AWS 區域

設定 CDK 堆疊的環境

步驟 3：引導您的 AWS 環境

步驟 4：建置您的 CDK 應用程式

步驟 5：列出應用程式中的 CDK 堆疊

步驟 6：定義您的 Lambda 函數

步驟 7：定義您的 Lambda 函數 URL

警告

步驟 8：合成 CloudFormation 範本

注意

AWS CloudFormation 範本

注意

步驟 9：部署 CDK 堆疊

步驟 10：在上與您的應用程式互動 AWS

步驟 11：修改您的應用程式

步驟 12：刪除您的應用程式

後續步驟

下一個主題：

上一個主題：

需要協助？

在本頁面

此頁面是否有幫助？

選取您的 Cookie 偏好設定

教學課程：建立您的第一個 AWS CDK 應用程式

先決條件

關於本教學

步驟 1：建立 CDK 專案

建立 CDK 專案

重要

步驟 2：設定您的 AWS 環境

使用 AWS CLI 取得您的 AWS 帳戶 ID

使用 AWS CLI 取得您的 AWS 區域

設定 CDK 堆疊的環境

步驟 3：引導您的 AWS 環境

步驟 4：建置您的 CDK 應用程式

步驟 5：列出應用程式中的 CDK 堆疊

步驟 6：定義您的 Lambda 函數

步驟 7：定義您的 Lambda 函數 URL

警告

步驟 8：合成 CloudFormation 範本

注意

AWS CloudFormation 範本

注意

步驟 9：部署 CDK 堆疊

步驟 10：在 上與您的應用程式互動 AWS

步驟 11：修改您的應用程式

步驟 12：刪除您的應用程式

後續步驟

下一個主題：

上一個主題：

需要協助？

在本頁面

此頁面是否有幫助？

步驟 10：在上與您的應用程式互動 AWS