Ini adalah Panduan Pengembang AWS CDK v2. CDK v1 yang lebih lama memasuki pemeliharaan pada 1 Juni 2022 dan mengakhiri dukungan pada 1 Juni 2023.
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tag dan AWS CDK
Tag adalah elemen nilai kunci informasi yang dapat Anda tambahkan ke konstruksi di aplikasi CDK Anda. AWS Tag yang diterapkan pada konstruksi tertentu juga berlaku untuk semua anak yang dapat diberi tag. Tag disertakan dalam AWS CloudFormation templat yang disintesis dari aplikasi Anda dan diterapkan ke AWS sumber daya yang diterapkan. Anda dapat menggunakan tag untuk mengidentifikasi dan mengkategorikan sumber daya untuk tujuan berikut:
+ Menyederhanakan manajemen
+ Alokasi biaya
+ Kontrol akses
+ Tujuan lain yang Anda rancang
**Tip**
Untuk informasi selengkapnya tentang cara menggunakan tag dengan AWS sumber daya, lihat [Praktik Terbaik untuk Menandai AWS Sumber Daya](https://docs.aws.amazon.com/whitepapers/latest/tagging-best-practices/tagging-best-practices.html) di * AWS Whitepaper*.
## Menggunakan tanda
Kelas [Tags](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Tags.html) mencakup metode statis`of()`, di mana Anda dapat menambahkan tag ke, atau menghapus tag dari, konstruksi yang ditentukan.
+ [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Tags.html#addkey-value-props](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Tags.html#addkey-value-props)menerapkan tag baru ke konstruksi yang diberikan dan semua anak-anaknya.
+ [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Tags.html#removekey-props](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Tags.html#removekey-props)menghapus tag dari konstruksi yang diberikan dan salah satu turunannya, termasuk tag yang mungkin diterapkan oleh konstruksi anak pada dirinya sendiri.
**catatan**
Penandaan diimplementasikan menggunakan [Aspects dan AWS CDK](aspects.md). Aspek adalah cara untuk menerapkan operasi (seperti penandaan) ke semua konstruksi dalam lingkup tertentu.
Contoh berikut menerapkan **kunci** tag dengan nilai **nilai** untuk konstruksi.
**Example**
```
Tags.of(myConstruct).add('key', 'value');
```
```
Tags.of(myConstruct).add('key', 'value');
```
```
Tags.of(my_construct).add("key", "value")
```
```
Tags.of(myConstruct).add("key", "value");
```
```
Tags.Of(myConstruct).Add("key", "value");
```
```
awscdk.Tags_Of(myConstruct).Add(jsii.String("key"), jsii.String("value"), &awscdk.TagProps{})
```
Contoh berikut menghapus **kunci** tag dari konstruksi.
**Example**
```
Tags.of(myConstruct).remove('key');
```
```
Tags.of(myConstruct).remove('key');
```
```
Tags.of(my_construct).remove("key")
```
```
Tags.of(myConstruct).remove("key");
```
```
Tags.Of(myConstruct).Remove("key");
```
```
awscdk.Tags_Of(myConstruct).Remove(jsii.String("key"), &awscdk.TagProps{})
```
Jika Anda menggunakan `Stage` konstruksi, terapkan tag di `Stage` tingkat atau di bawah. Tag tidak diterapkan melintasi `Stage` batas.
## Menandai prioritas
AWS CDK menerapkan dan menghapus tag secara rekursif. Jika ada konflik, operasi penandaan dengan prioritas tertinggi menang. (Prioritas ditetapkan menggunakan `priority` properti opsional.) Jika prioritas dua operasi sama, operasi penandaan yang paling dekat dengan bagian bawah pohon konstruksi menang. Secara default, menerapkan tag memiliki prioritas 100 (kecuali untuk tag yang ditambahkan langsung ke AWS CloudFormation sumber daya, yang memiliki prioritas 50). Prioritas default untuk menghapus tag adalah 200.
Berikut ini menerapkan tag dengan prioritas 300 untuk konstruksi.
**Example**
```
Tags.of(myConstruct).add('key', 'value', {
priority: 300
});
```
```
Tags.of(myConstruct).add('key', 'value', {
priority: 300
});
```
```
Tags.of(my_construct).add("key", "value", priority=300)
```
```
Tags.of(myConstruct).add("key", "value", TagProps.builder()
.priority(300).build());
```
```
Tags.Of(myConstruct).Add("key", "value", new TagProps { Priority = 300 });
```
```
awscdk.Tags_Of(myConstruct).Add(jsii.String("key"), jsii.String("value"), &awscdk.TagProps{
Priority: jsii.Number(300),
})
```
## Properti opsional
Tag mendukung [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.TagProps.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.TagProps.html)yang menyempurnakan cara tag diterapkan, atau dihapus dari, sumber daya. Semua properti adalah opsional.
`applyToLaunchedInstances`(Python:) `apply_to_launched_instances`
Tersedia untuk add () saja. Secara default, tag diterapkan ke instance yang diluncurkan di grup Auto Scaling. Setel properti ini ke **false** untuk mengabaikan instance yang diluncurkan dalam grup Auto Scaling.
`includeResourceTypes`/`excludeResourceTypes`(Python:`include_resource_types`/) `exclude_resource_types`
Gunakan ini untuk memanipulasi tag hanya pada subset sumber daya, berdasarkan jenis AWS CloudFormation sumber daya. Secara default, operasi diterapkan ke semua sumber daya di subpohon konstruksi, tetapi ini dapat diubah dengan memasukkan atau mengecualikan jenis sumber daya tertentu. Kecualikan lebih diutamakan daripada include, jika keduanya ditentukan.
`priority`
Gunakan ini untuk menetapkan prioritas operasi ini sehubungan dengan operasi lain `Tags.add()` dan `Tags.remove()` operasi. Nilai yang lebih tinggi lebih diutamakan daripada nilai yang lebih rendah. Defaultnya adalah 100 untuk operasi tambah (50 untuk tag diterapkan langsung ke AWS CloudFormation sumber daya) dan 200 untuk menghapus operasi.
Contoh berikut menerapkan tag **tag** dengan nilai **nilai** dan prioritas **100** untuk sumber daya tipe ** AWS: :Xxx: :Yyy** dalam konstruksi. Itu tidak menerapkan tag ke instance yang diluncurkan di grup EC2 Auto Scaling Amazon atau ke sumber daya ** AWS tipe: :Xxx: :Zzz**. (Ini adalah placeholder untuk dua jenis AWS CloudFormation sumber daya yang sewenang-wenang tetapi berbeda.)
**Example**
```
Tags.of(myConstruct).add('tagname', 'value', {
applyToLaunchedInstances: false,
includeResourceTypes: ['AWS::Xxx::Yyy'],
excludeResourceTypes: ['AWS::Xxx::Zzz'],
priority: 100,
});
```
```
Tags.of(myConstruct).add('tagname', 'value', {
applyToLaunchedInstances: false,
includeResourceTypes: ['AWS::Xxx::Yyy'],
excludeResourceTypes: ['AWS::Xxx::Zzz'],
priority: 100
});
```
```
Tags.of(my_construct).add("tagname", "value",
apply_to_launched_instances=False,
include_resource_types=["AWS::Xxx::Yyy"],
exclude_resource_types=["AWS::Xxx::Zzz"],
priority=100)
```
```
Tags.of(myConstruct).add("tagname", "value", TagProps.builder()
.applyToLaunchedInstances(false)
.includeResourceTypes(Arrays.asList("AWS::Xxx::Yyy"))
.excludeResourceTypes(Arrays.asList("AWS::Xxx::Zzz"))
.priority(100).build());
```
```
Tags.Of(myConstruct).Add("tagname", "value", new TagProps
{
ApplyToLaunchedInstances = false,
IncludeResourceTypes = ["AWS::Xxx::Yyy"],
ExcludeResourceTypes = ["AWS::Xxx::Zzz"],
Priority = 100
});
```
```
awscdk.Tags_Of(myConstruct).Add(jsii.String("tagname"), jsii.String("value"), &awscdk.TagProps{
ApplyToLaunchedInstances: jsii.Bool(false),
IncludeResourceTypes: &[]*string{jsii.String("AWS::Xxx:Yyy")},
ExcludeResourceTypes: &[]*string{jsii.String("AWS::Xxx:Zzz")},
Priority: jsii.Number(100),
})
```
**Contoh berikut menghapus tag **tag** dengan prioritas **200** dari sumber daya tipe ** AWS: :Xxx: :Yyy** dalam konstruksi, tetapi tidak dari sumber daya tipe: :Xxx: :Zzz. AWS**
**Example**
```
Tags.of(myConstruct).remove('tagname', {
includeResourceTypes: ['AWS::Xxx::Yyy'],
excludeResourceTypes: ['AWS::Xxx::Zzz'],
priority: 200,
});
```
```
Tags.of(myConstruct).remove('tagname', {
includeResourceTypes: ['AWS::Xxx::Yyy'],
excludeResourceTypes: ['AWS::Xxx::Zzz'],
priority: 200
});
```
```
Tags.of(my_construct).remove("tagname",
include_resource_types=["AWS::Xxx::Yyy"],
exclude_resource_types=["AWS::Xxx::Zzz"],
priority=200,)
```
```
Tags.of((myConstruct).remove("tagname", TagProps.builder()
.includeResourceTypes(Arrays.asList("AWS::Xxx::Yyy"))
.excludeResourceTypes(Arrays.asList("AWS::Xxx::Zzz"))
.priority(100).build());
)
```
```
Tags.Of(myConstruct).Remove("tagname", new TagProps
{
IncludeResourceTypes = ["AWS::Xxx::Yyy"],
ExcludeResourceTypes = ["AWS::Xxx::Zzz"],
Priority = 100
});
```
```
awscdk.Tags_Of(myConstruct).Remove(jsii.String("tagname"), &awscdk.TagProps{
IncludeResourceTypes: &[]*string{jsii.String("AWS::Xxx:Yyy")},
ExcludeResourceTypes: &[]*string{jsii.String("AWS::Xxx:Zzz")},
Priority: jsii.Number(200),
})
```
## Contoh
Contoh berikut menambahkan kunci tag **StackType**dengan nilai **TheBest**ke sumber daya apa pun yang dibuat dalam `Stack` nama`MarketingSystem`. Kemudian menghapusnya lagi dari semua sumber daya kecuali subnet Amazon EC2 VPC. Hasilnya adalah hanya subnet yang memiliki tag yang diterapkan.
**Example**
```
import { App, Stack, Tags } from 'aws-cdk-lib';
const app = new App();
const theBestStack = new Stack(app, 'MarketingSystem');
// Add a tag to all constructs in the stack
Tags.of(theBestStack).add('StackType', 'TheBest');
// Remove the tag from all resources except subnet resources
Tags.of(theBestStack).remove('StackType', {
excludeResourceTypes: ['AWS::EC2::Subnet']
});
```
```
const { App, Stack, Tags } = require('aws-cdk-lib');
const app = new App();
const theBestStack = new Stack(app, 'MarketingSystem');
// Add a tag to all constructs in the stack
Tags.of(theBestStack).add('StackType', 'TheBest');
// Remove the tag from all resources except subnet resources
Tags.of(theBestStack).remove('StackType', {
excludeResourceTypes: ['AWS::EC2::Subnet']
});
```
```
from aws_cdk import App, Stack, Tags
app = App();
the_best_stack = Stack(app, 'MarketingSystem')
# Add a tag to all constructs in the stack
Tags.of(the_best_stack).add("StackType", "TheBest")
# Remove the tag from all resources except subnet resources
Tags.of(the_best_stack).remove("StackType",
exclude_resource_types=["AWS::EC2::Subnet"])
```
```
import software.amazon.awscdk.App;
import software.amazon.awscdk.Tags;
// Add a tag to all constructs in the stack
Tags.of(theBestStack).add("StackType", "TheBest");
// Remove the tag from all resources except subnet resources
Tags.of(theBestStack).remove("StackType", TagProps.builder()
.excludeResourceTypes(Arrays.asList("AWS::EC2::Subnet"))
.build());
```
```
using Amazon.CDK;
var app = new App();
var theBestStack = new Stack(app, 'MarketingSystem');
// Add a tag to all constructs in the stack
Tags.Of(theBestStack).Add("StackType", "TheBest");
// Remove the tag from all resources except subnet resources
Tags.Of(theBestStack).Remove("StackType", new TagProps
{
ExcludeResourceTypes = ["AWS::EC2::Subnet"]
});
```
```
import "github.com/aws/aws-cdk-go/awscdk/v2"
app := awscdk.NewApp(nil)
theBestStack := awscdk.NewStack(app, jsii.String("MarketingSystem"), &awscdk.StackProps{})
// Add a tag to all constructs in the stack
awscdk.Tags_Of(theBestStack).Add(jsii.String("StackType"), jsii.String("TheBest"), &awscdk.TagProps{})
// Remove the tag from all resources except subnet resources
awscdk.Tags_Of(theBestStack).Add(jsii.String("StackType"), jsii.String("TheBest"), &awscdk.TagProps{
ExcludeResourceTypes: &[]*string{jsii.String("AWS::EC2::Subnet")},
})
```
Kode berikut mencapai hasil yang sama. Pertimbangkan pendekatan mana (inklusi atau pengecualian) yang membuat maksud Anda lebih jelas.
**Example**
```
Tags.of(theBestStack).add('StackType', 'TheBest',
{ includeResourceTypes: ['AWS::EC2::Subnet']});
```
```
Tags.of(theBestStack).add('StackType', 'TheBest',
{ includeResourceTypes: ['AWS::EC2::Subnet']});
```
```
Tags.of(the_best_stack).add("StackType", "TheBest",
include_resource_types=["AWS::EC2::Subnet"])
```
```
Tags.of(theBestStack).add("StackType", "TheBest", TagProps.builder()
.includeResourceTypes(Arrays.asList("AWS::EC2::Subnet"))
.build());
```
```
Tags.Of(theBestStack).Add("StackType", "TheBest", new TagProps {
IncludeResourceTypes = ["AWS::EC2::Subnet"]
});
```
```
awscdk.Tags_Of(theBestStack).Add(jsii.String("StackType"), jsii.String("TheBest"), &awscdk.TagProps{
IncludeResourceTypes: &[]*string{jsii.String("AWS::EC2::Subnet")},
})
```
## Menandai konstruksi tunggal
`Tags.of(scope).add(key, value)`adalah cara standar untuk menambahkan tag ke konstruksi di AWS CDK. Perilaku berjalan di pohon, yang secara rekursif menandai semua sumber daya yang dapat diberi tag di bawah lingkup yang diberikan, hampir selalu seperti yang Anda inginkan. Namun, terkadang, Anda perlu menandai konstruksi (atau konstruksi) tertentu yang sewenang-wenang.
Salah satu kasus tersebut melibatkan penerapan tag yang nilainya berasal dari beberapa properti konstruksi yang diberi tag. Pendekatan penandaan standar secara rekursif menerapkan kunci dan nilai yang sama ke semua sumber daya yang cocok dalam ruang lingkup. Namun, di sini nilainya bisa berbeda untuk setiap konstruksi yang ditandai.
Tag diimplementasikan menggunakan [aspek](aspects.md), dan CDK memanggil `visit()` metode tag untuk setiap konstruksi di bawah lingkup yang Anda tentukan menggunakan. `Tags.of(scope)` Kita dapat memanggil `Tag.visit()` langsung untuk menerapkan tag ke konstruksi tunggal.
**Example**
```
new cdk.Tag(key, value).visit(scope);
```
```
new cdk.Tag(key, value).visit(scope);
```
```
cdk.Tag(key, value).visit(scope)
```
```
Tag.Builder.create(key, value).build().visit(scope);
```
```
new Tag(key, value).Visit(scope);
```
```
awscdk.NewTag(key, value, &awscdk.TagProps{}).Visit(scope)
```
Anda dapat menandai semua konstruksi di bawah lingkup tetapi membiarkan nilai tag berasal dari properti setiap konstruksi. Untuk melakukannya, tulis aspek dan terapkan tag dalam `visit()` metode aspek seperti yang ditunjukkan pada contoh sebelumnya. Kemudian, tambahkan aspek ke lingkup yang diinginkan menggunakan`Aspects.of(scope).add(aspect)`.
Contoh berikut menerapkan tag untuk setiap sumber daya dalam tumpukan yang berisi jalur sumber daya.
**Example**
```
class PathTagger implements cdk.IAspect {
visit(node: IConstruct) {
new cdk.Tag("aws-cdk-path", node.node.path).visit(node);
}
}
stack = new MyStack(app);
cdk.Aspects.of(stack).add(new PathTagger())
```
```
class PathTagger {
visit(node) {
new cdk.Tag("aws-cdk-path", node.node.path).visit(node);
}
}
stack = new MyStack(app);
cdk.Aspects.of(stack).add(new PathTagger())
```
```
@jsii.implements(cdk.IAspect)
class PathTagger:
def visit(self, node: IConstruct):
cdk.Tag("aws-cdk-path", node.node.path).visit(node)
stack = MyStack(app)
cdk.Aspects.of(stack).add(PathTagger())
```
```
final class PathTagger implements IAspect {
public void visit(IConstruct node) {
Tag.Builder.create("aws-cdk-path", node.getNode().getPath()).build().visit(node);
}
}
stack stack = new MyStack(app);
Aspects.of(stack).add(new PathTagger());
```
```
public class PathTagger : IAspect
{
public void Visit(IConstruct node)
{
new Tag("aws-cdk-path", node.Node.Path).Visit(node);
}
}
var stack = new MyStack(app);
Aspects.Of(stack).Add(new PathTagger);
```
**Tip**
Logika penandaan bersyarat, termasuk prioritas, jenis sumber daya, dan sebagainya, dibangun ke dalam kelas. `Tag` Anda dapat menggunakan fitur ini saat menerapkan tag ke sumber daya arbitrer; tag tidak diterapkan jika kondisi tidak terpenuhi. Selain itu, `Tag` kelas hanya menandai sumber daya yang dapat diberi tag, jadi Anda tidak perlu menguji apakah konstruksi dapat diberi tag sebelum menerapkan tag.