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](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Aspects.html#static-ofscope).of().add()` com um novo aspecto, conforme mostrado no exemplo a seguir.
**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(...))
```
O AWS CDK usa aspectos para [marcar recursos](tagging.md), 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](mixins.md) 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](https://en.wikipedia.org/wiki/Visitor_pattern). Um aspecto é uma classe que implementa a interface a seguir.
**Example**
```
interface IAspect {
visit(node: IConstruct): void;}
```
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.
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.
```
public interface IAspect {
public void visit(Construct node);
}
```
```
public interface IAspect
{
void Visit(IConstruct node);
}
```
```
type IAspect interface {
Visit(node constructs.IConstruct)
}
```
Quando você chama `Aspects.of().add(…)`, o constructo adiciona o aspecto a uma lista interna de aspectos. É possível obter a lista com `Aspects.of()`.
Durante a [fase de preparação](deploy.md#deploy-how-synth-app), 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.
**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());
```