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.
# Aspekte und das AWS CDK
Aspekte sind eine Möglichkeit, eine Operation auf alle Konstrukte in einem bestimmten Bereich anzuwenden. Der Aspekt könnte die Konstrukte modifizieren, beispielsweise durch Hinzufügen von Tags. Oder es könnte etwas über den Zustand der Konstrukte überprüfen, z. B. sicherstellen, dass alle Buckets verschlüsselt sind.
Um einen Aspekt auf ein Konstrukt und alle Konstrukte desselben Gültigkeitsbereichs anzuwenden, rufen Sie ` [Aspects](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Aspects.html#static-ofscope).of().add()` mit einem neuen Aspekt auf, wie im folgenden Beispiel gezeigt.
**Example**
```
Aspects.of(myConstruct).add(new SomeAspect(...));
```
```
Aspects.of(myConstruct).add(new SomeAspect(...));
```
```
Aspects.of(my_construct).add(SomeAspect(...))
```
```
Aspects.of(myConstruct).add(new SomeAspect(...));
```
```
Aspects.Of(myConstruct).add(new SomeAspect(...));
```
```
awscdk.Aspects_Of(stack).Add(awscdk.NewTag(...))
```
Das AWS CDK verwendet Aspekte, um [Ressourcen zu taggen](tagging.md), aber das Framework kann auch für andere Zwecke verwendet werden. Sie können es beispielsweise verwenden, um die AWS CloudFormation Ressourcen zu validieren oder zu ändern, die durch Konstrukte auf höherer Ebene für Sie definiert sind.
## Aspekte im Vergleich zu Mixins
Aspekte und [Mixins](mixins.md) modifizieren beide Konstrukte, unterscheiden sich jedoch darin, wann und wie sie angewendet werden:
| Feature | Aspekte | Mixins |
| --- | --- | --- |
| **Wenn angewendet** | Während der Synthese, nachdem der gesamte andere Code ausgeführt wurde. | Sofort, wenn aufgerufen `.with()` wird. |
| **Scope** | Alle Konstrukte in einem bestimmten Bereich, einschließlich der später hinzugefügten Konstrukte. | Nur die Konstrukte, auf die Sie sie explizit anwenden. |
| **Style** | Deklarativ — Sie legen eine Regel fest und das CDK wendet sie an. | Unverzichtbar — Sie entscheiden, was und wo angewendet werden soll. |
| **Am besten geeignet für** | Validierung, Einhaltung von Vorschriften, Kennzeichnung, allgemeine Richtlinien. | Hinzufügen bestimmter Funktionen zu einzelnen Ressourcen. |
Verwenden Sie Aspekte, wenn Sie Regeln für Ihre gesamte Anwendung durchsetzen oder überprüfen möchten, ob Konstrukte bestimmte Kriterien erfüllen. Verwenden Sie Mixins, wenn Sie einem bestimmten Konstrukt ein bestimmtes Feature hinzufügen möchten.
Aspekte und Mixins können zusammen verwendet werden. Beispielsweise können Sie Mixins verwenden, um einzelne Ressourcen zu konfigurieren, und Aspekte, um zu überprüfen, ob alle Ressourcen in einem Stack die Sicherheitsanforderungen Ihres Unternehmens erfüllen.
## Aspekte im Detail
Aspekte orientieren sich am [Besuchermuster](https://en.wikipedia.org/wiki/Visitor_pattern). Ein Aspekt ist eine Klasse, die die folgende Schnittstelle implementiert.
**Example**
```
interface IAspect {
visit(node: IConstruct): void;}
```
JavaScript hat keine Schnittstellen als Sprachfunktion. Daher ist ein Aspekt einfach eine Instanz einer Klasse mit einer `visit` Methode, die den Knoten akzeptiert, auf dem operiert werden soll.
Python hat keine Schnittstellen als Sprachfunktion. Daher ist ein Aspekt einfach eine Instanz einer Klasse mit einer `visit` Methode, die den Knoten akzeptiert, auf dem operiert werden soll.
```
public interface IAspect {
public void visit(Construct node);
}
```
```
public interface IAspect
{
void Visit(IConstruct node);
}
```
```
type IAspect interface {
Visit(node constructs.IConstruct)
}
```
Wenn Sie aufrufen`Aspects.of().add(…)`, fügt das Konstrukt den Aspekt zu einer internen Liste von Aspekten hinzu. Sie können die Liste mit abrufen`Aspects.of()`.
Während der [Vorbereitungsphase](deploy.md#deploy-how-synth-app) ruft das AWS CDK die `visit` Methode des Objekts für das Konstrukt und jedes seiner untergeordneten Objekte in der Reihenfolge von oben nach unten auf.
Es steht der `visit` Methode frei, alles am Konstrukt zu ändern. Wandeln Sie in stark typisierten Sprachen das empfangene Konstrukt in einen spezifischeren Typ um, bevor Sie auf konstruktspezifische Eigenschaften oder Methoden zugreifen.
Aspekte breiten sich nicht über `Stage` Konstruktgrenzen hinweg aus, da sie in sich abgeschlossen und nach der Definition `Stages` unveränderlich sind. Wenden Sie Aspekte auf das `Stage` Konstrukt selbst (oder auf eine niedrigere Ebene) an, wenn Sie möchten, dass sie Konstrukte innerhalb von besuchen. `Stage`
## Beispiel
Im folgenden Beispiel wird überprüft, ob für alle im Stack erstellten Buckets die Versionsverwaltung aktiviert ist. Der Aspekt fügt den Konstrukten, bei denen die Überprüfung fehlschlägt, eine Fehleranmerkung hinzu. Dies führt dazu, dass der `synth` Vorgang fehlschlägt und die Bereitstellung der resultierenden Cloud-Assembly verhindert wird.
**Example**
```
class BucketVersioningChecker implements IAspect {
public visit(node: IConstruct): void {
// See that we're dealing with a CfnBucket
if (node instanceof s3.CfnBucket) {
// Check for versioning property, exclude the case where the property
// can be a token (IResolvable).
if (!node.versioningConfiguration
|| (!Tokenization.isResolvable(node.versioningConfiguration)
&& node.versioningConfiguration.status !== 'Enabled')) {
Annotations.of(node).addError('Bucket versioning is not enabled');
}
}
}
}
// Later, apply to the stack
Aspects.of(stack).add(new BucketVersioningChecker());
```
```
class BucketVersioningChecker {
visit(node) {
// See that we're dealing with a CfnBucket
if ( node instanceof s3.CfnBucket) {
// Check for versioning property, exclude the case where the property
// can be a token (IResolvable).
if (!node.versioningConfiguration
|| !Tokenization.isResolvable(node.versioningConfiguration)
&& node.versioningConfiguration.status !== 'Enabled')) {
Annotations.of(node).addError('Bucket versioning is not enabled');
}
}
}
}
// Later, apply to the stack
Aspects.of(stack).add(new BucketVersioningChecker());
```
```
@jsii.implements(cdk.IAspect)
class BucketVersioningChecker:
def visit(self, node):
# See that we're dealing with a CfnBucket
if isinstance(node, s3.CfnBucket):
# Check for versioning property, exclude the case where the property
# can be a token (IResolvable).
if (not node.versioning_configuration or
not Tokenization.is_resolvable(node.versioning_configuration)
and node.versioning_configuration.status != "Enabled"):
Annotations.of(node).add_error('Bucket versioning is not enabled')
# Later, apply to the stack
Aspects.of(stack).add(BucketVersioningChecker())
```
```
public class BucketVersioningChecker implements IAspect
{
@Override
public void visit(Construct node)
{
// See that we're dealing with a CfnBucket
if (node instanceof CfnBucket)
{
CfnBucket bucket = (CfnBucket)node;
Object versioningConfiguration = bucket.getVersioningConfiguration();
if (versioningConfiguration == null ||
!Tokenization.isResolvable(versioningConfiguration.toString()) &&
!versioningConfiguration.toString().contains("Enabled"))
Annotations.of(bucket.getNode()).addError("Bucket versioning is not enabled");
}
}
}
// Later, apply to the stack
Aspects.of(stack).add(new BucketVersioningChecker());
```
```
class BucketVersioningChecker : Amazon.Jsii.Runtime.Deputy.DeputyBase, IAspect
{
public void Visit(IConstruct node)
{
// See that we're dealing with a CfnBucket
if (node is CfnBucket)
{
var bucket = (CfnBucket)node;
if (bucket.VersioningConfiguration is null ||
!Tokenization.IsResolvable(bucket.VersioningConfiguration) &&
!bucket.VersioningConfiguration.ToString().Contains("Enabled"))
Annotations.Of(bucket.Node).AddError("Bucket versioning is not enabled");
}
}
}
// Later, apply to the stack
Aspects.Of(stack).add(new BucketVersioningChecker());
```