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

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

# AWS CDK 專案
<a name="projects"></a>

 AWS 雲端開發套件 (AWS CDK) 專案代表包含 CDK 程式碼的檔案和資料夾。內容會根據您的程式設計語言而有所不同。

您可以手動或使用 AWS CDK 命令列界面 (AWS CDK CLI) `cdk init`命令建立 AWS CDK 專案。在本主題中，我們將參考由 AWS CDK CLI 建立之檔案和資料夾的專案結構和命名慣例。您可以自訂和組織 CDK 專案，以符合您的需求。

**注意**  
 AWS CDK CLI 建立的專案結構可能會隨著時間的推移而因版本而異。

## 通用檔案和資料夾
<a name="projects-universal"></a><a name="projects-universal-git"></a>

 `.git`   
如果您`git`已安裝 ， AWS CDK CLI 會自動初始化專案的Git儲存庫。`.git` 目錄包含儲存庫的相關資訊。<a name="projects-universal-gitignore"></a>

 `.gitignore`   
Git 用來指定要忽略之檔案和資料夾的文字檔案。<a name="projects-universal-readme"></a>

 `README.md`   
提供您管理 AWS CDK 專案之基本指引和重要資訊的文字檔案。視需要修改此檔案，以記錄有關 CDK 專案的重要資訊。<a name="projects-universal-cdk"></a>

 `cdk.json`   
 AWS CDK 的組態檔案。此檔案提供 AWS CDK CLI 有關如何執行應用程式的指示。

## 語言特定的檔案和資料夾
<a name="projects-specific"></a>

下列檔案和資料夾對於每個支援的程式設計語言都是唯一的。

**Example**  
以下是使用 `cdk init --language typescript`命令在 `my-cdk-ts-project`目錄中建立的範例專案：  

```
my-cdk-ts-project
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│   └── my-cdk-ts-project.ts
├── cdk.json
├── jest.config.js
├── lib
│   └── my-cdk-ts-project-stack.ts
├── node_modules
├── package-lock.json
├── package.json
├── test
│   └── my-cdk-ts-project.test.ts
└── tsconfig.json
```  
 `.npmignore`   
檔案，指定在將套件發佈至`npm`登錄檔時要忽略哪些檔案和資料夾。此檔案類似於 `.gitignore`，但專屬於`npm`套件。  
 `bin/my-cdk-ts-project.ts`   
*應用程式檔案*會定義您的 CDK 應用程式。CDK 專案可以包含一或多個應用程式檔案。應用程式檔案會存放在 `bin` 資料夾中。  
以下是定義 CDK 應用程式的基本應用程式檔案範例：  

```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { MyCdkTsProjectStack } from '../lib/my-cdk-ts-project-stack';

const app = new cdk.App();
new MyCdkTsProjectStack(app, 'MyCdkTsProjectStack');
```  
 `jest.config.js`   
的組態檔案Jest。 *Jest * 是熱門的 JavaScript 測試架構。  
 `lib/my-cdk-ts-project-stack.ts`   
*堆疊檔案*會定義您的 CDK 堆疊。在堆疊中，您可以使用 建構來定義 AWS 資源和屬性。  
以下是定義 CDK 堆疊的基本堆疊檔案範例：  

```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export class MyCdkTsProjectStack extends cdk.Stack {
 constructor(scope: Construct, id: string, props?: cdk.StackProps) {
  super(scope, id, props);

  // code that defines your resources and properties go here
 }
}
```  
 `node_modules`   
Node.js 專案中的常見資料夾，其中包含專案的相依性。  
 `package-lock.json`   
與 檔案搭配使用以管理相依性版本的中繼資料`package.json`檔案。  
 `package.json`   
Node.js 專案中常用的中繼資料檔案。此檔案包含 CDK 專案的相關資訊，例如專案名稱、指令碼定義、相依性和其他匯入專案層級資訊。  
 `test/my-cdk-ts-project.test.ts`   
會建立測試資料夾來組織 CDK 專案的測試。也會建立範例測試檔案。  
您可以在 TypeScript 中撰寫測試，並使用 Jest 在執行測試之前編譯 TypeScript 程式碼。  
 `tsconfig.json`   
TypeScript 專案中使用的組態檔案，可指定編譯器選項和專案設定。
以下是使用 `cdk init --language javascript`命令在 `my-cdk-js-project`目錄中建立的範例專案：  

```
my-cdk-js-project
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│   └── my-cdk-js-project.js
├── cdk.json
├── jest.config.js
├── lib
│   └── my-cdk-js-project-stack.js
├── node_modules
├── package-lock.json
├── package.json
└── test
    └── my-cdk-js-project.test.js
```  
 `.npmignore`   
檔案，指定在將套件發佈至`npm`登錄檔時要忽略哪些檔案和資料夾。此檔案類似於 `.gitignore`，但專屬於`npm`套件。  
 `bin/my-cdk-js-project.js`   
