Esta es la guía para desarrolladores de AWS CDK v2. La primera versión del CDK pasó a la etapa de mantenimiento el 1.° de junio de 2022 y no cuenta con soporte desde el 1.° de junio de 2023.
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Aspectos y el AWS CDK
Los aspectos son una forma de aplicar una operación a todos los constructos de un ámbito determinado. El aspecto podría modificar los constructos, por ejemplo, mediante el agregado de etiquetas. O podría verificar algo sobre el estado de los constructos, como asegurarse de que todos los bucket estén cifrados.
Para aplicar un aspecto a un constructo y a todos los constructos del mismo ámbito, llame a ` [Aspects](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Aspects.html#static-ofscope).of().add()` con aspecto nuevo, como se muestra en el siguiente ejemplo.
**Example**
```
Aspects.of(myConstruct).add(new SomeAspect(...));
```
```
Aspects.of(myConstruct).add(new SomeAspect(...));
```
```
Aspects.of(my_construct).add(SomeAspect(...))
```
```
Aspects.of(myConstruct).add(new SomeAspect(...));
```
```
Aspects.Of(myConstruct).add(new SomeAspect(...));
```
```
awscdk.Aspects_Of(stack).Add(awscdk.NewTag(...))
```
El AWS CDK usa aspectos para [etiquetar los recursos](tagging.md), pero el marco también se puede usar para otros fines. Por ejemplo, puede usarla para validar o cambiar los AWS CloudFormation recursos que definan para usted las construcciones de nivel superior.
## Aspectos frente a mixins
Tanto Aspects como [Mixins](mixins.md) modifican los constructos, pero difieren en el momento y la forma en que se aplican:
| Característica | Aspectos | Mezclas |
| --- | --- | --- |
| **Cuando se aplica** | Durante la síntesis, después de que se haya ejecutado el resto del código. | Inmediatamente cuando `.with()` se llama. |
| **Alcance** | Todas las construcciones de un ámbito determinado, incluidas las que se agreguen posteriormente. | Solo las construcciones a las que las aplique de forma explícita. |
| **Style (Estilo)** | Declarativo: se establece una regla y la CDK la aplica. | Imperativo: tú eliges qué aplicar y dónde. |
| **Lo mejor para** | Validación, conformidad, etiquetado y políticas generales. | Añadir funciones específicas a los recursos individuales. |
Utilice Aspects cuando desee hacer cumplir las reglas en toda la aplicación o validar que las construcciones cumplan ciertos criterios. Utilice Mixins cuando desee añadir una función específica a una construcción específica.
Aspects y Mixins se pueden usar juntos. Por ejemplo, puede usar Mixins para configurar recursos individuales y Aspects para validar que todos los recursos de una pila cumplen con los requisitos de seguridad de su organización.
## Aspectos en detalle
Los aspectos emplean el [patrón de visitantes](https://en.wikipedia.org/wiki/Visitor_pattern). Un aspecto es una clase que implementa la siguiente interfaz.
**Example**
```
interface IAspect {
visit(node: IConstruct): void;}
```
JavaScript no tiene interfaces como función de idioma. Por lo tanto, un aspecto es simplemente una instancia de una clase que tiene un método `visit` que acepta el nodo en el que se va a operar.
Python no tiene interfaces como característica del lenguaje. Por lo tanto, un aspecto es simplemente una instancia de una clase que tiene un método `visit` que acepta el nodo en el que se va a operar.
```
public interface IAspect {
public void visit(Construct node);
}
```
```
public interface IAspect
{
void Visit(IConstruct node);
}
```
```
type IAspect interface {
Visit(node constructs.IConstruct)
}
```
Cuando llama a `Aspects.of().add(…)`, el constructo agrega el aspecto a una lista interna de aspectos. Puede obtener la lista mediante `Aspects.of()`.
Durante la [fase de preparación](deploy.md#deploy-how-synth-app), el AWS CDK llama al `visit` método del objeto para la construcción y para cada uno de sus elementos secundarios en orden descendente.
El método `visit` puede cambiar cualquier aspecto del constructo. En lenguajes fuertemente tipados, convierta el constructo recibido en un tipo más específico antes de acceder a las propiedades o métodos específicos del constructo.
Los aspectos no se propagan a través de los límites `Stage` de los constructos, porque los `Stages` son autónomos e inmutables después de la definición. Aplique los aspectos en el propio `Stage` del constructo (o en una parte inferior) si quiere que visiten los constructos que se encuentran dentro del `Stage`.
## Ejemplo
El siguiente ejemplo valida que todos los buckets creados en la pila tengan activado el control de versiones. El aspecto agrega una anotación de error a los constructos que no superan la validación. Esto provoca un error en la operación `synth` e impide implementar el ensamblaje de nube resultante.
**Example**
```
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());
```
```
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());
```
```
@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())
```
```
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());
```
```
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());
```