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

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

# 資源和 AWS CDK
<a name="resources"></a>

 *資源*是您設定為在應用程式中使用 AWS 服務的資源。資源是 AWS CloudFormation 的一項功能。透過在 a AWS CloudFormation 範本中設定資源及其屬性，您可以部署至 AWS CloudFormation 來佈建資源。使用 AWS 雲端開發套件 (AWS CDK)，您可以透過 建構設定資源。然後，您可以部署 CDK 應用程式，其中包含合成 a AWS CloudFormation 範本和部署至 AWS CloudFormation 以佈建資源。

## 使用 建構設定資源
<a name="resources-configure"></a>

如 [AWS CDK 建構](constructs.md)中所述， AWS CDK 提供豐富的建構類別程式庫，稱為*建構*，代表所有 AWS 資源。

若要使用其對應的建構模組建立資源執行個體，請傳入 範圍做為第一個引數、建構的邏輯 ID，以及一組組態屬性 (props)。例如，以下說明如何使用 AWS 建構程式庫中的 [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_sqs.Queue.html) 建構模組，建立具有 AWS KMS 加密的 Amazon SQS 佇列。

**Example**  

```
import * as sqs from '@aws-cdk/aws-sqs';

new sqs.Queue(this, 'MyQueue', {
    encryption: sqs.QueueEncryption.KMS_MANAGED
});
```

```
const sqs = require('@aws-cdk/aws-sqs');

new sqs.Queue(this, 'MyQueue', {
    encryption: sqs.QueueEncryption.KMS_MANAGED
});
```

```
import aws_cdk.aws_sqs as sqs

sqs.Queue(self, "MyQueue", encryption=sqs.QueueEncryption.KMS_MANAGED)
```

```
import software.amazon.awscdk.services.sqs.*;

Queue.Builder.create(this, "MyQueue").encryption(
        QueueEncryption.KMS_MANAGED).build();
```

```
using Amazon.CDK.AWS.SQS;

new Queue(this, "MyQueue", new QueueProps
{
    Encryption = QueueEncryption.KMS_MANAGED
});
```

```
import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  sqs "github.com/aws/aws-cdk-go/awscdk/v2/awssqs"
)

sqs.NewQueue(stack, jsii.String("MyQueue"), &sqs.QueueProps{
  Encryption: sqs.QueueEncryption_KMS_MANAGED,
})
```

有些組態道具是選用的，在許多情況下都有預設值。在某些情況下，所有道具都是選用的，而且可以完全省略最後一個引數。

### 資源屬性
<a name="resources-attributes"></a>

 AWS Construct Library 中的大多數資源都會公開屬性，這些屬性會在部署時間由 AWS CloudFormation 解析。屬性會以 資源類別上的屬性形式公開，並將類型名稱做為字首。下列範例示範如何使用 `queueUrl`(Python：`queue_url`) 屬性取得 Amazon SQS 佇列的 URL。

**Example**  

```
import * as sqs from '@aws-cdk/aws-sqs';

const queue = new sqs.Queue(this, 'MyQueue');
const url = queue.queueUrl; // => A string representing a deploy-time value
```

```
const sqs = require('@aws-cdk/aws-sqs');

const queue = new sqs.Queue(this, 'MyQueue');
const url = queue.queueUrl; // => A string representing a deploy-time value
```

```
import aws_cdk.aws_sqs as sqs

queue = sqs.Queue(self, "MyQueue")
url = queue.queue_url # => A string representing a deploy-time value
```

```
Queue queue = new Queue(this, "MyQueue");
String url = queue.getQueueUrl();    // => A string representing a deploy-time value
```

```
var queue = new Queue(this, "MyQueue");
var url = queue.QueueUrl; // => A string representing a deploy-time value
```

```
import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  sqs "github.com/aws/aws-cdk-go/awscdk/v2/awssqs"
)

queue := sqs.NewQueue(stack, jsii.String("MyQueue"), &sqs.QueueProps{})
url := queue.QueueUrl() // => A string representing a deploy-time value
```

如需 [AWS CDK 如何將部署時間屬性編碼為字串的相關資訊，請參閱權杖和](tokens.md) AWS CDK。

## 參考資源
<a name="resources-referencing"></a>

設定資源時，您通常必須參考另一個資源的屬性。範例如下：
+ Amazon Elastic Container Service (Amazon ECS) 資源需要其執行所在叢集的參考。
+ Amazon CloudFront 分佈需要參考包含原始碼的 Amazon Simple Storage Service (Amazon S3) 儲存貯體。

您可以透過下列任何方式參考資源：
+ 透過在相同堆疊或不同堆疊中傳遞 CDK 應用程式中定義的資源
+ 透過傳遞參考您 AWS 帳戶中定義之資源的代理物件，從資源的唯一識別符 （例如 ARN) 建立

如果建構的 屬性代表另一個資源的建構，則其類型是建構的界面類型。例如，Amazon ECS 建構會使用類型 `cluster`的屬性`ecs.ICluster`。另一個範例是採用類型 之 屬性 `sourceBucket`(Python：`source_bucket`) 的 CloudFront 分佈建構`s3.IBucket`。

您可以直接傳遞相同 AWS CDK 應用程式中定義之適當類型的任何資源物件。下列範例會定義 Amazon ECS 叢集，然後使用它來定義 Amazon ECS 服務。

**Example**  

```
const cluster = new ecs.Cluster(this, 'Cluster', { /*...*/ });

const service = new ecs.Ec2Service(this, 'Service', { cluster: cluster });
```

```
const cluster = new ecs.Cluster(this, 'Cluster', { /*...*/ });

const service = new ecs.Ec2Service(this, 'Service', { cluster: cluster });
```

```
cluster = ecs.Cluster(self, "Cluster")

service = ecs.Ec2Service(self, "Service", cluster=cluster)
```

```
Cluster cluster = new Cluster(this, "Cluster");
Ec2Service service = new Ec2Service(this, "Service",
        new Ec2ServiceProps.Builder().cluster(cluster).build());
```

