Aspects et AWS CDK - AWS Kit de développement Cloud (AWS CDK) v2
Aspects et mixinsAspects en détailExemple

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.

Aspects et AWS CDK

Les aspects permettent d'appliquer une opération à toutes les constructions d'une portée donnée. L'aspect peut modifier les constructions, par exemple en ajoutant des balises. Il peut également vérifier quelque chose concernant l'état des constructions, par exemple s'assurer que tous les compartiments sont chiffrés.

Pour appliquer un aspect à une construction et à toutes les constructions de la même portée, appelez Aspects.of(<SCOPE>).add() avec un nouvel aspect, comme indiqué dans l'exemple suivant.

Exemple
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(...))

Le AWS CDK utilise des aspects pour étiqueter les ressources, mais le framework peut également être utilisé à d'autres fins. Par exemple, vous pouvez l'utiliser pour valider ou modifier les AWS CloudFormation ressources définies pour vous par des constructions de niveau supérieur.

Aspects et mixins

Aspects et Mixins modifient tous deux les constructions, mais ils diffèrent quant au moment et à la manière dont ils sont appliqués :

Fonctionnalité Aspects Mixages

Lorsqu'il est appliqué

Pendant la synthèse, une fois que tous les autres codes ont été exécutés.

Immédiatement quand il .with() est appelé.

Scope (Portée)

Toutes les constructions d'une portée donnée, y compris les constructions ajoutées ultérieurement.

Uniquement les constructions auxquelles vous les appliquez explicitement.

Style

Déclaratif : vous définissez une règle et le CDK l'applique.

Impératif : c'est vous qui choisissez ce que vous voulez appliquer et où.

Idéal pour

Validation, conformité, balisage, politiques générales.

Ajouter des fonctionnalités spécifiques à des ressources individuelles.

Utilisez Aspects lorsque vous souhaitez appliquer des règles à l'ensemble de votre application ou vérifier que les constructions répondent à certains critères. Utilisez Mixins lorsque vous souhaitez ajouter une fonctionnalité spécifique à une construction spécifique.

Aspects et Mixins peuvent être utilisés ensemble. Par exemple, vous pouvez utiliser Mixins pour configurer des ressources individuelles et Aspects pour vérifier que toutes les ressources d'une pile répondent aux exigences de sécurité de votre organisation.

Aspects en détail

Les aspects utilisent le modèle des visiteurs. Un aspect est une classe qui implémente l'interface suivante.

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

JavaScript n'a pas d'interface en tant que fonctionnalité de langage. Par conséquent, un aspect est simplement une instance d'une classe ayant une visit méthode qui accepte le nœud à opérer.

Python

Python n'a pas d'interface en tant que fonctionnalité de langage. Par conséquent, un aspect est simplement une instance d'une classe ayant une visit méthode qui accepte le nœud à opérer.

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)
}

Lorsque vous appelezAspects.of(<SCOPE>).add(…​), la construction ajoute l'aspect à une liste interne d'aspects. Vous pouvez obtenir la liste avecAspects.of(<SCOPE>).

Pendant la phase de préparation, le AWS CDK appelle la visit méthode de l'objet pour la construction et chacun de ses enfants dans l'ordre du haut vers le bas.

La visit méthode est libre de changer quoi que ce soit dans la construction. Dans les langages fortement typés, convertissez la construction reçue en un type plus spécifique avant d'accéder aux propriétés ou méthodes spécifiques à la construction.

Les aspects ne se propagent pas au-delà des limites de la Stage construction, car ils Stages sont autonomes et immuables une fois définis. Appliquez des aspects à la Stage construction elle-même (ou à une valeur inférieure) si vous souhaitez qu'ils visitent les constructions situées à l'intérieur duStage.

Exemple

L'exemple suivant confirme que le versionnement est activé pour tous les compartiments créés dans la pile. L'aspect ajoute une annotation d'erreur aux constructions qui échouent à la validation. Cela entraîne l'échec de l'synthopération et empêche le déploiement de l'assemblage cloud qui en résulte.

Exemple
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());