*應用程式檔案*會定義您的 CDK 應用程式。CDK 專案可以包含一或多個應用程式檔案。應用程式檔案會存放在 `bin` 資料夾中。  
以下是定義 CDK 應用程式的基本應用程式檔案範例：  

```
#!/usr/bin/env node

const cdk = require('aws-cdk-lib');
const { MyCdkJsProjectStack } = require('../lib/my-cdk-js-project-stack');

const app = new cdk.App();
new MyCdkJsProjectStack(app, 'MyCdkJsProjectStack');
```  
 `jest.config.js`   
的組態檔案Jest。 *Jest * 是熱門的 JavaScript 測試架構。  
 `lib/my-cdk-js-project-stack.js`   
*堆疊檔案*會定義您的 CDK 堆疊。在堆疊中，您可以使用 建構來定義 AWS 資源和屬性。  
以下是定義 CDK 堆疊的基本堆疊檔案範例：  

```
const { Stack, Duration } = require('aws-cdk-lib');

class MyCdkJsProjectStack extends Stack {
 constructor(scope, id, props) {
  super(scope, id, props);

  // code that defines your resources and properties go here
 }
}

module.exports = { MyCdkJsProjectStack }
```  
 `node_modules`   
Node.js 專案中的常見資料夾，其中包含專案的相依性。  
 `package-lock.json`   
與 檔案搭配使用以管理相依性版本的中繼資料`package.json`檔案。  
 `package.json`   
Node.js 專案中常用的中繼資料檔案。此檔案包含 CDK 專案的相關資訊，例如專案名稱、指令碼定義、相依性和其他匯入專案層級資訊。  
 `test/my-cdk-js-project.test.js`   
會建立測試資料夾來組織 CDK 專案的測試。也會建立範例測試檔案。  
您可以在 JavaScript 中撰寫測試，並使用 Jest 在執行測試之前編譯 JavaScript 程式碼。
以下是使用 `cdk init --language python`命令在 `my-cdk-py-project`目錄中建立的範例專案：  

```
my-cdk-py-project
├── .git
├── .gitignore
├── .venv
├── README.md
├── app.py
├── cdk.json
├── my_cdk_py_project
│   ├── __init__.py
│   └── my_cdk_py_project_stack.py
├── requirements-dev.txt
├── requirements.txt
├── source.bat
└── tests
    ├── __init__.py
    └── unit
```  
 `.venv`   
CDK CLI 會自動為您的專案建立虛擬環境。`.venv` 目錄是指此虛擬環境。  
 `app.py`   
*應用程式檔案*會定義您的 CDK 應用程式。CDK 專案可以包含一或多個應用程式檔案。  
以下是定義 CDK 應用程式的基本應用程式檔案範例：  

```
#!/usr/bin/env python3
import os

import aws_cdk as cdk

from my_cdk_py_project.my_cdk_py_project_stack import MyCdkPyProjectStack

app = cdk.App()
MyCdkPyProjectStack(app, "MyCdkPyProjectStack")

app.synth()
```  
 `my_cdk_py_project`   
包含*堆疊檔案*的目錄。CDK CLI 在此處建立下列項目：  
+ \$1\$1init\$1\$1.py – 空的 Python 套件定義檔案。
+  `my_cdk_py_project` – 定義 CDK 堆疊的檔案。然後，您可以使用 建構模組定義堆疊內的 AWS 資源和屬性。
以下是堆疊檔案的範例：  

```
from aws_cdk import Stack

from constructs import Construct

class MyCdkPyProjectStack(Stack):
 def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
  super().__init__(scope, construct_id, **kwargs)

  # code that defines your resources and properties go here
```  
 `requirements-dev.txt`   
類似於 的檔案`requirements.txt`，但用於管理專門用於開發目的而非生產的相依性。  
 `requirements.txt`   
Python 專案中用來指定和管理專案相依性的常見檔案。  
 `source.bat`   
用於設定 Python 虛擬環境Windows的 批次檔案。  
 `tests`   
包含 CDK 專案測試的目錄。  
以下是單元測試的範例：  

```
import aws_cdk as core
import aws_cdk.assertions as assertions

from my_cdk_py_project.my_cdk_py_project_stack import MyCdkPyProjectStack

def test_sqs_queue_created():
 app = core.App()
 stack = MyCdkPyProjectStack(app, "my-cdk-py-project")
 template = assertions.Template.from_stack(stack)

 template.has_resource_properties("AWS::SQS::Queue", {
  "VisibilityTimeout": 300
 })
```
以下是使用 `cdk init --language java`命令在 `my-cdk-java-project`目錄中建立的範例專案：  

```
my-cdk-java-project
├── .git
├── .gitignore
├── README.md
├── cdk.json
├── pom.xml
└── src
    ├── main
    └── test
```  
 `pom.xml`   
包含 CDK 專案組態資訊和中繼資料的檔案。此檔案是 的一部分Maven。  
 `src/main`   
包含您的*應用程式*和*堆疊*檔案的目錄。  
以下是範例應用程式檔案：  