```
var cluster = new Cluster(this, "Cluster");
var service = new Ec2Service(this, "Service", new Ec2ServiceProps { Cluster = cluster });
```

```
import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  ecs "github.com/aws/aws-cdk-go/awscdk/v2/awsecs"
)

cluster := ecs.NewCluster(stack, jsii.String("MyCluster"), &ecs.ClusterProps{})
service := ecs.NewEc2Service(stack, jsii.String("MyService"), &ecs.Ec2ServiceProps{
  Cluster: cluster,
})
```

### 參考不同堆疊中的資源
<a name="resource-stack"></a>

您可以參考不同堆疊中的資源，只要它們是在相同的應用程式中定義，並且位於相同的 AWS 環境中即可。通常會使用以下模式：
+ 將 建構的參考儲存為產生資源之堆疊的屬性。（若要取得目前建構的堆疊參考，請使用 `Stack.of(this)`。)
+ 將此參考傳遞給使用資源做為參數或 屬性的堆疊建構函式。然後，耗用堆疊會將它做為屬性傳遞給任何需要它的建構。

下列範例定義堆疊 `stack1`。此堆疊會定義 Amazon S3 儲存貯體，並將儲存貯體建構的參考儲存為堆疊的屬性。然後，應用程式會定義第二個堆疊 `stack2`，它在執行個體化時接受儲存貯體。 `stack2`可能會定義使用儲存貯體進行資料儲存的 AWS Glue 資料表。

**Example**  

```
const prod = { account: '123456789012', region: 'us-east-1' };

const stack1 = new StackThatProvidesABucket(app, 'Stack1', { env: prod });

// stack2 will take a property { bucket: IBucket }
const stack2 = new StackThatExpectsABucket(app, 'Stack2', {
  bucket: stack1.bucket,
  env: prod
});
```

```
const prod = { account: '123456789012', region: 'us-east-1' };

const stack1 = new StackThatProvidesABucket(app, 'Stack1', { env: prod });

// stack2 will take a property { bucket: IBucket }
const stack2 = new StackThatExpectsABucket(app, 'Stack2', {
  bucket: stack1.bucket,
  env: prod
});
```

```
prod = core.Environment(account="123456789012", region="us-east-1")

stack1 = StackThatProvidesABucket(app, "Stack1", env=prod)

# stack2 will take a property "bucket"
stack2 = StackThatExpectsABucket(app, "Stack2", bucket=stack1.bucket, env=prod)
```

```
// Helper method to build an environment
static Environment makeEnv(String account, String region) {
    return Environment.builder().account(account).region(region)
            .build();
}

App app = new App();

Environment prod = makeEnv("123456789012", "us-east-1");

StackThatProvidesABucket stack1 = new StackThatProvidesABucket(app, "Stack1",
        StackProps.builder().env(prod).build());

// stack2 will take an argument "bucket"
StackThatExpectsABucket stack2 = new StackThatExpectsABucket(app, "Stack,",
        StackProps.builder().env(prod).build(), stack1.bucket);
```

```
Amazon.CDK.Environment makeEnv(string account, string region)
{
    return new Amazon.CDK.Environment { Account = account, Region = region };
}

var prod = makeEnv(account: "123456789012", region: "us-east-1");

var stack1 = new StackThatProvidesABucket(app, "Stack1", new StackProps { Env = prod });

// stack2 will take a property "bucket"
var stack2 = new StackThatExpectsABucket(app, "Stack2", new StackProps { Env = prod,
    bucket = stack1.Bucket});
```

如果 AWS CDK 判斷資源位於相同環境，但在不同的堆疊中，會自動合成生產堆疊中的 AWS CloudFormation [匯出](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-exports.html)，以及在耗用堆疊[https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-importvalue.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-importvalue.html)中的 匯出，以將該資訊從一個堆疊傳輸到另一個堆疊。

#### 解決相依性死結
<a name="resources-deadlock"></a>

從不同堆疊中的一個堆疊參考資源會在兩個堆疊之間建立相依性。這可確保它們以正確的順序部署。部署堆疊之後，此相依性即為具體。之後，從耗用堆疊中移除共用資源的使用可能會導致非預期的部署失敗。如果兩個堆疊之間存在另一個相依性，強制它們以相同的順序部署，就會發生這種情況。如果生產堆疊直接由 CDK Toolkit 選擇要先部署，也可能在沒有相依性的情況下發生。 AWS CloudFormation 匯出會從生產堆疊中移除，因為它不再需要，但匯出的資源仍在耗用堆疊中使用，因為它的更新尚未部署。因此，部署生產者堆疊失敗。

