必要條件關於本教學步驟 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 應用程式

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叫用，該函數可作為 Lambda 函數的專用 HTTP（S）端點。

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

建立專案 – 使用建立CDK專案 CDK CLI cdk init 命令。
設定您的 AWS 環境 – 設定您要部署應用程式 AWS 的環境。
引導您的 AWS 環境 – 使用引導環境以準備部署 AWS 環境 CDK CLI 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專案

從您選擇的起始目錄中，建立並導覽至名為的目錄hello-cdk：
```
$ mkdir hello-cdk && cd hello-cdk
```
重要
請務必如此處所示hello-cdk，為您的專案目錄命名。的 CDK CLI 使用此目錄名稱來命名CDK程式碼中的物件。如果您使用不同的目錄名稱，您會在本教學課程中遇到問題。
從hello-cdk目錄中，使用初始化新CDK專案 CDK CLI cdk init 命令。使用 --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，您現在可以開啟或匯入專案。In (入) 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
```

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

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

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

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
}

// ...

步驟 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"),
	}
}

步驟 3：啟動您的 AWS 環境

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

若要啟動您的環境，請從CDK專案根目錄執行下列項目：


$ cdk bootstrap

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

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

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

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

此時，您應該有一個包含單一CDK堆疊CDK的應用程式。若要驗證，請使用 CDK CLI cdk 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
}

// ...

我們來進一步了解Function建構。與所有建構一樣， Function類別需要三個參數：

範圍 – 將Stack執行個體定義為Function建構的父系。定義 AWS 資源的所有建構都會在堆疊的範圍內建立。您可以在建構內部定義建構，建立階層（樹狀結構）。在這裡，在大多數情況下，範圍為 this（self 中的 Python).
ID – Function應用程式中 AWS CDK 的建構 ID。此 ID 加上基於函數在堆疊中的位置的雜湊，可在部署期間唯一識別函數。當您更新應用程式中的建構並重新部署以更新部署的資源時， AWS CDK 也會參考此 ID。在此，您的建構 ID 為 HelloWorldFunction。函數也可以有使用 functionName 屬性指定的名稱。這與建構 ID 不同。
props – 定義函數屬性的一組值。您可以在此定義 runtime、 handler和 code 屬性。

道具以支援的語言表示 AWS CDK。
- In (入) TypeScript 以及 JavaScript、 props 是單一引數，而且您會傳遞到包含所需屬性的物件中。
- In (入) Python，道具會作為關鍵字引數傳遞。
- In (入) Java，提供 Builder 以傳遞道具。有兩個：一個用於 FunctionProps，另一個用於 Function，讓您在一個步驟中建置建構結構及其道具物件。此程式碼使用後者。
- In (入) 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
}

// ...

警告

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

步驟 8：合成 CloudFormation 範本

在此步驟中，您可以透過使用合成 CloudFormation 範本來準備部署 CDK CLI cdk synth 命令。此命令會執行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

如果成功， CDKCLI 將輸出 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::CDK::Metadata資源。 AWS CDK 團隊使用此中繼資料來深入了解 AWS CDK 用量，並尋找改善用量的方法。如需詳細資訊，包括如何選擇退出版本報告，請參閱版本報告。

透過定義單一 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 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 堆疊，因為應用程式包含單一堆疊。

在部署期間， CDKCLI 會在部署堆疊時顯示進度資訊。完成後，您可以前往AWS CloudFormation 主控台檢視您的HelloCdkStack堆疊。您也可以前往 Lambda 主控台檢視您的HelloWorldFunction資源。

部署完成時， CDKCLI 將輸出您的端點 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

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

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


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

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

在此步驟中，您可以修改 Lambda 函數在調用時傳回的訊息。您可以使用執行 diff CDK CLI cdk 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!'),
        };
      };
    `)),
  })

// ...

目前，您的程式碼變更尚未對部署的 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

若要建立此 diff， CDKCLI 會查詢 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 CLI cdk destroy 命令來刪除您的應用程式。此命令會刪除與 CloudFormation 堆疊相關聯的CDK堆疊，其中包含您建立的資源。

若要刪除您的應用程式，請執行 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程式庫

教學課程：建立第一個 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 範本

注意

注意

步驟 9：部署您的CDK堆疊

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

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

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

後續步驟

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