Aspectos e o AWS CDK - AWS Kit de desenvolvimento em nuvem (AWS CDK) v2
Aspectos versus misturasAspectos em detalhesExemplo

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á.

Aspectos e o AWS CDK

Aspectos são uma forma de aplicar uma operação a todos os constructos em um determinado escopo. O aspecto pode modificar os constructos, por exemplo, adicionando tags. Ou pode verificar algo sobre o estado dos constructos, como garantir que todos os buckets estejam criptografados.

Para aplicar um aspecto a um constructo e a todos os constructos no mesmo escopo, chame Aspects.of(<SCOPE>).add() com um novo aspecto, conforme mostrado no exemplo a seguir.

exemplo
TypeScript
Aspects.of(myConstruct).add(new SomeAspect(...));
JavaScript
Aspects.of(myConstruct).add(new SomeAspect(...));
Python
Aspects.of(my_construct).add(SomeAspect(...))
Java
Aspects.of(myConstruct).add(new SomeAspect(...));
C#
Aspects.Of(myConstruct).add(new SomeAspect(...));
Go
awscdk.Aspects_Of(stack).Add(awscdk.NewTag(...))

O AWS CDK usa aspectos para marcar recursos, mas a estrutura também pode ser usada para outras finalidades. Por exemplo, você pode usá-lo para validar ou alterar os AWS CloudFormation recursos definidos para você por construções de nível superior.

Aspectos versus misturas

Tanto os Aspects quanto os Mixins modificam construções, mas diferem em quando e como são aplicados:

Recurso Aspectos Misturas

Quando aplicado

Durante a síntese, após a execução de todos os outros códigos.

Imediatamente quando .with() é chamado.

Escopo

Todas as construções em um determinado escopo, incluindo construções adicionadas posteriormente.

Somente as construções às quais você as aplica explicitamente.

Style (Estilo)

Declarativo — você define uma regra e o CDK a aplica.

Imperativo — você escolhe o que aplicar e onde.

Melhor para

Validação, conformidade, marcação, políticas amplas.

Adicionar recursos específicos a recursos individuais.

Use Aspects quando quiser aplicar regras em todo o aplicativo ou validar se as construções atendem a determinados critérios. Use Mixins quando quiser adicionar um recurso específico a uma construção específica.

Aspects e Mixins podem ser usados juntos. Por exemplo, você pode usar o Mixins para configurar recursos e aspectos individuais para validar se todos os recursos em uma pilha atendem aos requisitos de segurança da sua organização.

Aspectos em detalhes

Os aspectos empregam o padrão do visitante. Um aspecto é uma classe que implementa a interface a seguir.

exemplo
TypeScript
interface IAspect {
   visit(node: IConstruct): void;}
JavaScript

JavaScript não tem interfaces como recurso de linguagem. Portanto, um aspecto é simplesmente uma instância de uma classe com um método visit que aceita o nó no qual ele será operado.

Python

O Python não tem interfaces como atributo de linguagem. Portanto, um aspecto é simplesmente uma instância de uma classe com um método visit que aceita o nó no qual ele será operado.

Java
public interface IAspect {
    public void visit(Construct node);
}
C#
public interface IAspect
{
    void Visit(IConstruct node);
}
Go
type IAspect interface {
  Visit(node constructs.IConstruct)
}

Quando você chama Aspects.of(<SCOPE>).add(…​), o constructo adiciona o aspecto a uma lista interna de aspectos. É possível obter a lista com Aspects.of(<SCOPE>).

Durante a fase de preparação, o AWS CDK chama o visit método do objeto para a construção e cada um de seus filhos na ordem de cima para baixo.

O método visit é livre para alterar qualquer coisa no constructo. Em linguagens de tipagem forte, converta o constructo recebido em um tipo mais específico antes de acessar propriedades ou métodos específicos do constructo.

Os aspectos não se propagam além dos limites do constructo Stage, porque Stages são independentes e imutáveis após a definição. Aplique aspectos no constructo Stage em si (ou inferior) se quiser que eles visitem constructos dentro do Stage.

Exemplo

O exemplo a seguir confirma que todos os buckets criados na pilha têm o versionamento ativado. O aspecto adiciona uma anotação de erro aos constructos que falham na validação. Isso resulta na falha da operação synth e impede a implantação do conjunto de nuvem resultante.

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