若要破壞此死結，請從耗用堆疊中移除共用資源的使用。（這會從生產堆疊中移除自動匯出。) 接著，使用與自動產生的匯出完全相同的邏輯 ID，手動將相同的匯出新增至生產堆疊。移除耗用堆疊中共用資源的使用，並部署這兩個堆疊。然後，移除手動匯出 （以及不再需要的共用資源），然後再次部署這兩個堆疊。堆疊的 [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html#exportwbrvalueexportedvalue-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html#exportwbrvalueexportedvalue-options)方法是一種方便的方法，可為此目的建立手動匯出。（請參閱連結方法參考中的範例。)

### 參考您 AWS 帳戶中的資源
<a name="resources-external"></a>

假設您想要在 AWS CDK 應用程式中使用 AWS 帳戶中已有的資源。這可能是透過 主控台、 AWS 開發套件、直接使用 AWS CloudFormation 或在不同 AWS CDK 應用程式中定義的資源。您可以將資源的 ARN （或其他識別屬性或屬性群組） 轉換為代理物件。代理物件透過呼叫資源類別上的靜態原廠方法，做為資源的參考。

當您建立這類代理時，外部資源**不會**成為 AWS CDK 應用程式的一部分。因此，您在 AWS CDK 應用程式中對代理所做的變更不會影響部署的資源。不過，代理可以傳遞到任何需要該類型資源的 AWS CDK 方法。

下列範例顯示如何根據具有 ARN 的現有儲存貯體來參考儲存貯體`arn:aws:s3:::amzn-s3-demo-bucket1`，以及根據具有特定 ID 的現有 VPC 來參考 Amazon Virtual Private Cloud。

**Example**  

```
// Construct a proxy for a bucket by its name (must be same account)
s3.Bucket.fromBucketName(this, 'MyBucket', 'amzn-s3-demo-bucket1');

// Construct a proxy for a bucket by its full ARN (can be another account)
s3.Bucket.fromBucketArn(this, 'MyBucket', 'arn:aws:s3:::amzn-s3-demo-bucket1');

// Construct a proxy for an existing VPC from its attribute(s)
ec2.Vpc.fromVpcAttributes(this, 'MyVpc', {
  vpcId: 'vpc-1234567890abcde',
});
```

```
// Construct a proxy for a bucket by its name (must be same account)
s3.Bucket.fromBucketName(this, 'MyBucket', 'amzn-s3-demo-bucket1');

// Construct a proxy for a bucket by its full ARN (can be another account)
s3.Bucket.fromBucketArn(this, 'MyBucket', 'arn:aws:s3:::amzn-s3-demo-bucket1');

// Construct a proxy for an existing VPC from its attribute(s)
ec2.Vpc.fromVpcAttributes(this, 'MyVpc', {
  vpcId: 'vpc-1234567890abcde'
});
```

```
# Construct a proxy for a bucket by its name (must be same account)
s3.Bucket.from_bucket_name(self, "MyBucket", "amzn-s3-demo-bucket1")

# Construct a proxy for a bucket by its full ARN (can be another account)
s3.Bucket.from_bucket_arn(self, "MyBucket", "arn:aws:s3:::amzn-s3-demo-bucket1")

# Construct a proxy for an existing VPC from its attribute(s)
ec2.Vpc.from_vpc_attributes(self, "MyVpc", vpc_id="vpc-1234567890abcdef")
```

```
// Construct a proxy for a bucket by its name (must be same account)
Bucket.fromBucketName(this, "MyBucket", "amzn-s3-demo-bucket1");

// Construct a proxy for a bucket by its full ARN (can be another account)
Bucket.fromBucketArn(this, "MyBucket",
        "arn:aws:s3:::amzn-s3-demo-bucket1");

// Construct a proxy for an existing VPC from its attribute(s)
Vpc.fromVpcAttributes(this, "MyVpc", VpcAttributes.builder()
        .vpcId("vpc-1234567890abcdef").build());
```

```
// Construct a proxy for a bucket by its name (must be same account)
Bucket.FromBucketName(this, "MyBucket", "amzn-s3-demo-bucket1");

// Construct a proxy for a bucket by its full ARN (can be another account)
Bucket.FromBucketArn(this, "MyBucket", "arn:aws:s3:::amzn-s3-demo-bucket1");

// Construct a proxy for an existing VPC from its attribute(s)
Vpc.FromVpcAttributes(this, "MyVpc", new VpcAttributes
{
    VpcId = "vpc-1234567890abcdef"
});
```

```
// Define a proxy for a bucket by its name (must be same account)
s3.Bucket_FromBucketName(stack, jsii.String("MyBucket"), jsii.String("amzn-s3-demo-bucket1"))

// Define a proxy for a bucket by its full ARN (can be another account)
s3.Bucket_FromBucketArn(stack, jsii.String("MyBucket"), jsii.String("arn:aws:s3:::amzn-s3-demo-bucket1"))

// Define a proxy for an existing VPC from its attributes
ec2.Vpc_FromVpcAttributes(stack, jsii.String("MyVpc"), &ec2.VpcAttributes{
  VpcId: jsii.String("vpc-1234567890abcde"),
})
```

讓我們進一步了解 [https://docs.aws.amazon.com/cdk/api/v1/docs/@aws-cdk_aws-ec2.Vpc.html#static-fromwbrlookupscope-id-options](https://docs.aws.amazon.com/cdk/api/v1/docs/@aws-cdk_aws-ec2.Vpc.html#static-fromwbrlookupscope-id-options)方法。由於 `ec2.Vpc` 建構結構很複雜，您可能會想透過多種方式選取要與 CDK 應用程式搭配使用的 VPC。為了解決此問題，VPC 建構具有靜態方法 `fromLookup` (Python：`from_lookup`)，可讓您在合成時查詢 AWS 您的帳戶，以查詢所需的 Amazon VPC。

若要使用 `Vpc.fromLookup()`，合成堆疊的系統必須能夠存取擁有 Amazon VPC 的帳戶。這是因為 CDK Toolkit 在合成時查詢帳戶以尋找正確的 Amazon VPC。

此外， `Vpc.fromLookup()` 僅適用於使用明確**帳戶**和**區域**定義的堆疊 （請參閱 [AWS CDK 的環境](environments.md))。如果 AWS CDK 嘗試從[與環境無關的堆疊](stacks.md#stack-api)中查詢 Amazon VPC，則 CDK Toolkit 不知道要查詢哪個環境來尋找 VPC。

您必須提供足以唯一識別您 AWS 帳戶中 VPC 的`Vpc.fromLookup()`屬性。例如，只能有一個預設 VPC，因此將 VPC 指定為預設值就足夠了。

**Example**  

```
ec2.Vpc.fromLookup(this, 'DefaultVpc', {
  isDefault: true
});
```

```
ec2.Vpc.fromLookup(this, 'DefaultVpc', {
  isDefault: true
});
```

```
ec2.Vpc.from_lookup(self, "DefaultVpc", is_default=True)
```

```
Vpc.fromLookup(this, "DefaultVpc", VpcLookupOptions.builder()
        .isDefault(true).build());
```

```
Vpc.FromLookup(this, id = "DefaultVpc", new VpcLookupOptions { IsDefault = true });
```

```
ec2.Vpc_FromLookup(this, jsii.String("DefaultVpc"), &ec2.VpcLookupOptions{
  IsDefault: jsii.Bool(true),
})
```

您也可以使用 `tags` 屬性，依標籤查詢 VPCs。您可以在建立標籤時，使用 AWS CloudFormation 或 AWS CDK 將標籤新增至 Amazon VPC。您可以使用 AWS 管理主控台、 CLI AWS 或 AWS 開發套件，在建立之後隨時編輯標籤。除了您自行新增的任何標籤之外， AWS CDK 也會自動將下列標籤新增至其建立的所有 VPCs。
+  **名稱** – VPC 的名稱。
+  **aws-cdk：subnet-name** – 子網路的名稱。
+  **aws-cdk：subnet-type** – 子網路的類型：公有、私有或隔離。

**Example**  

```
ec2.Vpc.fromLookup(this, 'PublicVpc',
    {tags: {'aws-cdk:subnet-type': "Public"}});
```

```
ec2.Vpc.fromLookup(this, 'PublicVpc',
    {tags: {'aws-cdk:subnet-type': "Public"}});
```

```
ec2.Vpc.from_lookup(self, "PublicVpc",
    tags={"aws-cdk:subnet-type": "Public"})
```

```
Vpc.fromLookup(this, "PublicVpc", VpcLookupOptions.builder()
        .tags(java.util.Map.of("aws-cdk:subnet-type", "Public"))  // Java 9 or later
        .build());
```

```
Vpc.FromLookup(this, id: "PublicVpc", new VpcLookupOptions
{
    Tags = new Dictionary<string, string> { ["aws-cdk:subnet-type"] = "Public" }
});
```

```
ec2.Vpc_FromLookup(this, jsii.String("DefaultVpc"), &ec2.VpcLookupOptions{
  Tags: &map[string]*string{"aws-cdk:subnet-type": jsii.String("Public")},
})
```

的結果會`Vpc.fromLookup()`快取在專案的 `cdk.context.json`檔案中。（請參閱[內容值和 AWS CDK](context.md)。) 將此檔案遞交至版本控制，讓您的應用程式將繼續參考相同的 Amazon VPC。即使您稍後以會導致選取不同 VPCs 的方式變更 VPC 的屬性，這也有效。如果您在無法存取定義 VPC 之 AWS 帳戶的環境中部署堆疊，例如 [CDK 管道](cdk-pipeline.md)，這尤其重要。

雖然您可以在使用 AWS CDK 應用程式中定義之類似資源的任何位置使用外部資源，但您無法修改它。例如，在外部呼叫 `addToResourcePolicy`(Python：`add_to_resource_policy`) 不會執行任何`s3.Bucket`動作。

## 資源實體名稱
<a name="resources-physical-names"></a>

在 AWS CloudFormation 部署資源之後， AWS CloudFormation 中的資源邏輯名稱與 AWS 管理主控台中顯示的資源名稱不同。 AWS CDK 會呼叫這些最終名稱*實體名稱*。

例如， AWS CloudFormation 可能會使用邏輯 ID `Stack2MyBucket4DD88B4F`和實體名稱 建立 Amazon S3 儲存貯體`stack2MyBucket4dd88b4f-iuv1rbv9z3to`。

您可以使用 屬性，在建立代表資源的建構時指定實體名稱`<resourceType>Name`。下列範例會建立實體名稱為 的 Amazon S3 儲存貯體`amzn-s3-demo-bucket`。

**Example**  

```
const bucket = new s3.Bucket(this, 'MyBucket', {
  bucketName: 'amzn-s3-demo-bucket',
});
```

```
const bucket = new s3.Bucket(this, 'MyBucket', {
  bucketName: 'amzn-s3-demo-bucket'
});
```

```
bucket = s3.Bucket(self, "MyBucket", bucket_name="amzn-s3-demo-bucket")
```

```
Bucket bucket = Bucket.Builder.create(this, "MyBucket")
        .bucketName("amzn-s3-demo-bucket").build();
```

```
var bucket = new Bucket(this, "MyBucket", new BucketProps { BucketName = "amzn-s3-demo-bucket" });
```

```
bucket := s3.NewBucket(this, jsii.String("MyBucket"), &s3.BucketProps{
  BucketName: jsii.String("amzn-s3-demo-bucket"),
})
```

將實體名稱指派給資源在 AWS CloudFormation 中有一些缺點。最重要的是，如果資源已指派實體名稱，則任何需要資源替換的已部署資源變更，例如資源屬性在建立後不可變的變更，都會失敗。如果您最終進入該狀態，唯一的解決方案是刪除 AWS CloudFormation 堆疊，然後再次部署 AWS CDK 應用程式。如需詳細資訊，請參閱 [AWS CloudFormation 文件](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html)。

在某些情況下，例如在建立具有跨環境參考的 AWS CDK 應用程式時， AWS CDK 需要實體名稱才能正常運作。在這些情況下，如果您不想煩惱自己提出實體名稱，您可以讓 AWS CDK 為您命名。若要這樣做，請使用特殊值 `PhysicalName.GENERATE_IF_NEEDED`，如下所示。

**Example**  

```
const bucket = new s3.Bucket(this, 'MyBucket', {
  bucketName: core.PhysicalName.GENERATE_IF_NEEDED,
});
```

```
const bucket = new s3.Bucket(this, 'MyBucket', {
  bucketName: core.PhysicalName.GENERATE_IF_NEEDED
});
```

```
bucket = s3.Bucket(self, "MyBucket",
                         bucket_name=core.PhysicalName.GENERATE_IF_NEEDED)
```

```
Bucket bucket = Bucket.Builder.create(this, "MyBucket")
        .bucketName(PhysicalName.GENERATE_IF_NEEDED).build();
```

```
var bucket = new Bucket(this, "MyBucket", new BucketProps
    { BucketName = PhysicalName.GENERATE_IF_NEEDED });
```

```
bucket := s3.NewBucket(this, jsii.String("MyBucket"), &s3.BucketProps{
  BucketName: awscdk.PhysicalName_GENERATE_IF_NEEDED(),
})
```

## 傳遞唯一資源識別符
<a name="resources-identifiers"></a>

盡可能透過參考傳遞資源，如上一節所述。不過，在某些情況下，您沒有其他選擇，只能透過其中一個屬性來參考資源。範例使用案例包括下列項目：
+ 當您使用低階 AWS CloudFormation 資源時。
+ 當您需要向 AWS CDK 應用程式的執行期元件公開資源時，例如透過環境變數參考 Lambda 函數時。

這些識別符可作為 資源上的屬性，如下所示。

**Example**  

```
bucket.bucketName
lambdaFunc.functionArn
securityGroup.groupArn
```

```
bucket.bucketName
lambdaFunc.functionArn
securityGroup.groupArn
```

```
bucket.bucket_name
lambda_func.function_arn
security_group_arn
```
Java AWS CDK 繫結使用屬性的 getter 方法。  

```
bucket.getBucketName()
lambdaFunc.getFunctionArn()
securityGroup.getGroupArn()
```

```
bucket.BucketName
lambdaFunc.FunctionArn
securityGroup.GroupArn
```

```
bucket.BucketName()
fn.FunctionArn()
```

下列範例示範如何將產生的儲存貯體名稱傳遞至 AWS Lambda 函數。

**Example**  

```
const bucket = new s3.Bucket(this, 'Bucket');

new lambda.Function(this, 'MyLambda', {
  // ...
  environment: {
    BUCKET_NAME: bucket.bucketName,
  },
});
```

```
const bucket = new s3.Bucket(this, 'Bucket');

new lambda.Function(this, 'MyLambda', {
  // ...
  environment: {
    BUCKET_NAME: bucket.bucketName
  }
});
```

```
bucket = s3.Bucket(self, "Bucket")

lambda.Function(self, "MyLambda", environment=dict(BUCKET_NAME=bucket.bucket_name))
```

```
final Bucket bucket = new Bucket(this, "Bucket");

Function.Builder.create(this, "MyLambda")
        .environment(java.util.Map.of(    // Java 9 or later
                "BUCKET_NAME", bucket.getBucketName()))
        .build();
```

```
var bucket = new Bucket(this, "Bucket");

new Function(this, "MyLambda", new FunctionProps
{
    Environment = new Dictionary<string, string>
    {
        ["BUCKET_NAME"] = bucket.BucketName
    }
});
```

```
bucket := s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{})
lambda.NewFunction(this, jsii.String("MyLambda"), &lambda.FunctionProps{
  Environment: &map[string]*string{"BUCKET_NAME": bucket.BucketName()},
})
```

## 在資源之間授予許可
<a name="resources-grants"></a>

更高層級的建構透過提供簡單的意圖型 APIs 來表達許可要求，使最低權限許可成為可實現。例如，許多建構提供授予方法，您可以用來授予實體 （例如 IAM 角色或使用者） 使用 資源的許可，而不必手動建立 IAM 許可陳述式。

授予方法可透過授予類別取得 （例如 `BucketGrants` Amazon S3 儲存貯體的 )。這些類別適用於 L1 和 L2 建構。L2 建構模組為了方便起見而公開`grants`屬性，但您也可以直接從 L1 建構模組建立授與類別。您可以結合 Grants 類別與 [Mixins](mixins.md)，在 L1 建構體上獲得L2-like 的便利。

