Dies ist der AWS CDK v2-Entwicklerhandbuch. Das ältere CDK v1 wurde am 1. Juni 2022 in die Wartung aufgenommen 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.

# Mixins
<a name="mixins"></a>

Mixins sind wiederverwendbare Funktionen, die Sie mithilfe der `.with()` Methode auf Konstrukte anwenden. Sie fügen Funktionen sowohl zu L1- (CloudFormation-Ebene) als auch zu L2-Konstrukten (absichtsbasiert) hinzu, z. B. Versionierung, automatisches Löschen von Objekten oder Blockieren des öffentlichen Zugriffs. Jedes Mixin funktioniert auf einer einzigen Ressource. Verwenden Sie stattdessen [Facades](facades.md), um zwei Ressourcen zu verbinden.

Jedes Mixin zielt auf einen bestimmten Ressourcentyp ab und ist nach dieser Ressource benannt. `BucketVersioning`Zielt beispielsweise auf Amazon S3 S3-Buckets ab. Sie greifen über den `mixins` Namespace der einzelnen Servicemodule auf Mixins zu, z. `s3.mixins`

## Mixins anwenden
<a name="mixins-basic"></a>

Sie wenden Mixins mit der `.with()` Methode an, die für alle Konstrukte verfügbar ist. Sie können mehrere Mixins miteinander verketten:

**Example**  

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

const bucket = new s3.CfnBucket(this, 'MyBucket')
  .with(new s3.mixins.BucketVersioning())
  .with(new s3.mixins.BucketBlockPublicAccess());
```

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

const bucket = new s3.CfnBucket(this, 'MyBucket')
  .with(new s3.mixins.BucketVersioning())
  .with(new s3.mixins.BucketBlockPublicAccess());
```

```
import aws_cdk.aws_s3 as s3

bucket = s3.CfnBucket(self, "MyBucket") \
    .with_(s3.mixins.BucketVersioning()) \
    .with_(s3.mixins.BucketBlockPublicAccess())
```

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

CfnBucket bucket = new CfnBucket(this, "MyBucket");
bucket.with(new BucketVersioning());
bucket.with(new BucketBlockPublicAccess());
```

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

var bucket = new CfnBucket(this, "MyBucket");
bucket.With(new BucketVersioning());
bucket.With(new BucketBlockPublicAccess());
```

```
bucket := awss3.NewCfnBucket(stack, jsii.String("MyBucket"), nil)
bucket.With(awss3.NewBucketVersioning())
bucket.With(awss3.NewBucketBlockPublicAccess())
```

Jedes Mixin deklariert, welche Ressourcentypen es unterstützt. Wenn Sie ein Mixin auf ein Konstrukt anwenden, das es nicht unterstützt, wird es stillschweigend übersprungen. Das bedeutet, dass Sie Mixins sicher und breit anwenden können, ohne sich Gedanken über Typinkongruenzen machen zu müssen. [Wenn Sie sicherstellen müssen, dass ein Mixin angewendet wird, verwenden Sie oder. `requireAll()``requireAny()`](#mixins-advanced)

## Verwenden Sie Mixins mit L1- und L2-Konstrukten
<a name="mixins-l1-l2"></a>

Mixins funktionieren sowohl mit L1- als auch mit L2-Konstrukten. Wenn Sie ein Mixin auf ein L2-Konstrukt anwenden, gilt es auch für die dahinter stehende L1-Ressource.

Das folgende Beispiel zeigt, wie Mixins sowohl auf L1- als auch auf L2-Konstrukte angewendet werden:

**Example**  

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

// Using a mixin with an L1 construct
new s3.CfnBucket(this, 'L1Bucket')
  .with(new s3.mixins.BucketVersioning());

// Using a mixin with an L2 construct
new s3.Bucket(this, 'L2Bucket', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
}).with(new s3.mixins.BucketAutoDeleteObjects());
```

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

// Using a mixin with an L1 construct
new s3.CfnBucket(this, 'L1Bucket')
  .with(new s3.mixins.BucketVersioning());

// Using a mixin with an L2 construct
new s3.Bucket(this, 'L2Bucket', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
}).with(new s3.mixins.BucketAutoDeleteObjects());
```

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

# Using a mixin with an L1 construct
s3.CfnBucket(self, "L1Bucket") \
    .with_(s3.mixins.BucketVersioning())

# Using a mixin with an L2 construct
s3.Bucket(self, "L2Bucket",
    removal_policy=cdk.RemovalPolicy.DESTROY,
).with_(s3.mixins.BucketAutoDeleteObjects())
```

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

// Using a mixin with an L1 construct
CfnBucket l1Bucket = new CfnBucket(this, "L1Bucket");
l1Bucket.with(new BucketVersioning());

// Using a mixin with an L2 construct
Bucket l2Bucket = Bucket.Builder.create(this, "L2Bucket")
        .removalPolicy(RemovalPolicy.DESTROY)
        .build();
l2Bucket.with(new BucketAutoDeleteObjects());
```

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

// Using a mixin with an L1 construct
var l1Bucket = new CfnBucket(this, "L1Bucket");
l1Bucket.With(new BucketVersioning());

// Using a mixin with an L2 construct
var l2Bucket = new Bucket(this, "L2Bucket", new BucketProps
{
    RemovalPolicy = RemovalPolicy.DESTROY
});
l2Bucket.With(new BucketAutoDeleteObjects());
```

```
l1Bucket := awss3.NewCfnBucket(stack, jsii.String("L1Bucket"), nil)
l1Bucket.With(awss3.NewBucketVersioning())

