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

# Scrivi le regole di Guard per valutare le risorse per Guard Hooks
<a name="guard-hooks-write-rules"></a>

AWS CloudFormation Guard è un linguaggio DSL (Domain Specific Language) open source e generico che puoi utilizzare per la creazione. policy-as-code Questo argomento spiega come utilizzare Guard per creare regole di esempio che possono essere eseguite in Guard Hook per valutazioni CloudFormation e AWS Cloud Control API operazioni automatiche. Si concentrerà anche sui diversi tipi di input disponibili per le regole di Guard a seconda del momento in cui Guard Hook viene eseguito. Un Guard Hook può essere configurato per essere eseguito durante i seguenti tipi di operazioni:
+ Operazioni sulle risorse
+ Operazioni di stack
+ Operazioni di modifica del set

Per ulteriori informazioni sulla scrittura delle regole di Guard, vedi [Writing AWS CloudFormation Guard rules](https://docs.aws.amazon.com/cfn-guard/latest/ug/writing-rules.html)

**Topics**
+ [Gestione delle risorse: regole di Guard](#guard-hooks-write-rules-resource-operations)
+ [Operazione Stack (regole Guard)](#guard-hooks-write-rules-stack-operations)
+ [Modifica le regole operative di Guard](#guard-hooks-write-rules-change-set-operations)

## Gestione delle risorse: regole di Guard
<a name="guard-hooks-write-rules-resource-operations"></a>

Ogni volta che crei, aggiorni o elimini una risorsa, questa viene considerata un'operazione relativa alle risorse. Ad esempio, se esegui l'aggiornamento di uno CloudFormation stack che crea una nuova risorsa, hai completato un'operazione sulla risorsa. Quando crei, aggiorni o elimini una risorsa utilizzando l'API Cloud Control, anche questa viene considerata un'operazione relativa alle risorse. Puoi configurare Guard Hook in base alla destinazione `RESOURCE` e `CLOUD_CONTROL` alle operazioni nella `TargetOperations` configurazione del tuo Hook. Quando il Guard Hook valuta il funzionamento di una risorsa, il motore Guard valuta l'input di una risorsa.

**Topics**
+ [Sintassi di input delle risorse Guard](#guard-hooks-write-rules-resource-operations-input)
+ [Esempio: input relativo al funzionamento delle risorse Guard](#guard-hooks-write-rules-resource-operations-example)
+ [Regole di protezione per le modifiche alle risorse](#guard-hooks-rules-resource-changes)

### Sintassi di input delle risorse Guard
<a name="guard-hooks-write-rules-resource-operations-input"></a>

L'input delle risorse Guard è costituito dai dati messi a disposizione delle regole di Guard per la valutazione.

Di seguito è riportato un esempio di forma di input di risorse:

```
HookContext:
  AWSAccountID: String
  StackId: String
  HookTypeName: String
  HookTypeVersion: String
  InvocationPoint: [CREATE_PRE_PROVISION, UPDATE_PRE_PROVISION, DELETE_PRE_PROVISION]
  TargetName: String
  TargetType: RESOURCE
  TargetLogicalId: String
  ChangeSetId: String
Resources:
  {ResourceLogicalID}:
    ResourceType: {ResourceType}
    ResourceProperties:
        {ResourceProperties}
Previous:
  ResourceLogicalID:
    ResourceType: {ResourceType}
    ResourceProperties:
        {PreviousResourceProperties}
```

`HookContext`  <a name="guard-hook-resource-hookcontext"></a>  
`AWSAccountID`  <a name="guard-hook-resource-awsaccountid"></a>
L'ID del Account AWS contenitore della risorsa da valutare.  
`StackId`  <a name="guard-hook-resource-stackid"></a>
L'ID dello CloudFormation stack che fa parte dell'operazione relativa alla risorsa. È vuoto se il chiamante è Cloud Control API.  
`HookTypeName`  <a name="guard-hook-resource-hooktypename"></a>
Il nome dell'Hook in esecuzione.  
`HookTypeVersion`  <a name="guard-hook-resource-hooktypeversion"></a>
La versione dell'Hook in esecuzione.  
`InvocationPoint`  <a name="guard-hook-resource-invocationpoint"></a>
Il punto esatto della logica di provisioning in cui viene eseguito l'Hook.  
*Valori validi*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-resource-targetname"></a>
Il tipo di oggetto da valutare, ad esempio,`AWS::S3::Bucket`.  
`TargetType`  <a name="guard-hook-resource-targettype"></a>
Il tipo di oggetto da valutare, ad esempio. `AWS::S3::Bucket` Per le risorse fornite con l'API Cloud Control, questo valore sarà. `RESOURCE`  
`TargetLogicalId`  <a name="guard-hook-resource-targetlogicalid"></a>
La risorsa oggetto `TargetLogicalId` di valutazione. Se l'origine dell'Hook è CloudFormation, questo sarà l'ID logico (noto anche come nome logico) della risorsa. Se l'origine dell'Hook è l'API Cloud Control, questo sarà un valore costruito.  
`ChangeSetId`  <a name="guard-hook-resource-changesetid"></a>
L'ID del set di modifiche che è stato eseguito per causare la chiamata di Hook. Questo valore è vuoto se la modifica delle risorse è stata avviata dall'API Cloud Control o dalle operazioni `create-stack``update-stack`, o. `delete-stack`

`Resources`  <a name="guard-hook-resource-resources"></a>  
`ResourceLogicalID`  <a name="guard-hook-resource-current-resourcelogicalid"></a>
Quando l'operazione viene avviata da CloudFormation, `ResourceLogicalID` è l'ID logico della risorsa nel CloudFormation modello.  
Quando l'operazione viene avviata dall'API Cloud Control, `ResourceLogicalID` è una combinazione del tipo di risorsa, del nome, dell'ID dell'operazione e dell'ID della richiesta.  
`ResourceType`  <a name="guard-hook-resource-current-resourcetype"></a>
Il nome del tipo della risorsa (esempio:`AWS::S3::Bucket`).  
`ResourceProperties`  <a name="guard-hook-resource-current-resourceproperties"></a>
Le proprietà proposte della risorsa da modificare. Quando Guard Hook viene eseguito in caso di modifiche alla CloudFormation risorsa, tutte le funzioni, i parametri e le trasformazioni verranno completamente risolti. Se la risorsa viene eliminata, questo valore sarà vuoto.

`Previous`  <a name="guard-hook-resource-previous"></a>  
`ResourceLogicalID`  <a name="guard-hook-resource-previous-resourcelogicalid"></a>
Quando l'operazione viene avviata da CloudFormation, `ResourceLogicalID` è l'ID logico della risorsa nel CloudFormation modello.  
Quando l'operazione viene avviata dall'API Cloud Control, `ResourceLogicalID` è una combinazione del tipo di risorsa, del nome, dell'ID dell'operazione e dell'ID della richiesta.  
`ResourceType`  <a name="guard-hook-resource-previous-resourcetype"></a>
Il nome del tipo della risorsa (esempio:`AWS::S3::Bucket`).  
`ResourceProperties`  <a name="guard-hook-resource-previous-resourceproperties"></a>
Le proprietà correnti associate alla risorsa da modificare. Se la risorsa viene eliminata, questo valore sarà vuoto.

### Esempio: input relativo al funzionamento delle risorse Guard
<a name="guard-hooks-write-rules-resource-operations-example"></a>

L'input di esempio seguente mostra un Guard Hook che riceverà la definizione della `AWS::S3::Bucket` risorsa da aggiornare. Questi sono i dati a disposizione di Guard per la valutazione.

```
HookContext:
  AwsAccountId: "123456789012"
  StackId: "arn:aws:cloudformation:us-west-2:123456789012:stack/MyStack/1a2345b6-0000-00a0-a123-00abc0abc000"
  HookTypeName: org::s3policy::hook
  HookTypeVersion: "00001"
  InvocationPoint: UPDATE_PRE_PROVISION
  TargetName: AWS::S3::Bucket
  TargetType: RESOURCE
  TargetLogicalId: MyS3Bucket
  ChangeSetId: ""
Resources:
  MyS3Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: amzn-s3-demo-bucket
      ObjectLockEnabled: true
Previous:
  MyS3Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: amzn-s3-demo-bucket
      ObjectLockEnabled: false
```

Per visualizzare tutte le proprietà disponibili per il tipo di risorsa, vedere [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html).

### Regole di protezione per le modifiche alle risorse
<a name="guard-hooks-rules-resource-changes"></a>

Quando un Guard Hook valuta le modifiche alle risorse, inizia scaricando tutte le regole configurate con l'Hook. Queste regole vengono quindi valutate in base all'input delle risorse. L'Hook fallirà se una regola fallisce nella sua valutazione. Se non ci sono errori, l'Hook passerà.

L'esempio seguente è una regola Guard che valuta se la `ObjectLockEnabled` proprietà è `true` per qualsiasi tipo di `AWS::S3::Bucket` risorsa.

```
let s3_buckets_default_lock_enabled = Resources.*[ Type == 'AWS::S3::Bucket']

rule S3_BUCKET_DEFAULT_LOCK_ENABLED when %s3_buckets_default_lock_enabled !empty {
  %s3_buckets_default_lock_enabled.Properties.ObjectLockEnabled exists
  %s3_buckets_default_lock_enabled.Properties.ObjectLockEnabled == true
  <<
    Violation: S3 Bucket ObjectLockEnabled must be set to true.
    Fix: Set the S3 property ObjectLockEnabled parameter to true.
  >>
}
```

Quando questa regola viene eseguita sul seguente input, avrà esito negativo poiché la `ObjectLockEnabled` proprietà non è impostata su. `true`

```
Resources:
  MyS3Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: amzn-s3-demo-bucket 
      ObjectLockEnabled: false
```

Quando questa regola viene eseguita sul seguente input, passerà poiché `ObjectLockEnabled` è impostata su`true`.

```
Resources:
  MyS3Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: amzn-s3-demo-bucket
      ObjectLockEnabled: true
```

Quando un Hook fallisce, le regole che hanno fallito verranno propagate nuovamente alla nostra CloudFormation API Cloud Control. Se è stato configurato un bucket di registrazione per Guard Hook, qui verrà fornito un feedback aggiuntivo sulle regole. Questo feedback aggiuntivo include le informazioni `Violation` e`Fix`.

## Operazione Stack (regole Guard)
<a name="guard-hooks-write-rules-stack-operations"></a>

Quando uno CloudFormation stack viene creato, aggiornato o eliminato, puoi configurare Guard Hook in modo che inizi a valutare il nuovo modello e potenzialmente bloccare il proseguimento dell'operazione sullo stack. Puoi configurare il tuo Guard Hook per indirizzare `STACK` le operazioni nella `TargetOperations` configurazione del tuo Hook.

**Topics**
+ [Sintassi di input Guard Stack](#guard-hooks-write-rules-stack-operations-input)
+ [Esempio di input dell'operazione Guard stack](#guard-hooks-write-rules-stack-operations-example)
+ [Regole Guard per le modifiche allo stack](#guard-hooks-rules-stack-changes)

### Sintassi di input Guard Stack
<a name="guard-hooks-write-rules-stack-operations-input"></a>

L'input per le operazioni dello stack Guard fornisce l'intero CloudFormation modello per la valutazione delle regole di Guard.

Di seguito è riportato un esempio di forma di input dello stack:

```
HookContext:
  AWSAccountID: String
  StackId: String
  HookTypeName: String
  HookTypeVersion: String
  InvocationPoint: [CREATE_PRE_PROVISION, UPDATE_PRE_PROVISION, DELETE_PRE_PROVISION]
  TargetName: String
  TargetType:STACK
  ChangeSetId: String
{Proposed CloudFormation Template}
Previous:
    {CloudFormation Template}
```

`HookContext`  <a name="guard-hook-stack-hookcontext"></a>  
`AWSAccountID`  <a name="guard-hook-stack-awsaccountid"></a>
L'ID del Account AWS contenitore della risorsa.  
`StackId`  <a name="guard-hook-stack-stackid"></a>
L'ID dello CloudFormation stack che fa parte dell'operazione stack.  
`HookTypeName`  <a name="guard-hook-stack-hooktypename"></a>
Il nome dell'Hook in esecuzione.  
`HookTypeVersion`  <a name="guard-hook-stack-hooktypeversion"></a>
La versione dell'Hook in esecuzione.  
`InvocationPoint`  <a name="guard-hook-stack-invocationpoint"></a>
Il punto esatto della logica di provisioning in cui viene eseguito l'Hook.  
*Valori validi*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-stack-targetname"></a>
Il nome dello stack da valutare.  
`TargetType`  <a name="guard-hook-stack-targettype"></a>
Questo valore sarà presente `STACK` quando viene eseguito come Hook a livello di stack.  
`ChangeSetId`  <a name="guard-hook-stack-changesetid"></a>
L'ID del set di modifiche che è stato eseguito per causare la chiamata di Hook. Questo valore è vuoto se l'operazione stack è stata avviata da un'operazione`create-stack`, `update-stack` o. `delete-stack`

`Proposed CloudFormation Template`  <a name="guard-hook-stack-template-current-template"></a>
Il valore completo del CloudFormation modello che è stato passato alle nostre operazioni CloudFormation`create-stack`. `update-stack` Ciò include elementi come `Resources``Outputs`, e`Properties`. Può essere una stringa JSON o YAML a seconda di ciò che è stato fornito. CloudFormation  
Nelle `delete-stack` operazioni, questo valore sarà vuoto.

`Previous`  <a name="guard-hook-stack-template-previous-template"></a>
L'ultimo CloudFormation modello distribuito correttamente. Questo valore è vuoto se lo stack viene creato o eliminato.  
Nelle `delete-stack` operazioni, questo valore sarà vuoto.

**Nota**  
I modelli forniti sono quelli che vengono passati `create` o le operazioni di `update` impilamento. Quando si elimina uno stack, non viene fornito alcun valore di modello.

### Esempio di input dell'operazione Guard stack
<a name="guard-hooks-write-rules-stack-operations-example"></a>

L'input di esempio seguente mostra un Guard Hook che riceverà un modello completo e il modello precedentemente distribuito. Il modello in questo esempio utilizza il formato JSON.

```
HookContext:
  AwsAccountId: 123456789012
  StackId: "arn:aws:cloudformation:us-west-2:123456789012:stack/MyStack/1a2345b6-0000-00a0-a123-00abc0abc000"
  HookTypeName: org::templatechecker::hook
  HookTypeVersion: "00001"
  InvocationPoint: UPDATE_PRE_PROVISION
  TargetName: MyStack
  TargetType: CHANGE_SET
  TargetLogicalId: arn:aws:cloudformation:us-west-2:123456789012:changeSet/SampleChangeSet/1a2345b6-0000-00a0-a123-00abc0abc000
  ChangeSetId: arn:aws:cloudformation:us-west-2:123456789012:changeSet/SampleChangeSet/1a2345b6-0000-00a0-a123-00abc0abc000
Resources: {
   "S3Bucket": {
        "Type": "AWS::S3::Bucket",
        "Properties": {
           "BucketEncryption": {
               "ServerSideEncryptionConfiguration": [ 
                {"ServerSideEncryptionByDefault": 
                    {"SSEAlgorithm": "aws:kms", 
                      "KMSMasterKeyID": "KMS-KEY-ARN" }, 
                      "BucketKeyEnabled": true } 
                ] 
           }
        }
}
Previous: {
    "AWSTemplateFormatVersion": "2010-09-09",
    "Resources": {
        "S3Bucket": {
            "Type": "AWS::S3::Bucket",
            "Properties": {}
        }
    }
}
```

### Regole Guard per le modifiche allo stack
<a name="guard-hooks-rules-stack-changes"></a>

Quando un Guard Hook valuta le modifiche allo stack, inizia scaricando tutte le regole configurate con l'Hook. Queste regole vengono quindi valutate in base all'input delle risorse. L'Hook fallirà se una regola fallisce nella sua valutazione. Se non ci sono errori, l'Hook passerà.

L'esempio seguente è una regola Guard che valuta se esistono tipi di `AWS::S3::Bucket` risorse contenenti una proprietà chiamata`BucketEncryption`, con l'`SSEAlgorithm`impostazione su o`aws:kms`. `AES256`

```
let s3_buckets_s3_default_encryption = Resources.*[ Type == 'AWS::S3::Bucket']

rule S3_DEFAULT_ENCRYPTION_KMS when %s3_buckets_s3_default_encryption !empty {
  %s3_buckets_s3_default_encryption.Properties.BucketEncryption exists
  %s3_buckets_s3_default_encryption.Properties.BucketEncryption.ServerSideEncryptionConfiguration[*].ServerSideEncryptionByDefault.SSEAlgorithm in ["aws:kms","AES256"]
  <<
    Violation: S3 Bucket default encryption must be set.
    Fix: Set the S3 Bucket property BucketEncryption.ServerSideEncryptionConfiguration.ServerSideEncryptionByDefault.SSEAlgorithm to either "aws:kms" or "AES256"
  >>
}
```

Quando la regola viene eseguita sul modello seguente, lo farà`fail`.

```
AWSTemplateFormatVersion: 2010-09-09
Description: S3 bucket without default encryption
Resources:
  EncryptedS3Bucket:
    Type: 'AWS::S3::Bucket'
    Properties:
      BucketName: !Sub 'encryptedbucket-${AWS::Region}-${AWS::AccountId}'
```

Quando la regola viene eseguita sul modello seguente, lo farà`pass`.

```
AWSTemplateFormatVersion: 2010-09-09
Description: S3 bucket with default encryption using SSE-KMS with an S3 Bucket Key
Resources:
  EncryptedS3Bucket:
    Type: 'AWS::S3::Bucket'
    Properties:
      BucketName: !Sub 'encryptedbucket-${AWS::Region}-${AWS::AccountId}'
      BucketEncryption:
        ServerSideEncryptionConfiguration:
          - ServerSideEncryptionByDefault:
              SSEAlgorithm: 'aws:kms'
              KMSMasterKeyID: KMS-KEY-ARN
            BucketKeyEnabled: true
```

## Modifica le regole operative di Guard
<a name="guard-hooks-write-rules-change-set-operations"></a>

Quando viene creato un set di CloudFormation modifiche, è possibile configurare Guard Hook per valutare il modello e le modifiche proposte nel set di modifiche per bloccare l'esecuzione del set di modifiche.

**Topics**
+ [Guard change set (sintassi di input)](#guard-hooks-write-rules-change-set-operations-input)
+ [Esempio: input dell'operazione Guard change set](#guard-hooks-write-rules-change-set-operations-example)
+ [Regola Guard per le operazioni relative ai set di modifiche](#guard-hooks-rules-change-set-operations)

### Guard change set (sintassi di input)
<a name="guard-hooks-write-rules-change-set-operations-input"></a>

L'input del set di modifiche di Guard è costituito dai dati messi a disposizione delle regole di Guard per la valutazione.

Di seguito è riportato un esempio di forma di input di un set di modifiche:

```
HookContext:
  AWSAccountID: String
  StackId: String
  HookTypeName: String
  HookTypeVersion: String
  InvocationPoint: [CREATE_PRE_PROVISION, UPDATE_PRE_PROVISION, DELETE_PRE_PROVISION]
  TargetName: CHANGE_SET
  TargetType:CHANGE_SET
  TargetLogicalId:ChangeSet ID
  ChangeSetId: String
{Proposed CloudFormation Template}
Previous:
  {CloudFormation Template}
Changes: [{ResourceChange}]
```

La sintassi `ResourceChange` del modello è:

```
logicalResourceId: String 
resourceType: String
operazione: CREATE, UPDATE, DELETE
Numero di riga: Number
BeforeContext: JSON String
AfterContext: JSON String
```

`HookContext`  <a name="guard-hook-change-set-hookcontext"></a>  
`AWSAccountID`  <a name="guard-hook-change-set-awsaccountid"></a>
L'ID del Account AWS contenitore della risorsa.  
`StackId`  <a name="guard-hook-change-set-stackid"></a>
L'ID dello CloudFormation stack che fa parte dell'operazione stack.  
`HookTypeName`  <a name="guard-hook-change-set-hooktypename"></a>
Il nome dell'Hook in esecuzione.  
`HookTypeVersion`  <a name="guard-hook-change-set-hooktypeversion"></a>
La versione dell'Hook in esecuzione.  
`InvocationPoint`  <a name="guard-hook-change-set-invocationpoint"></a>
Il punto esatto della logica di provisioning in cui viene eseguito l'Hook.  
*Valori validi*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-change-set-targetname"></a>
Il nome dello stack da valutare.  
`TargetType`  <a name="guard-hook-change-set-targettype"></a>
Questo valore sarà presente `CHANGE_SET` quando viene eseguito come Hook a livello di set di modifiche.  
`TargetLogicalId`  <a name="guard-hook-change-set-targetlogicalid"></a>
Questo valore sarà l'ARN del set di modifiche.  
`ChangeSetId`  <a name="guard-hook-change-set-changesetid"></a>
L'ID del set di modifiche che è stato eseguito per causare la chiamata di Hook. Questo valore è vuoto se l'operazione stack è stata avviata da un'operazione`create-stack`, `update-stack` o. `delete-stack`

`Proposed CloudFormation Template`  <a name="guard-hook-change-set-current-template"></a>
Il CloudFormation modello completo fornito per un'`create-change-set`operazione. Può essere una stringa JSON o YAML a seconda del tipo di stringa fornita. CloudFormation

`Previous`  <a name="guard-hook-change-set-previous-template"></a>
L'ultimo modello distribuito correttamente. CloudFormation Questo valore è vuoto se lo stack viene creato o eliminato.

`Changes`  <a name="guard-hook-change-set-changes"></a>
Il `Changes` modello. Questo elenca le modifiche alle risorse.

Modifiche    
logicalResourceId  <a name="guard-hook-change-set-change-logicalresourceid"></a>
Il nome della risorsa logica della risorsa modificata.  
resourceType  <a name="guard-hook-change-set-change-resourcetype"></a>
Il tipo di risorsa che verrà modificata.  
operazione  <a name="guard-hook-change-set-change-action"></a>
Il tipo di operazione eseguita sulla risorsa.  
*Valori validi*: (`CREATE`\$1 `UPDATE` \$1`DELETE`)  
Numero di riga  <a name="guard-hook-change-set-change-linenumber"></a>
Il numero di riga nel modello associato alla modifica.  
BeforeContext  <a name="guard-hook-change-set-change-beforecontext"></a>
Una stringa JSON di proprietà della risorsa prima della modifica:  

```
{"properties": {"property1": "value"}}
```  
AfterContext  <a name="guard-hook-change-set-change-aftercontext"></a>
Una stringa JSON di proprietà della risorsa dopo la modifica:  

```
{"properties": {"property1": "new value"}}
```

### Esempio: input dell'operazione Guard change set
<a name="guard-hooks-write-rules-change-set-operations-example"></a>

L'input di esempio seguente mostra un Guard Hook che riceverà un modello completo, il modello precedentemente distribuito e un elenco di modifiche alle risorse. Il modello in questo esempio utilizza il formato JSON.

```
HookContext:
  AwsAccountId: "00000000"
  StackId: MyStack
  HookTypeName: org::templatechecker::hook
  HookTypeVersion: "00001"
  InvocationPoint: UPDATE_PRE_PROVISION
  TargetName: my-example-stack
  TargetType:STACK
  TargetLogicalId: arn...:changeSet/change-set
  ChangeSetId: ""
Resources: {
    "S3Bucket": {
       "Type": "AWS::S3::Bucket",
       "Properties": {
           "BucketName": "amzn-s3-demo-bucket",
           "VersioningConfiguration":{
              "Status": "Enabled"
            }                
         }
    }
Previous: {
    "AWSTemplateFormatVersion": "2010-09-09",
    "Resources": {
        "S3Bucket": {
            "Type": "AWS::S3::Bucket",
            "Properties": {
                "BucketName": "amzn-s3-demo-bucket",
                "VersioningConfiguration":{
                  "Status": "Suspended"
                }
            }
        }
    }
}
Changes: [
  {
    "logicalResourceId": "S3Bucket",
    "resourceType": "AWS::S3::Bucket",
    "action": "UPDATE",
    "lineNumber": 5,
    "beforeContext": "{\"Properties\":{\"VersioningConfiguration\":{\"Status\":\"Suspended\"}}}",
    "afterContext": "{\"Properties\":{\"VersioningConfiguration\":{\"Status\":\"Enabled\"}}}"
  }
]
```

### Regola Guard per le operazioni relative ai set di modifiche
<a name="guard-hooks-rules-change-set-operations"></a>

L'esempio seguente è una regola Guard che valuta le modifiche ai bucket Amazon S3 e garantisce `VersionConfiguration` che non sia disabilitata.

```
let s3_buckets_changing = Changes[resourceType == 'AWS::S3::Bucket']

rule S3_VERSIONING_STAY_ENABLED when %s3_buckets_changing !empty {
    let afterContext = json_parse(%s3_buckets_changing.afterContext)
    when %afterContext.Properties.VersioningConfiguration.Status !empty {
        %afterContext.Properties.VersioningConfiguration.Status == 'Enabled'
    }
}
```