下列範例會建立許可，以允許 Lambda 函數的執行角色讀取和寫入物件至特定的 Amazon S3 儲存貯體。如果 Amazon S3 儲存貯體使用 AWS KMS 金鑰加密，此方法也會將許可授予 Lambda 函數的執行角色，以使用金鑰解密。

**Example**  

```
if (bucket.grants.readWrite(func).success) {
  // ...
}
```

```
if ( bucket.grants.readWrite(func).success) {
  // ...
}
```

```
if bucket.grants.read_write(func).success:
    # ...
```

```
if (bucket.getGrants().readWrite(func).getSuccess()) {
    // ...
}
```

```
if (bucket.Grants.ReadWrite(func).Success)
{
    // ...
}
```

```
if *bucket.Grants().ReadWrite(function, nil).Success() {
  // ...
}
```

授予方法會傳回 `iam.Grant` 物件。使用 `Grant` 物件的 `success` 屬性來判斷授權是否已有效套用 （例如，它可能尚未套用到[外部資源](#resources-referencing))。您也可以使用 `Grant` 物件的 `assertSuccess`(Python：`assert_success`) 方法，強制執行已成功套用授予。

如果特定授予方法不適用於特定使用案例，您可以使用一般授予方法定義具有指定動作清單的新授予。

下列範例顯示如何授予 Lambda 函數對 Amazon DynamoDB `CreateBackup`動作的存取權。

**Example**  

```
table.grants.actions(func, 'dynamodb:CreateBackup');
```

```
table.grants.actions(func, 'dynamodb:CreateBackup');
```

```
table.grants.actions(func, "dynamodb:CreateBackup")
```

```
table.getGrants().actions(func, "dynamodb:CreateBackup");
```

```
table.Grants.Actions(func, "dynamodb:CreateBackup");
```

```
table := dynamodb.NewTable(this, jsii.String("MyTable"), &dynamodb.TableProps{})
table.Grants().Actions(function, jsii.String("dynamodb:CreateBackup"))
```

許多資源，例如 Lambda 函數，都需要在執行程式碼時擔任角色。組態屬性可讓您指定 `iam.IRole`。如果未指定角色，函數會自動建立專門用於此用途的角色。然後，您可以在資源上使用授予方法，將陳述式新增至角色。

授予方法使用低階 APIs建置，以處理 IAM 政策。政策會建模為 [PolicyDocument](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyDocument.html) 物件。使用 `addToRolePolicy`方法 (Python：) 將陳述式直接新增至角色 （或建構的連接角色`add_to_role_policy`)，或使用 (Python：) 方法新增至資源的政策 `addToResourcePolicy`（例如`Bucket`政策`add_to_resource_policy`)。

