Questa è la AWS CDK v2 Developer Guide. Il vecchio CDK v1 è entrato in manutenzione il 1° giugno 2022 e ha terminato il supporto il 1° giugno 2023.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Aspetti e AWS CDK
Gli aspetti sono un modo per applicare un'operazione a tutti i costrutti in un determinato ambito. L'aspetto potrebbe modificare i costrutti, ad esempio aggiungendo tag. Oppure potrebbe verificare qualcosa sullo stato dei costrutti, ad esempio assicurarsi che tutti i bucket siano crittografati.
Per applicare un aspetto a un costrutto e a tutti i costrutti nello stesso ambito, chiamate ` [Aspects](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Aspects.html#static-ofscope).of().add()` con un nuovo aspetto, come mostrato nell'esempio seguente.
**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(...))
```
Il AWS CDK utilizza gli aspetti per [etichettare le risorse](tagging.md), ma il framework può essere utilizzato anche per altri scopi. Ad esempio, potete usarlo per convalidare o modificare le AWS CloudFormation risorse definite per voi da costrutti di livello superiore.
## Aspects vs. Mixins
Aspects e [Mixin](mixins.md) modificano entrambi i costrutti, ma differiscono nel momento e nel modo in cui vengono applicati:
| Funzionalità | Aspetti | Mixins |
| --- | --- | --- |
| **Quando applicato** | Durante la sintesi, dopo che tutto l'altro codice è stato eseguito. | Immediatamente quando `.with()` viene chiamato. |
| **Scope** (Ambito) | Tutti i costrutti in un determinato ambito, inclusi i costrutti aggiunti successivamente. | Solo i costrutti a cui li applichi esplicitamente. |
| **Style** (Stile) | Dichiarativo: imposti una regola e il CDK la applica. | Imperativo: scegli tu cosa applicare e dove. |
| **Ideale per** | Convalida, conformità, etichettatura, politiche generali. | Aggiungere funzionalità specifiche alle singole risorse. |
Usa Aspects quando desideri applicare le regole all'intera applicazione o verificare che i costrutti soddisfino determinati criteri. Usa Mixins quando vuoi aggiungere una funzionalità specifica a un costrutto specifico.
Aspects e Mixins possono essere usati insieme. Ad esempio, potreste utilizzare Mixins per configurare singole risorse e Aspects per verificare che tutte le risorse in uno stack soddisfino i requisiti di sicurezza dell'organizzazione.
## Aspetti in dettaglio
Gli aspetti utilizzano lo [schema dei visitatori.](https://en.wikipedia.org/wiki/Visitor_pattern) Un aspetto è una classe che implementa la seguente interfaccia.
**Example**
```
interface IAspect {
visit(node: IConstruct): void;}
```
JavaScript non ha interfacce come funzionalità linguistica. Pertanto, un aspetto è semplicemente un'istanza di una classe con un `visit` metodo che accetta il nodo su cui operare.
Python non ha interfacce come funzionalità del linguaggio. Pertanto, un aspetto è semplicemente un'istanza di una classe con un `visit` metodo che accetta il nodo su cui operare.
```
public interface IAspect {
public void visit(Construct node);
}
```
```
public interface IAspect
{
void Visit(IConstruct node);
}
```
```
type IAspect interface {
Visit(node constructs.IConstruct)
}
```
Quando si chiama`Aspects.of().add(…)`, il costrutto aggiunge l'aspetto a un elenco interno di aspetti. È possibile ottenere l'elenco con`Aspects.of()`.
Durante la [fase di preparazione](deploy.md#deploy-how-synth-app), il AWS CDK chiama il `visit` metodo dell'oggetto per il costrutto e ciascuno dei suoi figli in ordine dall'alto verso il basso.
Il `visit` metodo è libero di modificare qualsiasi cosa nel costrutto. In linguaggi fortemente tipizzati, trasmetti il costrutto ricevuto a un tipo più specifico prima di accedere a proprietà o metodi specifici del costrutto.
Gli aspetti non si propagano oltre i confini del `Stage` costrutto, perché dopo la definizione `Stages` sono autonomi e immutabili. Applica gli aspetti sul `Stage` costrutto stesso (o inferiore) se vuoi che visitino i costrutti all'interno di. `Stage`
## Esempio
L'esempio seguente verifica che tutti i bucket creati nello stack abbiano il controllo delle versioni abilitato. L'aspetto aggiunge un'annotazione di errore ai costrutti che non superano la convalida. Ciò comporta il fallimento dell'`synth`operazione e impedisce la distribuzione dell'assemblaggio cloud risultante.
**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());
```