l2Bucket := awss3.NewBucket(stack, jsii.String("L2Bucket"), &awss3.BucketProps{
    RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
})
l2Bucket.With(awss3.NewBucketAutoDeleteObjects())
```

## Mixins im Vergleich zu Konstrukteigenschaften
<a name="mixins-vs-props"></a>

Mixins und Konstrukteigenschaften arbeiten zusammen. L2-Konstrukteigenschaften richten eine Ressource ein, wenn Sie sie erstellen. Mixins können jederzeit angewendet werden.

Verwenden Sie L2-Konstrukteigenschaften, wenn  
Sie verwenden ein L2-Konstrukt und die benötigte Eigenschaft ist verfügbar. Dies ist der einfachste Ansatz.

Verwenden Sie Mixins, wenn  
+ Sie arbeiten mit einem L1-Konstrukt und benötigen L2-ähnliche Funktionen.
+ Sie möchten einem L2-Konstrukt ein Feature hinzufügen, das nicht als Eigenschaft verfügbar ist.
+ Sie möchten dasselbe Feature auf mehrere Konstrukte unterschiedlichen Typs anwenden.

Mixins ersetzen keine Konstrukteigenschaften. Sie können eine erforderliche Eigenschaft nicht optional machen oder Standardwerte ändern.

## Wenden Sie Mixins auf mehrere Konstrukte an
<a name="mixins-advanced"></a>

Die `Mixins.of()` API bietet mehr Kontrolle darüber, wie Mixins in einem bestimmten Bereich angewendet werden. Anstatt einzelne Konstrukte aufzurufen, können Sie ein Mixin `.with()` auf alle passenden Konstrukte in einem Stack oder Bereich gleichzeitig anwenden:

**Example**  

```
import { Mixins } from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';

// Apply to all supported constructs in the stack
Mixins.of(stack).apply(new s3.mixins.BucketVersioning());
```

```
const { Mixins } = require('aws-cdk-lib');
const s3 = require('aws-cdk-lib/aws-s3');

// Apply to all supported constructs in the stack
Mixins.of(stack).apply(new s3.mixins.BucketVersioning());
```

```
from aws_cdk import Mixins
import aws_cdk.aws_s3 as s3

# Apply to all supported constructs in the stack
Mixins.of(stack).apply(s3.mixins.BucketVersioning())
```

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

// Apply to all supported constructs in the stack
Mixins.of(stack).apply(new BucketVersioning());
```

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

// Apply to all supported constructs in the stack
Mixins.Of(stack).Apply(new BucketVersioning());
```

```
awscdk.Mixins_Of(stack, nil).Apply(awss3.NewBucketVersioning())
```

Standardmäßig werden Konstrukte, die das Mixin nicht unterstützen, stillschweigend übersprungen. Wird verwendet, `requireAll()` um zu bestätigen, dass das Mixin auf jedes Konstrukt in der Auswahl angewendet wird, oder `requireAny()` um zu bestätigen, dass es auf mindestens eines angewendet wird. Dies ist nützlich, um zu erzwingen, dass Ressourcen eine erforderliche Konfiguration haben:

**Example**  

```
// Throws an error if any construct in the scope doesn't support the mixin
Mixins.of(stack)
  .requireAll()
  .apply(new s3.mixins.BucketVersioning());
```

```
// Throws an error if any construct in the scope doesn't support the mixin
Mixins.of(stack)
  .requireAll()
  .apply(new s3.mixins.BucketVersioning());
```

```
# Throws an error if any construct in the scope doesn't support the mixin
Mixins.of(stack) \
    .require_all() \
    .apply(s3.mixins.BucketVersioning())
```

```
// Throws an error if any construct in the scope doesn't support the mixin
Mixins.of(stack)
        .requireAll()
        .apply(new BucketVersioning());
```

```
// Throws an error if any construct in the scope doesn't support the mixin
Mixins.Of(stack)
    .RequireAll()
    .Apply(new BucketVersioning());
```

```
awscdk.Mixins_Of(stack, nil).RequireAll().Apply(awss3.NewBucketVersioning())
```

## Mixins und Aspekte
<a name="mixins-aspects"></a>

Mixins und [Aspects](aspects.md) sind verwandt, dienen aber unterschiedlichen Zwecken:
+  **Mixins** werden sofort angewendet, wenn Sie anrufen. `.with()` Sie wählen genau aus, auf welche Konstrukte sie angewendet werden sollen.
+  **Aspekte** gelten während der Synthese für alle Konstrukte in einem Bereich. Verwenden Sie sie für allgemeine Richtlinien und Kontrollen.

Verwenden Sie Mixins, um bestimmten Konstrukten ein Feature hinzuzufügen. Verwenden Sie Aspects, um Regeln durchzusetzen oder Änderungen auf Ihre gesamte Anwendung anzuwenden.

## Zugehörige Ressourcen
<a name="mixins-related"></a>
+  [Fassaden](facades.md) — Connect Ressourcen mit IAM-Prinzipalen und anderen Diensten.
+  [Aspekte](aspects.md) — Wenden Sie Änderungen an oder validieren Sie Konstrukte in Ihrer gesamten Anwendung.
+  [Konstrukte](constructs.md) — Erfahren Sie mehr über L1-, L2- und L3-Konstrukte.
+  [Gebäudemodule anpassen — Passen Sie Konstrukte mit Notschraffuren](cfn-layer.md) und unverarbeiteten Überschreibungen individuell an.