## 資源指標和警示
<a name="resources-metrics"></a>

許多資源會發出 CloudWatch 指標，可用來設定監控儀表板和警示。較高層級的建構具有指標方法，可讓您存取指標，而無需查詢要使用的正確名稱。

下列範例示範如何在 Amazon SQS 佇列`ApproximateNumberOfMessagesNotVisible`的 超過 100 時定義警示。

**Example**  

```
import * as cw from '@aws-cdk/aws-cloudwatch';
import * as sqs from '@aws-cdk/aws-sqs';
import { Duration } from '@aws-cdk/core';

const queue = new sqs.Queue(this, 'MyQueue');

const metric = queue.metricApproximateNumberOfMessagesNotVisible({
  label: 'Messages Visible (Approx)',
  period: Duration.minutes(5),
  // ...
});
metric.createAlarm(this, 'TooManyMessagesAlarm', {
  comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
  threshold: 100,
  // ...
});
```

```
const cw = require('@aws-cdk/aws-cloudwatch');
const sqs = require('@aws-cdk/aws-sqs');
const { Duration } = require('@aws-cdk/core');

const queue = new sqs.Queue(this, 'MyQueue');

const metric = queue.metricApproximateNumberOfMessagesNotVisible({
  label: 'Messages Visible (Approx)',
  period: Duration.minutes(5)
  // ...
});
metric.createAlarm(this, 'TooManyMessagesAlarm', {
  comparisonOperator: cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
  threshold: 100
  // ...
});
```

