Ceci est le guide du développeur du AWS CDK v2. L'ancien CDK v1 est entré en maintenance le 1er juin 2022 et a pris fin le 1er juin 2023.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

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

Les mixins sont des fonctionnalités réutilisables que vous appliquez aux constructions à l'aide de la `.with()` méthode. Ils ajoutent des fonctionnalités aux constructions L1 (CloudFormationniveau) et L2 (basées sur l'intention), telles que le contrôle de version, la suppression automatique d'objets ou le blocage de l'accès public. Chaque mixin fonctionne sur une seule ressource. Pour connecter deux ressources, utilisez plutôt [Facades](facades.md).

Chaque mixin cible un type de ressource spécifique et porte le nom de cette ressource. Par exemple, `BucketVersioning` cible les compartiments Amazon S3. Vous accédez aux mixins via l'`mixins`espace de noms de chaque module de service, tel que. `s3.mixins`

## Appliquer des mixins
<a name="mixins-basic"></a>

Vous appliquez des mixins à l'aide de la `.with()` méthode, qui est disponible sur toutes les constructions. Vous pouvez enchaîner plusieurs mixins ensemble :

**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())
```

Chaque mixin déclare les types de ressources qu'il prend en charge. Si vous appliquez un mixin à une construction qu'il ne prend pas en charge, il est ignoré en silence. Cela signifie que vous pouvez appliquer des mixins à grande échelle en toute sécurité sans vous soucier des incohérences entre les types. Si vous devez vous assurer qu'un mixin est appliqué, utilisez [`requireAll()`ou `requireAny()`](#mixins-advanced).

## Utiliser Mixins avec les constructions L1 et L2
<a name="mixins-l1-l2"></a>

Les mixins fonctionnent avec les constructions L1 et L2. Lorsque vous appliquez un mixin à une construction L2, cela s'applique également à la ressource L1 qui la sous-tend.

L'exemple suivant montre comment appliquer des mixins aux constructions L1 et L2 :

**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())
```

## Propriétés des mélanges et des propriétés de construction
<a name="mixins-vs-props"></a>

Les propriétés de mixage et de construction fonctionnent ensemble. Les propriétés de construction L2 configurent une ressource lorsque vous la créez. Les mixins peuvent être appliqués à tout moment.

Utilisez les propriétés de construction L2 lorsque  
Vous utilisez une construction L2 et la propriété dont vous avez besoin est disponible. Il s'agit de l'approche la plus simple.

Utilisez Mixins lorsque  
+ Vous travaillez avec une construction L1 et souhaitez des fonctionnalités de type L2.
+ Vous souhaitez ajouter une fonction à une construction L2 qui n'est pas disponible en tant que propriété.
+ Vous souhaitez appliquer la même fonctionnalité à plusieurs constructions de types différents.

Les mixins ne remplacent pas les propriétés de construction. Ils ne peuvent pas rendre une propriété obligatoire facultative ou modifier les valeurs par défaut.

## Appliquer des mixins à plusieurs constructions
<a name="mixins-advanced"></a>

L'`Mixins.of()`API permet de mieux contrôler la manière dont les mixins sont appliqués dans un scope. Au lieu de faire appel `.with()` à des constructions individuelles, vous pouvez appliquer un mixin à toutes les constructions correspondantes d'une pile ou d'une portée en même temps :

**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())
```

Par défaut, les constructions qui ne supportent pas le mixin sont ignorées silencieusement. `requireAll()`À utiliser pour affirmer que le mixin est appliqué à toutes les constructions de la sélection, ou `requireAny()` pour affirmer qu'il est appliqué à au moins une d'entre elles. Ceci est utile pour s'assurer que les ressources ont une configuration requise :

**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())
```

## Mixages et aspects
<a name="mixins-aspects"></a>

Les mixins et [les aspects](aspects.md) sont liés mais ont des objectifs différents :
+  Les **mixins** sont appliqués immédiatement lorsque vous appelez`.with()`. Vous choisissez exactement les constructions auxquelles les appliquer.
+  Les **aspects** s'appliquent lors de la synthèse à toutes les constructions d'un scope. Utilisez-les pour les politiques générales et les contrôles.

Utilisez Mixins pour ajouter une fonctionnalité à des constructions spécifiques. Utilisez Aspects pour appliquer des règles ou appliquer des modifications à l'ensemble de votre application.

## Ressources connexes
<a name="mixins-related"></a>
+  [Façades](facades.md) — Connectez les ressources aux principaux IAM et à d'autres services.
+  [Aspects](aspects.md) — Appliquez les modifications ou validez les constructions dans l'ensemble de votre application.
+  [Constructions](constructs.md) — Découvrez les constructions L1, L2 et L3.
+  [Personnalisation des constructions](cfn-layer.md) : personnalisez les constructions avec des trappes d'échappement et des remplacements bruts.