Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 wurde am 1. Juni 2022 gewartet und der Support wurde am 1. Juni 2023 eingestellt.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Ressourcen und das AWS CDK
*Ressourcen* sind das, was Sie für die Nutzung von AWS Diensten in Ihren Anwendungen konfigurieren. Ressourcen sind ein Feature von AWS CloudFormation. Indem Sie Ressourcen und ihre Eigenschaften in einer AWS CloudFormation Vorlage konfigurieren, können Sie diese bereitstellen, AWS CloudFormation um Ihre Ressourcen bereitzustellen. Mit dem AWS Cloud Development Kit (AWS CDK) können Sie Ressourcen mithilfe von Konstrukten konfigurieren. Anschließend stellen Sie Ihre CDK-App bereit. Dazu müssen Sie eine AWS CloudFormation Vorlage synthetisieren und diese bereitstellen, AWS CloudFormation um Ihre Ressourcen bereitzustellen.
## Konfiguration von Ressourcen mithilfe von Konstrukten
Wie in [AWS CDK Constructs](constructs.md) beschrieben, bietet das AWS CDK eine umfangreiche Klassenbibliothek mit Konstrukten, sogenannten *Konstrukten*, die alle Ressourcen repräsentieren. AWS
Um eine Instanz einer Ressource mit dem entsprechenden Konstrukt zu erstellen, übergeben Sie den Gültigkeitsbereich als erstes Argument, die logische ID des Konstrukts und eine Reihe von Konfigurationseigenschaften (Requisiten). So erstellen Sie beispielsweise eine Amazon SQS SQS-Warteschlange mit AWS KMS-Verschlüsselung mithilfe des [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)Konstrukts aus der AWS Construct-Bibliothek.
**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,
})
```
Einige Konfigurationsrequisiten sind optional und haben in vielen Fällen Standardwerte. In einigen Fällen sind alle Requisiten optional, und das letzte Argument kann vollständig weggelassen werden.
### Ressourcenattribute
Die meisten Ressourcen in der AWS Construct-Bibliothek stellen Attribute zur Verfügung, die bei der Bereitstellung von AWS CloudFormation aufgelöst werden. Attribute werden in Form von Eigenschaften für die Ressourcenklassen mit dem Typnamen als Präfix verfügbar gemacht. Das folgende Beispiel zeigt, wie die URL einer Amazon SQS SQS-Warteschlange mithilfe der Eigenschaft `queueUrl` (Python:`queue_url`) abgerufen wird.
**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
```
Informationen darüber, wie [das AWS CDK Bereitstellungszeitattribute als Zeichenketten kodiert, finden Sie unter Tokens](tokens.md) und AWS CDK.
## Ressourcen referenzieren
Bei der Konfiguration von Ressourcen müssen Sie häufig auf Eigenschaften einer anderen Ressource verweisen. Im Folgenden sind einige Beispiele aufgeführt:
+ Eine Amazon Elastic Container Service (Amazon ECS) -Ressource benötigt einen Verweis auf den Cluster, auf dem sie ausgeführt wird.
+ Für eine CloudFront Amazon-Distribution ist ein Verweis auf den Amazon Simple Storage Service (Amazon S3) -Bucket erforderlich, der den Quellcode enthält.
Sie können auf eine der folgenden Arten auf Ressourcen verweisen:
+ Indem Sie eine in Ihrer CDK-App definierte Ressource übergeben, entweder im selben Stack oder in einem anderen
+ Indem Sie ein Proxy-Objekt übergeben, das auf eine in Ihrem AWS Konto definierte Ressource verweist und aus einer eindeutigen Kennung der Ressource (z. B. einem ARN) erstellt wurde
Wenn die Eigenschaft eines Konstrukts ein Konstrukt für eine andere Ressource darstellt, entspricht ihr Typ dem Schnittstellentyp des Konstrukts. Das Amazon ECS-Konstrukt nimmt beispielsweise eine Eigenschaft `cluster` vom Typ an`ecs.ICluster`. Ein anderes Beispiel ist das CloudFront Verteilungskonstrukt, das eine Eigenschaft `sourceBucket` (Python:`source_bucket`) vom Typ annimmt`s3.IBucket`.
Sie können jedes Ressourcenobjekt des richtigen Typs, das in derselben AWS CDK-App definiert ist, direkt übergeben. Das folgende Beispiel definiert einen Amazon ECS-Cluster und verwendet ihn dann, um einen Amazon ECS-Service zu definieren.
**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,
})
```
### Referenzieren von Ressourcen in einem anderen Stack
Sie können auf Ressourcen in einem anderen Stack verweisen, sofern sie in derselben App definiert sind und sich in derselben AWS Umgebung befinden. Das folgende Muster wird im Allgemeinen verwendet:
+ Speichern Sie einen Verweis auf das Konstrukt als Attribut des Stacks, der die Ressource erzeugt. (Um einen Verweis auf den Stack des aktuellen Konstrukts zu erhalten, verwenden Sie`Stack.of(this)`.)
+ Übergeben Sie diese Referenz als Parameter oder Eigenschaft an den Konstruktor des Stacks, der die Ressource verbraucht. Der verbrauchende Stapel übergibt ihn dann als Eigenschaft an jedes Konstrukt, das ihn benötigt.
Das folgende Beispiel definiert einen Stapel`stack1`. Dieser Stack definiert einen Amazon S3 S3-Bucket und speichert einen Verweis auf das Bucket-Konstrukt als Attribut des Stacks. Dann definiert die App einen zweiten Stack`stack2`, der bei der Instanziierung einen Bucket akzeptiert. `stack2`könnte zum Beispiel eine AWS Glue-Tabelle definieren, die den Bucket für die Datenspeicherung verwendet.
**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});
```
Wenn das AWS CDK feststellt, dass sich die Ressource in derselben Umgebung, aber in einem anderen Stapel befindet, synthetisiert es automatisch AWS CloudFormation [Exporte](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-exports.html) im produzierenden Stapel und einen [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)im verbrauchenden Stapel, um diese Informationen von einem Stapel auf den anderen zu übertragen.
#### Behebung von Deadlocks bei Abhängigkeiten
Wenn Sie auf eine Ressource von einem Stapel in einem anderen Stapel verweisen, entsteht eine Abhängigkeit zwischen den beiden Stacks. Dadurch wird sichergestellt, dass sie in der richtigen Reihenfolge bereitgestellt werden. Nachdem die Stacks bereitgestellt wurden, ist diese Abhängigkeit konkret. Danach kann das Entfernen der Nutzung der gemeinsam genutzten Ressource aus dem verbrauchenden Stack zu einem unerwarteten Bereitstellungsfehler führen. Dies passiert, wenn zwischen den beiden Stacks eine weitere Abhängigkeit besteht, die eine Bereitstellung in derselben Reihenfolge erzwingt. Es kann auch ohne Abhängigkeit geschehen, wenn der produzierende Stack einfach vom CDK Toolkit so ausgewählt wird, dass er zuerst bereitgestellt wird. Der AWS CloudFormation Export wird aus dem produzierenden Stack entfernt, weil er nicht mehr benötigt wird. Die exportierte Ressource wird jedoch weiterhin im verbrauchenden Stack verwendet, da ihr Update noch nicht bereitgestellt wurde. Daher schlägt die Bereitstellung des Producer-Stacks fehl.
Um diesen Deadlock zu überwinden, entfernen Sie die Nutzung der gemeinsam genutzten Ressource aus dem verbrauchenden Stack. (Dadurch wird der automatische Export aus dem produzierenden Stack entfernt.) Als Nächstes fügen Sie denselben Export manuell zum Produktionsstapel hinzu und verwenden dabei genau dieselbe logische ID wie der automatisch generierte Export. Entfernen Sie die Nutzung der gemeinsam genutzten Ressource im verbrauchenden Stack und stellen Sie beide Stapel bereit. Entfernen Sie dann den manuellen Export (und die gemeinsam genutzte Ressource, falls sie nicht mehr benötigt wird) und stellen Sie beide Stapel erneut bereit. Die [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)Methode des Stacks ist eine bequeme Möglichkeit, den manuellen Export für diesen Zweck zu erstellen. (Sehen Sie sich das Beispiel in der verlinkten Methodenreferenz an.)
### Verweisen auf Ressourcen in Ihrem Konto AWS
Angenommen, Sie möchten eine Ressource verwenden, die bereits in Ihrem AWS Konto in Ihrer AWS CDK-App verfügbar ist. Dies kann eine Ressource sein, die über die Konsole, ein AWS SDK, direkt mit AWS CloudFormation oder in einer anderen AWS CDK-Anwendung definiert wurde. Sie können den ARN der Ressource (oder ein anderes identifizierendes Attribut oder eine Gruppe von Attributen) in ein Proxy-Objekt umwandeln. Das Proxy-Objekt dient als Referenz auf die Ressource, indem es eine statische Factory-Methode für die Klasse der Ressource aufruft.
Wenn Sie einen solchen Proxy erstellen, wird die externe Ressource **nicht** Teil Ihrer AWS CDK-App. Daher wirken sich Änderungen, die Sie am Proxy in Ihrer AWS CDK-App vornehmen, nicht auf die bereitgestellte Ressource aus. Der Proxy kann jedoch an jede AWS CDK-Methode übergeben werden, die eine Ressource dieses Typs benötigt.
Das folgende Beispiel zeigt, wie Sie auf einen Bucket verweisen, der auf einem vorhandenen Bucket mit dem ARN basiert`arn:aws:s3:::amzn-s3-demo-bucket1`, und auf eine Amazon Virtual Private Cloud, die auf einer vorhandenen VPC mit einer bestimmten ID basiert.
**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"),
})
```
Schauen wir uns die [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)Methode genauer an. Da das `ec2.Vpc` Konstrukt komplex ist, gibt es viele Möglichkeiten, die VPC auszuwählen, die mit Ihrer CDK-App verwendet werden soll. Um dieses Problem zu lösen, verfügt das VPC-Konstrukt über eine `fromLookup` statische Methode (Python:`from_lookup`), mit der Sie die gewünschte Amazon-VPC suchen können, indem Sie Ihr AWS Konto bei der Synthese abfragen.
Zur Verwendung muss das System`Vpc.fromLookup()`, das den Stack synthetisiert, Zugriff auf das Konto haben, dem die Amazon VPC gehört. Das liegt daran, dass das CDK Toolkit das Konto abfragt, um zum Zeitpunkt der Synthese die richtige Amazon VPC zu finden.
Darüber hinaus `Vpc.fromLookup()` funktioniert es nur in Stacks, die mit einem expliziten **Konto** und einer **Region** definiert sind (siehe [Umgebungen für](environments.md) das CDK). AWS Wenn das AWS CDK versucht, eine Amazon-VPC aus einem [umgebungsunabhängigen Stack](stacks.md#stack-api) zu suchen, weiß das CDK Toolkit nicht, welche Umgebung abgefragt werden muss, um die VPC zu finden.
Sie müssen ausreichende `Vpc.fromLookup()` Attribute angeben, um eine VPC in Ihrem AWS Konto eindeutig zu identifizieren. Beispielsweise kann es immer nur eine Standard-VPC geben, sodass es ausreichend ist, die VPC als Standard-VPC anzugeben.
**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),
})
```
Sie können die `tags` Eigenschaft auch verwenden, um nach einem Tag abzufragen VPCs . Sie können der Amazon VPC bei ihrer Erstellung Tags hinzufügen, indem Sie AWS CloudFormation oder das AWS CDK verwenden. Sie können Tags nach der Erstellung jederzeit mit der AWS Management Console, der AWS CLI oder einem AWS SDK bearbeiten. Zusätzlich zu allen Tags, die Sie selbst hinzufügen, fügt das AWS CDK allen VPCs erstellten Tags automatisch die folgenden Tags hinzu.
+ **Name** — Der Name der VPC.
+ **aws-cdk:subnet-name — Der Name des Subnetzes**.
+ **aws-cdk:subnet-type — Der Typ des Subnetzes: Öffentlich**, Privat oder Isoliert.
**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 { ["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")},
})
```
Die Ergebnisse von `Vpc.fromLookup()` werden in der Projektdatei zwischengespeichert. `cdk.context.json` (Siehe [Kontextwerte und AWS CDK](context.md).) Übergeben Sie diese Datei der Versionskontrolle, damit Ihre App weiterhin auf dieselbe Amazon VPC verweist. Dies funktioniert auch dann, wenn Sie später Ihre VPCs Attribute so ändern, dass eine andere VPC ausgewählt wird. Dies ist besonders wichtig, wenn Sie den Stack in einer Umgebung bereitstellen, die keinen Zugriff auf das AWS Konto hat, das die VPC definiert, z. B. [CDK](cdk-pipeline.md) Pipelines.
Sie können eine externe Ressource zwar überall verwenden, wo Sie eine ähnliche Ressource verwenden würden, die in Ihrer AWS CDK-App definiert ist, aber Sie können sie nicht ändern. Zum Beispiel bewirkt der Aufruf von `addToResourcePolicy` (Python:`add_to_resource_policy`) auf einem externen `s3.Bucket` Gerät nichts.
## Physische Namen der Ressourcen
Die logischen Namen der Ressourcen in unterscheiden AWS CloudFormation sich von den Namen der Ressourcen, die in der AWS Management Console angezeigt werden, nachdem sie von bereitgestellt wurden AWS CloudFormation. Das AWS CDK nennt diese endgültigen Namen *physische Namen*.
AWS CloudFormation Könnte beispielsweise den Amazon S3 S3-Bucket mit der logischen ID `Stack2MyBucket4DD88B4F` und dem physischen Namen erstellen`stack2MyBucket4dd88b4f-iuv1rbv9z3to`.
Mithilfe der Eigenschaft `Name` können Sie beim Erstellen von Konstrukten, die Ressourcen repräsentieren, einen physischen Namen angeben. Im folgenden Beispiel wird ein Amazon S3 S3-Bucket mit dem physischen Namen erstellt`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"),
})
```
Die Zuweisung physischer Namen zu Ressourcen hat einige Nachteile in AWS CloudFormation. Am wichtigsten ist jedoch, dass alle Änderungen an bereitgestellten Ressourcen, die einen Austausch von Ressourcen erfordern, wie z. B. Änderungen an den Eigenschaften einer Ressource, die nach der Erstellung unveränderlich sind, fehlschlagen, wenn einer Ressource ein physischer Name zugewiesen wurde. Wenn Sie in diesem Zustand landen, besteht die einzige Lösung darin, den AWS CloudFormation Stack zu löschen und dann die AWS CDK-App erneut bereitzustellen. Einzelheiten finden Sie in der [AWS CloudFormation Dokumentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html).
In einigen Fällen, z. B. beim Erstellen einer AWS CDK-App mit umgebungsübergreifenden Referenzen, sind physische Namen erforderlich, damit das AWS CDK ordnungsgemäß funktioniert. Wenn Sie sich in diesen Fällen nicht selbst die Mühe machen möchten, einen physischen Namen zu finden, können Sie ihn vom AWS CDK für Sie benennen lassen. Verwenden Sie dazu den speziellen Wert `PhysicalName.GENERATE_IF_NEEDED` wie folgt.
**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(),
})
```
## Übergeben von eindeutigen Ressourcen-Identifikatoren
Wann immer möglich, sollten Sie Ressourcen als Referenz übergeben, wie im vorherigen Abschnitt beschrieben. Es gibt jedoch Fälle, in denen Sie keine andere Wahl haben, als mit einem ihrer Attribute auf eine Ressource zu verweisen. Zu den beispielhaften Anwendungsfällen gehören die folgenden:
+ Wenn Sie AWS CloudFormation Ressourcen auf niedriger Ebene verwenden.
+ Wenn Sie Ressourcen für die Laufzeitkomponenten einer AWS CDK-Anwendung verfügbar machen müssen, z. B. wenn Sie über Umgebungsvariablen auf Lambda-Funktionen verweisen.
Diese Identifikatoren sind als Attribute für die Ressourcen verfügbar, wie z. B. die folgenden.
**Example**
```
bucket.bucketName
lambdaFunc.functionArn
securityGroup.groupArn
```
```
bucket.bucketName
lambdaFunc.functionArn
securityGroup.groupArn
```
```
bucket.bucket_name
lambda_func.function_arn
security_group_arn
```
Die AWS Java-CDK-Bindung verwendet Getter-Methoden für Attribute.
```
bucket.getBucketName()
lambdaFunc.getFunctionArn()
securityGroup.getGroupArn()
```
```
bucket.BucketName
lambdaFunc.FunctionArn
securityGroup.GroupArn
```
```
bucket.BucketName()
fn.FunctionArn()
```
Das folgende Beispiel zeigt, wie ein generierter Bucket-Name an eine AWS Lambda-Funktion übergeben wird.
**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
{
["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()},
})
```
## Erteilen von Berechtigungen zwischen Ressourcen
Konstrukte auf höherer Ebene ermöglichen die Erzielung von Berechtigungen mit den geringsten Rechten, indem sie einfache, absichtsbasierte bis ausdrückliche Berechtigungsanforderungen anbieten. APIs Viele Konstrukte bieten beispielsweise Erteilungsmethoden, mit denen Sie einer Entität (z. B. einer IAM-Rolle oder einem IAM-Benutzer) die Erlaubnis erteilen können, mit der Ressource zu arbeiten, ohne IAM-Berechtigungsanweisungen manuell erstellen zu müssen.
Grant-Methoden sind über Grants-Klassen verfügbar (z. B. `BucketGrants` für Amazon S3 S3-Buckets). Diese Klassen funktionieren sowohl mit L1- als auch mit L2-Konstrukten. L2-Konstrukte stellen der Einfachheit halber eine `grants` Eigenschaft zur Verfügung, aber Sie können eine Grants-Klasse auch direkt aus einem L1-Konstrukt erstellen. Sie können Grants-Klassen mit [Mixins](mixins.md) kombinieren, um L1-Konstrukten eine L2-ähnliche Benutzerfreundlichkeit zu bieten.
Im folgenden Beispiel werden die Berechtigungen erstellt, die es der Ausführungsrolle einer Lambda-Funktion ermöglichen, Objekte in einen bestimmten Amazon S3 S3-Bucket zu lesen und zu schreiben. Wenn der Amazon S3 S3-Bucket mit einem AWS KMS-Schlüssel verschlüsselt ist, gewährt diese Methode auch der Ausführungsrolle der Lambda-Funktion die Berechtigung, mit dem Schlüssel zu entschlüsseln.
**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() {
// ...
}
```
Die Grant-Methoden geben ein `iam.Grant` Objekt zurück. Verwenden Sie das `success` Attribut des `Grant` Objekts, um festzustellen, ob der Zuschuss tatsächlich gewährt wurde (z. B. wurde er möglicherweise nicht auf [externe Ressourcen](#resources-referencing) angewendet). Sie können auch die Methode `assertSuccess` (Python:`assert_success`) des `Grant` Objekts verwenden, um zu erzwingen, dass der Zuschuss erfolgreich beantragt wurde.
Wenn eine bestimmte Grant-Methode für den jeweiligen Anwendungsfall nicht verfügbar ist, können Sie eine generische Grant-Methode verwenden, um einen neuen Zuschuss mit einer bestimmten Liste von Aktionen zu definieren.
Das folgende Beispiel zeigt, wie einer Lambda-Funktion Zugriff auf die Amazon DynamoDB `CreateBackup` DynamoDB-Aktion gewährt wird.
**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"))
```
Für viele Ressourcen, wie z. B. Lambda-Funktionen, muss bei der Ausführung von Code eine Rolle übernommen werden. Mit einer Konfigurationseigenschaft können Sie eine `iam.IRole` angeben. Wenn keine Rolle angegeben ist, erstellt die Funktion automatisch eine Rolle speziell für diesen Zweck. Anschließend können Sie Grant-Methoden für die Ressourcen verwenden, um der Rolle Anweisungen hinzuzufügen.
Die Grant-Methoden basieren auf untergeordneten Ebenen APIs für den Umgang mit IAM-Richtlinien. Richtlinien werden als Objekte modelliert. [PolicyDocument](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_iam.PolicyDocument.html) Fügen Sie mithilfe der Methode (Python:) Anweisungen direkt zu Rollen (oder der angehängten Rolle eines Konstrukts`add_to_role_policy`) oder mit der `addToRolePolicy` Methode (Python:) zur `Bucket` Richtlinie einer Ressource `addToResourcePolicy` (z. B. einer Richtlinie`add_to_resource_policy`) hinzu.
## Metriken und Alarme für Ressourcen
Viele Ressourcen geben CloudWatch Metriken aus, mit denen Überwachungs-Dashboards und Alarme eingerichtet werden können. Konstrukte auf höherer Ebene verfügen über metrische Methoden, mit denen Sie auf die Metriken zugreifen können, ohne nach dem richtigen Namen suchen zu müssen.
Das folgende Beispiel zeigt, wie ein Alarm definiert wird, wenn `ApproximateNumberOfMessagesNotVisible` der Wert einer Amazon SQS SQS-Warteschlange 100 überschreitet.
**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),
})
```
Wenn es für eine bestimmte Metrik keine Methode gibt, können Sie die allgemeine Metrikmethode verwenden, um den Metriknamen manuell anzugeben.
Metriken können auch zu CloudWatch Dashboards hinzugefügt werden. Siehe [CloudWatch](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_cloudwatch-readme.html).
## Netzwerkdatenverkehr
In vielen Fällen müssen Sie Berechtigungen in einem Netzwerk aktivieren, damit eine Anwendung funktioniert, z. B. wenn die Recheninfrastruktur auf die Persistenzschicht zugreifen muss. Ressourcen, die Verbindungen herstellen oder darauf warten, stellen Methoden zur Verfügung, die den Datenfluss ermöglichen, einschließlich der Festlegung von Sicherheitsgruppenregeln oder Netzwerken ACLs.
[IConnectable](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.IConnectable.html)Ressourcen haben eine `connections` Eigenschaft, die das Gateway zur Konfiguration der Netzwerkverkehrsregeln darstellt.
Mithilfe von `allow` Methoden ermöglichen Sie den Datenfluss auf einem bestimmten Netzwerkpfad. Das folgende Beispiel aktiviert HTTPS-Verbindungen zum Internet und eingehende Verbindungen von der Amazon EC2 Auto Scaling Scaling-Gruppe`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"))
```
Bestimmten Ressourcen sind Standardports zugeordnet. Beispiele hierfür sind der Listener eines Load Balancers auf dem öffentlichen Port und die Ports, auf denen die Datenbank-Engine Verbindungen für Instances einer Amazon RDS-Datenbank akzeptiert. In solchen Fällen können Sie eine strenge Netzwerkkontrolle erzwingen, ohne den Port manuell angeben zu müssen. Verwenden Sie dazu die `allowToDefaultPort` Methoden `allowDefaultPortFrom` und (Python:`allow_default_port_from`,`allow_to_default_port`).
Das folgende Beispiel zeigt, wie Verbindungen von einer beliebigen IPV4 Adresse und eine Verbindung von einer Auto Scaling Scaling-Gruppe aus für den Zugriff auf eine Datenbank aktiviert werden.
**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"))
```
## Behandlung von Ereignissen
Einige Ressourcen können als Ereignisquellen dienen. Verwenden Sie die `addEventNotification` Methode (Python:`add_event_notification`), um ein Ereignisziel für einen bestimmten Ereignistyp zu registrieren, der von der Ressource ausgegeben wird. Darüber hinaus bieten `addXxxNotification` Methoden eine einfache Möglichkeit, einen Handler für gängige Ereignistypen zu registrieren.
Das folgende Beispiel zeigt, wie eine Lambda-Funktion ausgelöst wird, wenn ein Objekt zu einem Amazon S3 S3-Bucket hinzugefügt wird.
**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)
```
## Richtlinien zur Entfernung
*Für Ressourcen, die persistente Daten verwalten, wie Datenbanken, Amazon S3 S3-Buckets und Amazon ECR-Registries, gilt eine Entfernungsrichtlinie.* Die Entfernungsrichtlinie gibt an, ob persistente Objekte gelöscht werden sollen, wenn der AWS CDK-Stapel, der sie enthält, zerstört wird. Die Werte, die die Entfernungsrichtlinie angeben, sind über die `RemovalPolicy` Aufzählung im AWS `core` CDK-Modul verfügbar.
**Anmerkung**
Neben Ressourcen, die Daten dauerhaft speichern, können auch Ressourcen eine haben`removalPolicy`, die für einen anderen Zweck verwendet wird. Beispielsweise verwendet eine Lambda-Funktionsversion ein `removalPolicy` Attribut, um zu bestimmen, ob eine bestimmte Version beibehalten wird, wenn eine neue Version bereitgestellt wird. Diese haben im Vergleich zu den Entfernungsrichtlinien für einen Amazon S3 S3-Bucket oder eine DynamoDB-Tabelle unterschiedliche Bedeutungen und Standardeinstellungen.
| Wert | Bedeutung |
| --- | --- |
| `RemovalPolicy.RETAIN` | Behält den Inhalt der Ressource bei, wenn der Stapel zerstört wird (Standard). Die Ressource ist aus dem Stapel verwaist und muss manuell gelöscht werden. Wenn Sie versuchen, den Stack erneut bereitzustellen, während die Ressource noch vorhanden ist, erhalten Sie aufgrund eines Namenskonflikts eine Fehlermeldung. |
| `RemovalPolicy.DESTROY` | Die Ressource wird zusammen mit dem Stapel zerstört. |
AWS CloudFormation entfernt keine Amazon S3 S3-Buckets, die Dateien enthalten, auch wenn ihre Entfernungsrichtlinie auf `DESTROY` eingestellt ist. Der Versuch, dies zu tun, ist ein AWS CloudFormation Fehler. Damit das AWS CDK vor der Zerstörung alle Dateien aus dem Bucket löscht, setzen Sie die `autoDeleteObjects` Eigenschaft des Buckets auf`true`.
Im Folgenden finden Sie ein Beispiel für die Erstellung eines Amazon S3 S3-Buckets mit `RemovalPolicy` der Einstellung of `DESTROY` und der `autoDeleteOjbects` Einstellung auf`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),
})
```
Mithilfe der `applyRemovalPolicy()` Methode können Sie eine Entfernungsrichtlinie auch direkt auf die zugrunde liegende AWS CloudFormation Ressource anwenden. Diese Methode ist für einige statusbehaftete Ressourcen verfügbar, die keine `removalPolicy` Eigenschaft in den Requisiten ihrer L2-Ressource haben. Beispiele sind unter anderem:
+ AWS CloudFormation stapelt
+ Amazon-Cognito-Benutzerpools
+ Amazon DocumentDB DocumentDB-Datenbank-Instances
+ Amazon EC2 EC2-Volumen
+ Amazon OpenSearch Service-Domänen
+ FSx Amazon-Dateisysteme
+ Amazon-SQS-Warteschlangen
**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);
```
**Anmerkung**
Das AWS CDK's `RemovalPolicy` bedeutet übersetzt's. AWS CloudFormation `DeletionPolicy` Die Standardeinstellung in AWS CDK besteht jedoch darin, die Daten beizubehalten, was das Gegenteil der Standardeinstellung ist. AWS CloudFormation