```
import aws_cdk.aws_cloudwatch as cw
import aws_cdk.aws_sqs as sqs
from aws_cdk.core import Duration

queue = sqs.Queue(self, "MyQueue")
metric = queue.metric_approximate_number_of_messages_not_visible(
    label="Messages Visible (Approx)",
    period=Duration.minutes(5),
    # ...
)
metric.create_alarm(self, "TooManyMessagesAlarm",
    comparison_operator=cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
    threshold=100,
    # ...
)
```

```
import software.amazon.awscdk.core.Duration;
import software.amazon.awscdk.services.sqs.Queue;
import software.amazon.awscdk.services.cloudwatch.Metric;
import software.amazon.awscdk.services.cloudwatch.MetricOptions;
import software.amazon.awscdk.services.cloudwatch.CreateAlarmOptions;
import software.amazon.awscdk.services.cloudwatch.ComparisonOperator;

Queue queue = new Queue(this, "MyQueue");

Metric metric = queue
        .metricApproximateNumberOfMessagesNotVisible(MetricOptions.builder()
                .label("Messages Visible (Approx)")
                .period(Duration.minutes(5)).build());

metric.createAlarm(this, "TooManyMessagesAlarm", CreateAlarmOptions.builder()
                .comparisonOperator(ComparisonOperator.GREATER_THAN_THRESHOLD)
                .threshold(100)
                // ...
                .build());
```

```
using cdk = Amazon.CDK;
using cw = Amazon.CDK.AWS.CloudWatch;
using sqs = Amazon.CDK.AWS.SQS;

var queue = new sqs.Queue(this, "MyQueue");
var metric = queue.MetricApproximateNumberOfMessagesNotVisible(new cw.MetricOptions
{
    Label = "Messages Visible (Approx)",
    Period = cdk.Duration.Minutes(5),
    // ...
});
metric.CreateAlarm(this, "TooManyMessagesAlarm", new cw.CreateAlarmOptions
{
    ComparisonOperator = cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
    Threshold = 100,
    // ..
});
```

```
import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  cw "github.com/aws/aws-cdk-go/awscdk/v2/awscloudwatch"
  sqs "github.com/aws/aws-cdk-go/awscdk/v2/awssqs"
)

queue := sqs.NewQueue(this, jsii.String("MyQueue"), &sqs.QueueProps{})
metric := queue.MetricApproximateNumberOfMessagesNotVisible(&cw.MetricOptions{
  Label: jsii.String("Messages Visible (Approx)"),
  Period: awscdk.Duration_Minutes(jsii.Number(5)),
})

metric.CreateAlarm(this, jsii.String("TooManyMessagesAlarm"), &cw.CreateAlarmOptions{
  ComparisonOperator: cw.ComparisonOperator_GREATER_THAN_THRESHOLD,
  Threshold: jsii.Number(100),
})
```

如果特定指標沒有方法，您可以使用一般指標方法手動指定指標名稱。

指標也可以新增至 CloudWatch 儀表板。請參閱 [CloudWatch](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch-readme.html)。

## 網路流量
<a name="resources-traffic"></a>

在許多情況下，您必須在網路上啟用許可，應用程式才能運作，例如當運算基礎設施需要存取持久性層時。建立或接聽連線的資源會公開啟用流量流程的方法，包括設定安全群組規則或網路 ACLs。

 [IConnectable](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IConnectable.html) 資源具有`connections`屬性，其為網路流量規則組態的閘道。

您可以使用 `allow`方法，讓資料在指定的網路路徑上流動。下列範例會啟用與 Web 的 HTTPS 連線，以及來自 Amazon EC2 Auto Scaling 群組 的傳入連線`fleet2`。

**Example**  

```
import * as asg from '@aws-cdk/aws-autoscaling';
import * as ec2 from '@aws-cdk/aws-ec2';

const fleet1: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/);

// Allow surfing the (secure) web
fleet1.connections.allowTo(new ec2.Peer.anyIpv4(), new ec2.Port({ fromPort: 443, toPort: 443 }));

const fleet2: asg.AutoScalingGroup = asg.AutoScalingGroup(/*...*/);
fleet1.connections.allowFrom(fleet2, ec2.Port.AllTraffic());
```

