これは 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 Package Manager を使用して CKD 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 をインストールしたら、CDK の使用を開始してローカルマシンでアプリケーションを開発できます。アプリケーションのデプロイ AWSなどの を操作するには、開始したアクションを実行するアクセス許可を持つセキュリティ認証情報をローカルマシンに設定する必要があります。
ローカルマシンでセキュリティ認証情報を設定するには、 CLI AWS を使用します。セキュリティ認証情報の設定方法は、ユーザーの管理方法によって異なります。手順については、* AWS 「 コマンドラインインターフェイスユーザーガイド*」の[「認証とアクセスの認証情報](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html)」を参照してください。
CDK CLI は、 AWS CLI で設定したセキュリティ認証情報を自動的に使用します。例えば、IAM Identity Center ユーザーの場合、`aws configure sso` コマンドを使用してセキュリティ認証情報を設定できます。IAM ユーザーの場合、`aws configure` コマンドを使用できます。 AWS CLI は、ローカルマシンでセキュリティ認証情報を設定し、必要な情報を `config`および `credentials` ファイルに保存する手順を説明します。次に、`cdk deploy` を使用してアプリケーションをデプロイするなど、CDK CLI を使用するとき、CDK CLI は設定したセキュリティ認証情報を使用します。
CLI と同様に、CDK AWS 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/) は、 AWSでのアプリケーションの作成、デバッグ、デプロイに役立つ Visual Studio Code のオープンソースプラグインです。ツールキットは、 AWS CDK アプリケーションを開発するための統合されたエクスペリエンスを提供します。これには、 AWS CDK プロジェクトを一覧表示し、 AWS CDK アプリケーションのさまざまなコンポーネントを参照する CDK Explorer 機能が含まれています。手順については、以下を参照してください。
+ [AWS Toolkit for Visual Studio Code のインストール](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html)。
+ [AWS CDK for VS Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/cdk-explorer.html)。
## 最初の CDK アプリの作成
これで、最初の AWS CDK アプリを作成して CDK の使用を開始する準備ができました。手順については、[「チュートリアル: 最初の AWS CDK アプリを作成する](hello-world.md)」を参照してください。
# チュートリアル: 最初の AWS CDK アプリを作成する
CDK コマンドラインインターフェイス (AWS CDK CLI) を使用して最初の AWS CDK アプリケーションを開発し、 AWS 環境をブートストラップして、アプリケーションを にデプロイすることで、 AWS クラウド開発キット (AWS CDK) の使用を開始します AWS。
## 前提条件
このチュートリアルを開始する前に、[AWS 「CDK の開始方法」のすべてのセットアップステップを完了してください](getting-started.md)。
## このチュートリアルの内容
このチュートリアルでは、 AWS CDK AWS を使用して にシンプルなアプリケーションを作成してデプロイします。アプリケーションは、呼び出されたときに `Hello World!` メッセージを返す [AWS Lambda 関数](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)で構成されます。関数は、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 を使用してアプリを構築し、 AWS CloudFormation テンプレートを合成します。
+ **アプリケーションをデプロイする** – CDK CLI `cdk deploy` コマンドを使用してアプリケーションをデプロイし、 AWS リソースをプロビジョニングします。
+ **アプリケーションを操作する** – デプロイした Lambda 関数を呼び出してレスポンスを受け取る AWS ことで、 で操作します。
+ **アプリの変更** – Lambda 関数を変更してデプロイし、変更を実装します。
+ **アプリの削除** – CDK CLI の `cdk destroy` コマンドを使用して作成したすべてのリソースを削除します。
## ステップ 1: CDK プロジェクトの作成
このステップでは、新しい CKD プロジェクトを作成します。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
```
アプリを作成したら、以下の 2 つのコマンドも入力します。これにより、アプリケーションの Python 仮想環境がアクティブ化され、 AWS CDK コアの依存関係がインストールされます。
```
$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead
$ python -m pip install -r requirements.txt
```
------
#### [ Java ]
```
$ cdk init app --language java
```
IDE を使用している場合は、これでプロジェクトを開くかインポートできるようになります。例えば、Eclipse では **[ファイル]** > **[インポート]** > **[Maven]** > **[既存の Maven プロジェクト]** を選択します。プロジェクト設定が Java 8 (1.8) を使用するように設定されていることを確認してください。
------
#### [ C\$1 ]
```
$ cdk init app --language csharp
```
Visual Studio を使用している場合は、`src` ディレクトリでソリューションファイルを開きます。
------
#### [ Go ]
```
$ cdk init app --language go
```
アプリを作成したら、次のコマンドを入力して、アプリに必要な AWS コンストラクトライブラリモジュールをインストールします。
```
$ go get
```
------
`cdk init` コマンドは `hello-cdk` ディレクトリ内にファイルおよびフォルダの構造を作成し、CDK アプリのソースコードを整理できるようにします。このファイルおよびフォルダの構造は、CDK *プロジェクト*と呼ばれます。少し時間をかけて CDK プロジェクトを確認してください。
Git がインストールされている場合、`cdk init` を使用して作成する各プロジェクトも Git リポジトリとして初期化されます。
プロジェクトの初期化中、CDK CLI は 1 つの 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 を使用してローカルマシンでセキュリティ認証情報を設定する場合、CLI AWS を使用して特定のプロファイルの AWS 環境情報を取得できます。
**CLI AWS を使用して 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
```
**CLI AWS を使用して 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 アプリの構築
ほとんどのプログラミング環境では、変更後にコードを構築またはコンパイルします。 AWS CDK CLI は自動的にこのステップを実行するため、これは CDK では必要ありません。ただし、構文および型エラーをキャッチするときでも、手動で構築できます。以下に例を示します。
**Example**
```
$ npm run build
> hello-cdk@0.1.0 build
> tsc
```
構築ステップは必要ありません。
構築ステップは必要ありません。
```
$ mvn compile -q
```
または、Eclipseで `Control-B` を押します (他の Java IDE は異なる場合があります)。
```
$ dotnet build src
```
または、Visual Studio で F6 キーを押します。
```
$ go build
```
## ステップ 5: アプリの CDK スタックの一覧表示
この時点では、1 つの CDK スタックを含む CDK アプリが必要です。確認するには、CDK CLI の `cdk list` コマンドを使用してスタックを表示します。出力には、`HelloCdkStack` という名前のスタックが 1 つ表示されます。
```
$ 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)モジュールをインポートし、L2 [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) コンストラクトを使用します。
次のように、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` クラスは 3 つのパラメータを使用します。
+ **scope** – `Stack` インスタンスを `Function` コンストラクトの親として定義します。 AWS リソースを定義するすべてのコンストラクトは、スタックの範囲内で作成されます。コンストラクト内でコンストラクトを定義し、階層 (ツリー) を作成できます。こちらですが、ほとんどの場合、スコープは `this` (Python で `self`) です。
+ **ID** – AWS CDK アプリ`Function`内の のコンストラクト ID。この ID に加え、スタック内で関数の場所に基づくハッシュは、デプロイ中に関数を一意に識別します。 AWS CDK は、アプリでコンストラクトを更新し、デプロイされたリソースを更新するために再デプロイするときにも、この ID を参照します。こちらでは、コンストラクト ID は `HelloWorldFunction` です。関数には `functionName` プロパティで指定された名前を付けることもできます。これはコンストラクト ID とは異なります。
+ **props** – 関数のプロパティを定義する値のバンドル。こちらでは `runtime`、`handler`、`code` プロパティを定義します。
Props は、 AWS CDK でサポートされている言語で表現が異なります。
+ TypeScript および JavaScript では、`props` は単一の引数であり、目的のプロパティを含むオブジェクトを渡します。
+ Python では、props はキーワード引数として渡されます。
+ Java では、ビルダーは props を渡すために提供されます。2 つあります。1 つは `FunctionProps` 用で、2 つ目は 1 つのステップでコンストラクトおよびその props オブジェクトを構築できるようにするため、`Function` 用にあります。このコードは後者を使用します。
+ C\$1 では、オブジェクト初期化子を使用して `FunctionProps` オブジェクトをインスタンス化し、3 番目のパラメータとして渡します。
コンストラクトの props がオプションの場合、`props` パラメータを完全に省略できます。
すべてのコンストラクトはこれらの 3 つの引数を取るため、新しい引数について知るときに方向性の意識を維持しやすくなります。さらに予想どおり、必要に応じて、あるいはデフォルトを変更する場合、任意のコンストラクトをサブクラス化して拡張できます。
## ステップ 7: Lambda 関数 URL の定義
このステップでは、`Function` コンストラクトの `addFunctionUrl` ヘルパーメソッドを使用し、Lambda 関数 URL を定義します。デプロイ時にこの URL の値を出力するには、 [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)コンストラクトを使用して AWS CloudFormation 出力を作成します。
次の内容を CDK スタックファイルに追加します。
**Example**
`lib/hello-cdk-stack.ts` にあります
```
// ...
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new cdk.CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
```
`lib/hello-cdk-stack.js` にあります
```
const { Stack, CfnOutput } = require('aws-cdk-lib'); // Import CfnOutput
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
module.exports = { HelloCdkStack }
```
`hello_cdk/hello_cdk_stack.py` にあります
```
from aws_cdk import (
# ...
CfnOutput # Import CfnOutput
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
# ...
# Define the Lambda function URL resource
my_function_url = my_function.add_function_url(
auth_type = _lambda.FunctionUrlAuthType.NONE,
)
# Define a CloudFormation output for your URL
CfnOutput(self, "myFunctionUrlOutput", value=my_function_url.url)
```
`src/main/java/…/HelloCdkStack.java` にあります
```
package com.myorg;
// ...
// Import Lambda function URL
import software.amazon.awscdk.services.lambda.FunctionUrl;
import software.amazon.awscdk.services.lambda.FunctionUrlAuthType;
import software.amazon.awscdk.services.lambda.FunctionUrlOptions;
// Import CfnOutput
import software.amazon.awscdk.CfnOutput;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
FunctionUrl myFunctionUrl = myFunction.addFunctionUrl(FunctionUrlOptions.builder()
.authType(FunctionUrlAuthType.NONE)
.build());
// Define a CloudFormation output for your URL
CfnOutput.Builder.create(this, "myFunctionUrlOutput")
.value(myFunctionUrl.getUrl())
.build();
}
}
```
`src/main/java/…/HelloCdkStack.java` にあります
```
// ...
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
var myFunctionUrl = myFunction.AddFunctionUrl(new FunctionUrlOptions
{
AuthType = FunctionUrlAuthType.NONE
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", new CfnOutputProps
{
Value = myFunctionUrl.Url
});
}
}
}
```
`hello-cdk.go` にあります
```
// ...
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
myFunctionUrl := myFunction.AddFunctionUrl(&awslambda.FunctionUrlOptions{
AuthType: awslambda.FunctionUrlAuthType_NONE,
})
// Define a CloudFormation output for your URL
awscdk.NewCfnOutput(stack, jsii.String("myFunctionUrlOutput"), &awscdk.CfnOutputProps{
Value: myFunctionUrl.Url(),
})
return stack
}
// ...
```
**警告**
このチュートリアルを簡単にするため、Lambda 関数 URL は認証なしで定義されます。デプロイすると、関数の呼び出しに使用できるパブリックアクセス可能なエンドポイントが作成されます。このチュートリアルを完了したら、「[ステップ 12: アプリケーションを削除する](#hello-world-delete)」に従ってこれらのリソースを削除します。
## ステップ 8: CloudFormation テンプレートの合成
このステップでは、CDK CLI の `cdk synth` コマンドを使用して CloudFormation テンプレートを合成することにより、デプロイの準備をします。このコマンドは CDK コードの基本的な検証の実行、CDK アプリの実行、CDK スタックから CloudFormation テンプレートの生成をします。
アプリに複数のスタックが含まれている場合、合成するスタックを指定する必要があります。アプリに 1 つのスタックが含まれているため、CDK CLI は合成するスタックを自動的に検出します。
テンプレートを合成しない場合、デプロイ時に CDK CLI はこのステップを自動的に実行します。ただし、合成エラーを確認するには、各デプロイの前にこのステップを実行することをお勧めします。
テンプレートを合成する前に、オプションでアプリケーションを構築し、構文および入力エラーをキャッチできます。手順については、「[ステップ 4: CDK アプリを構築する](#hello-world-build)」を参照してください。
CloudFormation テンプレートを合成するには、プロジェクトのルートから次の内容を実行します。
```
$ cdk synth
```
**注記**
次のようなエラーが表示された場合、`hello-cdk` ディレクトリにいることを確認してもう一度やり直してください。
```
--app is required either in command-line, in cdk.json or in ~/.cdk.json
```
正常に処理された場合、CDK CLI は `YAML` にフォーマットされた CloudFormation テンプレートを `stdout` に出力し、`JSON` にフォーマットされたテンプレートをプロジェクトの `cdk.out` ディレクトリに保存します。
次の内容は、 CloudFormation テンプレートの出力の例です。
### AWS CloudFormation テンプレート
```
Resources:
HelloWorldFunctionServiceRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Statement:
- Action: sts:AssumeRole
Effect: Allow
Principal:
Service: lambda.amazonaws.com
Version: "2012-10-17"
ManagedPolicyArns:
- Fn::Join:
- ""
- - "arn:"
- Ref: AWS::Partition
- :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/ServiceRole/Resource
HelloWorldFunction:
Type: AWS::Lambda::Function
Properties:
Code:
ZipFile: "
\ exports.handler = async function(event) {
\ return {
\ statusCode: 200,
\ body: JSON.stringify('Hello World!'),
\ };
\ };
\ "
Handler: index.handler
Role:
Fn::GetAtt:
- HelloWorldFunctionServiceRole
- Arn
Runtime: nodejs20.x
DependsOn:
- HelloWorldFunctionServiceRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
HelloWorldFunctionFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: NONE
TargetFunctionArn:
Fn::GetAtt:
- HelloWorldFunction
- Arn
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
HelloWorldFunctioninvokefunctionurl:
Type: AWS::Lambda::Permission
Properties:
Action: lambda:InvokeFunctionUrl
FunctionName:
Fn::GetAtt:
- HelloWorldFunction
- Arn
FunctionUrlAuthType: NONE
Principal: "*"
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Analytics: v2:deflate64:
Metadata:
aws:cdk:path: HelloCdkStack/CDKMetadata/Default
Condition: CDKMetadataAvailable
Outputs:
myFunctionUrlOutput:
Value:
Fn::GetAtt:
- HelloWorldFunctionFunctionUrl
- FunctionUrl
Parameters:
BootstrapVersion:
Type: AWS::SSM::Parameter::Value
Default: /cdk-bootstrap//version
Description: Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]
Rules:
CheckBootstrapVersion:
Assertions:
- Assert:
Fn::Not:
- Fn::Contains:
- - "1"
- "2"
- "3"
- "4"
- "5"
- Ref: BootstrapVersion
AssertDescription: CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI.
```
**注記**
生成されたすべてのテンプレートには、デフォルトで ` AWS::CDK::Metadata` リソースが含まれています。 AWS CDK チームは、このメタデータを使用して AWS CDK の使用状況を把握し、その改善方法を見つけます。バージョンのレポート作成からオプトアウトする方法などの詳細については、「[バージョンのレポート作成](cli.md#version-reporting)」を参照してください。
単一の L2 コンストラクトを定義することで、 AWS CDK は Lambda リソースと、リソースがアプリケーション内でやり取りするために必要なアクセス許可とグルーロジックを含む広範な CloudFormation テンプレートを作成します。
## ステップ 9: CDK スタックのデプロイ
このステップでは、CDK CLI の `cdk deploy` コマンドを使用して CDK スタックをデプロイします。このコマンドは、生成された CloudFormation テンプレートを取得し、 AWS CloudFormation を介してデプロイします。CloudFormation は、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`、アプリケーションには 1 つのスタックが含まれているため、 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 を使用して Lambda 関数を呼び出す AWS ことで、 でアプリケーションとやり取りします。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`スタックの latest 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/)を試し、より複雑なプロジェクトに関連する詳細なチュートリアルを体験できます。
+ お好みのサービスで使用できる CDK コンストラクトの探索を開始するには、 [API リファレンス](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html)を参照してください AWS 。
+ [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)」を参照してください。