Misturas - AWS Kit de desenvolvimento em nuvem (AWS CDK) v2
Aplique MixinsUse mixins com construções L1 e L2Misturas versus propriedades de construçãoAplique Mixins a várias construçõesMisturas e aspectosRecursos relacionados

Este é o Guia do desenvolvedor do AWS CDK v2. O CDK v1 antigo entrou em manutenção em 1º de junho de 2022 e encerrou o suporte em 1º de junho de 2023.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Misturas

Os mixins são recursos reutilizáveis que você aplica às construções usando o método. .with() Eles adicionam recursos às construções L1 (CloudFormationnível) e L2 (com base em intenção), como controle de versão, exclusão automática de objetos ou bloqueio do acesso público. Cada mixin funciona em um único recurso. Para conectar dois recursos, use Facades em vez disso.

Cada mixin tem como alvo um tipo de recurso específico e tem o nome desse recurso. Por exemplo, BucketVersioning tem como alvo buckets do Amazon S3. Você acessa mixins por meio do mixins namespace de cada módulo de serviço, como. s3.mixins

Aplique Mixins

Você aplica mixins usando o .with() método, que está disponível em todas as construções. Você pode encadear vários mixins juntos:

exemplo
TypeScript
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());
JavaScript
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());
Python
import aws_cdk.aws_s3 as s3

bucket = s3.CfnBucket(self, "MyBucket") \
    .with_(s3.mixins.BucketVersioning()) \
    .with_(s3.mixins.BucketBlockPublicAccess())
Java
import software.amazon.awscdk.services.s3.*;

CfnBucket bucket = new CfnBucket(this, "MyBucket");
bucket.with(new BucketVersioning());
bucket.with(new BucketBlockPublicAccess());
C#
using Amazon.CDK.AWS.S3;

var bucket = new CfnBucket(this, "MyBucket");
bucket.With(new BucketVersioning());
bucket.With(new BucketBlockPublicAccess());
Go
bucket := awss3.NewCfnBucket(stack, jsii.String("MyBucket"), nil)
bucket.With(awss3.NewBucketVersioning())
bucket.With(awss3.NewBucketBlockPublicAccess())

Cada mixin declara quais tipos de recursos ele suporta. Se você aplicar uma mixina a uma construção que ela não suporta, ela é ignorada silenciosamente. Isso significa que você pode aplicar mixins de forma ampla com segurança, sem se preocupar com incompatibilidades de tipos. Se você precisar garantir que uma mistura seja aplicada, use requireAll()ou requireAny().

Use mixins com construções L1 e L2

Os mixins funcionam com as construções L1 e L2. Quando você aplica um mixin a uma construção L2, ele também se aplica ao recurso L1 por trás dele.

O exemplo a seguir mostra como aplicar mixins às construções L1 e L2:

exemplo
TypeScript
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());
JavaScript
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());
Python
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())
Java
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());
C#
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());
Go
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())

Misturas versus propriedades de construção

As misturas e as propriedades de construção funcionam juntas. As propriedades de construção L2 configuram um recurso quando você o cria. As misturas podem ser aplicadas a qualquer momento.

Use propriedades de construção L2 quando

Você está usando uma construção L2 e a propriedade de que você precisa está disponível. Essa é a abordagem mais simples.

Use Mixins quando

  • Você está trabalhando com uma construção L1 e deseja recursos semelhantes aos L2.

  • Você deseja adicionar um recurso a uma construção L2 que não está disponível como propriedade.

  • Você deseja aplicar o mesmo recurso em várias construções de tipos diferentes.

Os mixins não substituem as propriedades de construção. Eles não podem tornar uma propriedade obrigatória opcional nem alterar os valores padrão.

Aplique Mixins a várias construções

A Mixins.of() API fornece mais controle sobre como os mixins são aplicados em um escopo. Em vez de chamar .with() construções individuais, você pode aplicar um mixin a todas as construções correspondentes em uma pilha ou escopo de uma só vez:

exemplo
TypeScript
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());
JavaScript
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());
Python
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())
Java
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());
C#
using Amazon.CDK;
using Amazon.CDK.AWS.S3;

// Apply to all supported constructs in the stack
Mixins.Of(stack).Apply(new BucketVersioning());
Go
awscdk.Mixins_Of(stack, nil).Apply(awss3.NewBucketVersioning())

Por padrão, as construções que não suportam o mixin são ignoradas silenciosamente. Use requireAll() para afirmar que o mixin é aplicado a cada construção na seleção ou requireAny() para afirmar que ele é aplicado a pelo menos um. Isso é útil para garantir que os recursos tenham uma configuração necessária:

exemplo
TypeScript
// Throws an error if any construct in the scope doesn't support the mixin
Mixins.of(stack)
  .requireAll()
  .apply(new s3.mixins.BucketVersioning());
JavaScript
// Throws an error if any construct in the scope doesn't support the mixin
Mixins.of(stack)
  .requireAll()
  .apply(new s3.mixins.BucketVersioning());
Python
# Throws an error if any construct in the scope doesn't support the mixin
Mixins.of(stack) \
    .require_all() \
    .apply(s3.mixins.BucketVersioning())
Java
// Throws an error if any construct in the scope doesn't support the mixin
Mixins.of(stack)
        .requireAll()
        .apply(new BucketVersioning());
C#
// Throws an error if any construct in the scope doesn't support the mixin
Mixins.Of(stack)
    .RequireAll()
    .Apply(new BucketVersioning());
Go
awscdk.Mixins_Of(stack, nil).RequireAll().Apply(awss3.NewBucketVersioning())

Misturas e aspectos

Mixins e Aspectos estão relacionados, mas têm propósitos diferentes:

  • Os mixins são aplicados imediatamente quando você liga.with(). Você escolhe exatamente em quais construções aplicá-las.

  • Os aspectos se aplicam durante a síntese a todas as construções em um escopo. Use-os para políticas e verificações amplas.

Use Mixins para adicionar um recurso a construções específicas. Use Aspects para impor regras ou aplicar alterações em todo o aplicativo.

  • Fachadas — Conecte recursos com diretores do IAM e outros serviços.

  • Aspectos — aplique alterações ou valide construções em todo o aplicativo.

  • Construções — Aprenda sobre as construções L1, L2 e L3.

  • Personalize construções — Personalize construções com escotilhas de emergência e substituições brutas.