```
const asg = require('@aws-cdk/aws-autoscaling');
const ec2 = require('@aws-cdk/aws-ec2');

const fleet1 = asg.AutoScalingGroup();

// Allow surfing the (secure) web
fleet1.connections.allowTo(new ec2.Peer.anyIpv4(), new ec2.Port({ fromPort: 443, toPort: 443 }));

const fleet2 = asg.AutoScalingGroup();
fleet1.connections.allowFrom(fleet2, ec2.Port.AllTraffic());
```

```
import aws_cdk.aws_autoscaling as asg
import aws_cdk.aws_ec2 as ec2

fleet1 = asg.AutoScalingGroup( ... )

# Allow surfing the (secure) web
fleet1.connections.allow_to(ec2.Peer.any_ipv4(),
  ec2.Port(PortProps(from_port=443, to_port=443)))

fleet2 = asg.AutoScalingGroup( ... )
fleet1.connections.allow_from(fleet2, ec2.Port.all_traffic())
```

```
import software.amazon.awscdk.services.autoscaling.AutoScalingGroup;
import software.amazon.awscdk.services.ec2.Peer;
import software.amazon.awscdk.services.ec2.Port;

AutoScalingGroup fleet1 = AutoScalingGroup.Builder.create(this, "MyFleet")
        /* ... */.build();

// Allow surfing the (secure) Web
fleet1.getConnections().allowTo(Peer.anyIpv4(),
        Port.Builder.create().fromPort(443).toPort(443).build());

AutoScalingGroup fleet2 = AutoScalingGroup.Builder.create(this, "MyFleet2")
        /* ... */.build();
fleet1.getConnections().allowFrom(fleet2, Port.allTraffic());
```

```
using cdk = Amazon.CDK;
using asg = Amazon.CDK.AWS.AutoScaling;
using ec2 = Amazon.CDK.AWS.EC2;

// Allow surfing the (secure) Web
var fleet1 = new asg.AutoScalingGroup(this, "MyFleet", new asg.AutoScalingGroupProps { /* ... */ });
fleet1.Connections.AllowTo(ec2.Peer.AnyIpv4(), new ec2.Port(new ec2.PortProps
  { FromPort = 443, ToPort = 443 }));

var fleet2 = new asg.AutoScalingGroup(this, "MyFleet2", new asg.AutoScalingGroupProps { /* ... */ });
fleet1.Connections.AllowFrom(fleet2, ec2.Port.AllTraffic());
```

```
import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  autoscaling "github.com/aws/aws-cdk-go/awscdk/v2/awsautoscaling"
  ec2 "github.com/aws/aws-cdk-go/awscdk/v2/awsec2"
)

fleet1 := autoscaling.NewAutoScalingGroup(this, jsii.String("MyFleet1"), &autoscaling.AutoScalingGroupProps{})
fleet1.Connections().AllowTo(ec2.Peer_AnyIpv4(),ec2.NewPort(&ec2.PortProps{ FromPort: jsii.Number(443), ToPort: jsii.Number(443) }),jsii.String("secure web"))

fleet2 := autoscaling.NewAutoScalingGroup(this, jsii.String("MyFleet2"), &autoscaling.AutoScalingGroupProps{})
fleet1.Connections().AllowFrom(fleet2, ec2.Port_AllTraffic(),jsii.String("all traffic"))
```

某些資源具有與其相關聯的預設連接埠。範例包括公有連接埠上負載平衡器的接聽程式，以及資料庫引擎接受 Amazon RDS 資料庫執行個體連線的連接埠。在這種情況下，您可以強制執行緊密的網路控制，而無需手動指定連接埠。若要這樣做，請使用 `allowDefaultPortFrom`和 `allowToDefaultPort`方法 (Python：`allow_default_port_from`、`allow_to_default_port`)。

下列範例顯示如何啟用來自任何 IPV4 地址的連線，以及來自 Auto Scaling 群組的連線來存取資料庫。

**Example**  

```
listener.connections.allowDefaultPortFromAnyIpv4('Allow public access');

fleet.connections.allowToDefaultPort(rdsDatabase, 'Fleet can access database');
```

```
listener.connections.allowDefaultPortFromAnyIpv4('Allow public access');

fleet.connections.allowToDefaultPort(rdsDatabase, 'Fleet can access database');
```

```
listener.connections.allow_default_port_from_any_ipv4("Allow public access")

fleet.connections.allow_to_default_port(rds_database, "Fleet can access database")
```

```
listener.getConnections().allowDefaultPortFromAnyIpv4("Allow public access");

fleet.getConnections().AllowToDefaultPort(rdsDatabase, "Fleet can access database");
```

```
listener.Connections.AllowDefaultPortFromAnyIpv4("Allow public access");

fleet.Connections.AllowToDefaultPort(rdsDatabase, "Fleet can access database");
```

```
listener.Connections().AllowDefaultPortFromAnyIpv4(jsii.String("Allow public Access"))
fleet.Connections().AllowToDefaultPort(rdsDatabase, jsii.String("Fleet can access database"))
```

## 事件處理
<a name="resources-events"></a>

有些資源可以做為事件來源。使用 `addEventNotification`方法 (Python：`add_event_notification`) 將事件目標註冊至 資源發出的特定事件類型。此外，`addXxxNotification`方法提供簡單的方式來註冊常見事件類型的處理常式。

下列範例顯示如何在將物件新增至 Amazon S3 儲存貯體時觸發 Lambda 函數。

**Example**  

```
import * as s3nots from '@aws-cdk/aws-s3-notifications';

const handler = new lambda.Function(this, 'Handler', { /*…*/ });
const bucket = new s3.Bucket(this, 'Bucket');
bucket.addObjectCreatedNotification(new s3nots.LambdaDestination(handler));
```

```
const s3nots = require('@aws-cdk/aws-s3-notifications');

const handler = new lambda.Function(this, 'Handler', { /*…*/ });
const bucket = new s3.Bucket(this, 'Bucket');
bucket.addObjectCreatedNotification(new s3nots.LambdaDestination(handler));
```

```
import aws_cdk.aws_s3_notifications as s3_nots

handler = lambda_.Function(self, "Handler", ...)
bucket = s3.Bucket(self, "Bucket")
bucket.add_object_created_notification(s3_nots.LambdaDestination(handler))
```