```
package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;

import java.util.Arrays;

public class MyCdkJavaProjectApp {
 public static void main(final String[] args) {
  App app = new App();

  new MyCdkJavaProjectStack(app, "MyCdkJavaProjectStack", StackProps.builder()
   .build());

  app.synth();
 }
}
```
以下是堆疊檔案的範例：  

```
package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;

public class MyCdkJavaProjectStack extends Stack {
 public MyCdkJavaProjectStack(final Construct scope, final String id) {
  this(scope, id, null);
 }

 public MyCdkJavaProjectStack(final Construct scope, final String id, final StackProps props) {
  super(scope, id, props);

  // code that defines your resources and properties go here
 }
}
```  
 `src/test`   
包含測試檔案的目錄。以下是範例：  

```
package com.myorg;

import software.amazon.awscdk.App;
import software.amazon.awscdk.assertions.Template;
import java.io.IOException;

import java.util.HashMap;

import org.junit.jupiter.api.Test;

public class MyCdkJavaProjectTest {

 @Test
 public void testStack() throws IOException {
  App app = new App();
  MyCdkJavaProjectStack stack = new MyCdkJavaProjectStack(app, "test");

  Template template = Template.fromStack(stack);

  template.hasResourceProperties("AWS::SQS::Queue", new HashMap<String, Number>() {{
   put("VisibilityTimeout", 300);
  }});
 }
}
```
以下是使用 `cdk init --language csharp`命令在 `my-cdk-csharp-project`目錄中建立的範例專案：  

```
my-cdk-csharp-project
├── .git
├── .gitignore
├── README.md
├── cdk.json
└── src
    ├── MyCdkCsharpProject
    └── MyCdkCsharpProject.sln
```  
 `src/MyCdkCsharpProject`   
包含您的*應用程式*和*堆疊*檔案的目錄。  
以下是範例應用程式檔案：  

```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;

namespace MyCdkCsharpProject
{
 sealed class Program
 {
  public static void Main(string[] args)
  {
   var app = new App();
   new MyCdkCsharpProjectStack(app, "MyCdkCsharpProjectStack", new StackProps{});
   app.Synth();
  }
 }
}
```
以下是堆疊檔案的範例：  

```
using Amazon.CDK;
using Constructs;

namespace MyCdkCsharpProject
{
 public class MyCdkCsharpProjectStack : Stack
 {
  internal MyCdkCsharpProjectStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
  {
   // code that defines your resources and properties go here
  }
 }
}
```
此目錄也包含下列項目：  
  
+  `GlobalSuppressions.cs` – 用來隱藏專案中特定編譯器警告或錯誤的檔案。
+  `.csproj` – 用於定義專案設定、相依性和建置組態的 XML 型檔案。  
 `src/MyCdkCsharpProject.sln`   
 Microsoft Visual Studio Solution File 用來組織和管理相關專案。
以下是使用 `cdk init --language go`命令在 `my-cdk-go-project`目錄中建立的範例專案：  

```
my-cdk-go-project
├── .git
├── .gitignore
├── README.md
├── cdk.json
├── go.mod
├── my-cdk-go-project.go
└── my-cdk-go-project_test.go
```  
 `go.mod`   
包含模組資訊的檔案，用於管理Go專案的相依性和版本控制。  
 `my-cdk-go-project.go`   
定義 CDK 應用程式和堆疊的檔案。  
以下是範例：  

```
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 MyCdkGoProjectStackProps struct {
 awscdk.StackProps
}

func NewMyCdkGoProjectStack(scope constructs.Construct, id string, props *MyCdkGoProjectStackProps) awscdk.Stack {
 var sprops awscdk.StackProps
 if props != nil {
  sprops = props.StackProps
 }
 stack := awscdk.NewStack(scope, &id, &sprops)
 // The code that defines your resources and properties go here

  return stack
}

func main() {
 defer jsii.Close()
 app := awscdk.NewApp(nil)
 NewMyCdkGoProjectStack(app, "MyCdkGoProjectStack", &MyCdkGoProjectStackProps{
  awscdk.StackProps{
   Env: env(),
  },
 })
 app.Synth(nil)
}

func env() *awscdk.Environment {

 return nil
}
```  
 `my-cdk-go-project_test.go`   
定義範例測試的檔案。  
以下是範例：  

```
package main

import (
 "testing"

 "github.com/aws/aws-cdk-go/awscdk/v2"
 "github.com/aws/aws-cdk-go/awscdk/v2/assertions"
 "github.com/aws/jsii-runtime-go"
)

func TestMyCdkGoProjectStack(t *testing.T) {

 // GIVEN
 app := awscdk.NewApp(nil)

 // WHEN
 stack := NewMyCdkGoProjectStack(app, "MyStack", nil)

 // THEN
 template := assertions.Template_FromStack(stack, nil)
 template.HasResourceProperties(jsii.String("AWS::SQS::Queue"), map[string]interface{}{
  "VisibilityTimeout": 300,
 })
}
```