```
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.s3.notifications.LambdaDestination;

Function handler = Function.Builder.create(this, "Handler")/* ... */.build();
Bucket bucket = new Bucket(this, "Bucket");
bucket.addObjectCreatedNotification(new LambdaDestination(handler));
```

```
using lambda = Amazon.CDK.AWS.Lambda;
using s3 = Amazon.CDK.AWS.S3;
using s3Nots = Amazon.CDK.AWS.S3.Notifications;

var handler = new lambda.Function(this, "Handler", new lambda.FunctionProps { .. });
var bucket = new s3.Bucket(this, "Bucket");
bucket.AddObjectCreatedNotification(new s3Nots.LambdaDestination(handler));
```

```
import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3"
  s3nots "github.com/aws/aws-cdk-go/awscdk/v2/awss3notifications"
)

handler := lambda.NewFunction(this, jsii.String("MyFunction"), &lambda.FunctionProps{})
bucket := s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{})
bucket.AddObjectCreatedNotification(s3nots.NewLambdaDestination(handler), nil)
```

## 移除政策
<a name="resources-removal"></a>

維護持久性資料的資源，例如資料庫、Amazon S3 儲存貯體和 Amazon ECR 登錄檔，具有*移除政策*。移除政策指出是否要在包含持久性物件的 AWS CDK 堆疊銷毀時刪除持久性物件。指定移除政策的值可透過 AWS CDK `RemovalPolicy` `core`模組中的列舉取得。

**注意**  
除了持續存放資料的資源之外`removalPolicy`，也可能會有用於不同用途的 。例如，Lambda 函數版本使用 `removalPolicy` 屬性來判斷在部署新版本時是否保留指定版本。相較於 Amazon S3 儲存貯體或 DynamoDB 資料表上的移除政策，這些具有不同的意義和預設值。


| Value | 意義 | 
| --- | --- | 
|   `RemovalPolicy.RETAIN`   |  在銷毀堆疊時保留資源的內容 （預設）。資源會從堆疊中孤立，且必須手動刪除。如果您在資源仍然存在時嘗試重新部署堆疊，由於名稱衝突，您將會收到錯誤訊息。  | 
|   `RemovalPolicy.DESTROY`   |  資源將與堆疊一起銷毀。  | 

 AWS CloudFormation 不會移除包含檔案的 Amazon S3 儲存貯體，即使其移除政策設定為 `DESTROY`。嘗試這麼做是 AWS CloudFormation 錯誤。若要讓 AWS CDK 在銷毀儲存貯體之前刪除所有檔案，請將儲存貯體的 `autoDeleteObjects` 屬性設定為 `true`。

以下是使用 建立 Amazon S3 儲存貯體`RemovalPolicy``DESTROY`並`autoDeleteOjbects`設定為 的範例`true`。

**Example**  

```
import * as cdk from '@aws-cdk/core';
import * as s3 from '@aws-cdk/aws-s3';

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

    const bucket = new s3.Bucket(this, 'Bucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true
    });
  }
}
```

```
const cdk = require('@aws-cdk/core');
const s3 = require('@aws-cdk/aws-s3');

class CdkTestStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    const bucket = new s3.Bucket(this, 'Bucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true
    });
  }
}

module.exports = { CdkTestStack }
```

```
import aws_cdk.core as cdk
import aws_cdk.aws_s3 as s3

class CdkTestStack(cdk.stack):
    def __init__(self, scope: cdk.Construct, id: str, **kwargs):
        super().__init__(scope, id, **kwargs)

        bucket = s3.Bucket(self, "Bucket",
            removal_policy=cdk.RemovalPolicy.DESTROY,
            auto_delete_objects=True)
```

```
software.amazon.awscdk.core.*;
import software.amazon.awscdk.services.s3.*;

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

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

        Bucket.Builder.create(this, "Bucket")
                .removalPolicy(RemovalPolicy.DESTROY)
                .autoDeleteObjects(true).build();
    }
}
```

```
using Amazon.CDK;
using Amazon.CDK.AWS.S3;

public CdkTestStack(Construct scope, string id, IStackProps props) : base(scope, id, props)
{
    new Bucket(this, "Bucket", new BucketProps {
        RemovalPolicy = RemovalPolicy.DESTROY,
        AutoDeleteObjects = true
    });
}
```

```
import (
  "github.com/aws/aws-cdk-go/awscdk/v2"
  "github.com/aws/jsii-runtime-go"
  s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3"
)

s3.NewBucket(this, jsii.String("Bucket"), &s3.BucketProps{
  RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
  AutoDeleteObjects: jsii.Bool(true),
})
```

您也可以透過 `applyRemovalPolicy()`方法，將移除政策直接套用至 underlying AWS CloudFormation 資源。此方法適用於在其 L2 資源的道具中沒有`removalPolicy`屬性的某些具狀態資源。範例如下：
+  AWS CloudFormation 堆疊
+ Amazon Cognito 使用者集區
+ Amazon DocumentDB 資料庫執行個體
+ Amazon EC2 磁碟區
+ Amazon OpenSearch Service 域
+ Amazon FSx 檔案系統
+ Amazon SQS 佇列

**Example**  

```
const resource = bucket.node.findChild('Resource') as cdk.CfnResource;
resource.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
```

```
const resource = bucket.node.findChild('Resource');
resource.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
```

```
resource = bucket.node.find_child('Resource')
resource.apply_removal_policy(cdk.RemovalPolicy.DESTROY);
```

```
CfnResource resource = (CfnResource)bucket.node.findChild("Resource");
resource.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
```

```
var resource = (CfnResource)bucket.node.findChild('Resource');
resource.ApplyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
```

**注意**  
 AWS CDK 的 會`RemovalPolicy`轉譯為 AWS CloudFormation 的 `DeletionPolicy`。不過， AWS CDK 中的預設值是保留資料，這與 AWS CloudFormation 預設值相反。