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.

# Rédiger des règles de garde pour évaluer les ressources pour Guard Hooks
<a name="guard-hooks-write-rules"></a>

AWS CloudFormation Guard est un langage spécifique à un domaine (DSL) open source et à usage général que vous pouvez utiliser pour créer. policy-as-code Cette rubrique explique comment utiliser Guard pour créer des exemples de règles qui peuvent être exécutées dans Guard Hook pour une évaluation CloudFormation et API de commande du Cloud AWS des opérations automatiques. Il se concentrera également sur les différents types d'entrées disponibles pour vos règles de garde en fonction du moment où votre crochet de garde fonctionne. Un Guard Hook peut être configuré pour s'exécuter lors des types d'opérations suivants :
+ Opérations de ressources
+ Opérations de pile
+ Modifier les opérations du set

Pour plus d'informations sur la rédaction des règles Guard, voir [AWS CloudFormation Guard Règles d'écriture](https://docs.aws.amazon.com/cfn-guard/latest/ug/writing-rules.html)

**Topics**
+ [Règles relatives à l'exploitation des ressources](#guard-hooks-write-rules-resource-operations)
+ [Règles de Stack Operation Guard](#guard-hooks-write-rules-stack-operations)
+ [Modifier les règles du jeu Operation Guard](#guard-hooks-write-rules-change-set-operations)

## Règles relatives à l'exploitation des ressources
<a name="guard-hooks-write-rules-resource-operations"></a>

Chaque fois que vous créez, mettez à jour ou supprimez une ressource, cela est considéré comme une opération de ressource. Par exemple, si vous exécutez la mise à jour d'une CloudFormation pile qui crée une nouvelle ressource, vous avez terminé une opération sur la ressource. Lorsque vous créez, mettez à jour ou supprimez une ressource à l'aide de l'API Cloud Control, cela est également considéré comme une opération de ressource. Vous pouvez configurer votre Guard Hook en fonction du `RESOURCE` ciblage et `CLOUD_CONTROL` des opérations dans la `TargetOperations` configuration de votre Hook. Lorsque votre Guard Hook évalue une opération de ressource, le moteur Guard évalue une entrée de ressource.

**Topics**
+ [Syntaxe d'entrée des ressources Guard](#guard-hooks-write-rules-resource-operations-input)
+ [Exemple d'entrée d'opération de ressource Guard](#guard-hooks-write-rules-resource-operations-example)
+ [Règles de protection en cas de modification des ressources](#guard-hooks-rules-resource-changes)

### Syntaxe d'entrée des ressources Guard
<a name="guard-hooks-write-rules-resource-operations-input"></a>

Les ressources d'entrée du Guard sont les données mises à la disposition de vos règles Guard à des fins d'évaluation.

Voici un exemple de forme d'entrée de ressource :

```
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>
ID du Compte AWS contenant la ressource en cours d'évaluation.  
`StackId`  <a name="guard-hook-resource-stackid"></a>
L'ID de pile de la CloudFormation pile qui fait partie de l'opération de ressource. Ce champ est vide si l'appelant est l'API Cloud Control.  
`HookTypeName`  <a name="guard-hook-resource-hooktypename"></a>
Le nom du Hook en cours d'exécution.  
`HookTypeVersion`  <a name="guard-hook-resource-hooktypeversion"></a>
Version du Hook en cours d'exécution.  
`InvocationPoint`  <a name="guard-hook-resource-invocationpoint"></a>
Point exact de la logique de provisionnement où le Hook s'exécute.  
*Valeurs valides* : (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-resource-targetname"></a>
Le type de cible évalué, par exemple,`AWS::S3::Bucket`.  
`TargetType`  <a name="guard-hook-resource-targettype"></a>
Le type de cible évalué, par exemple`AWS::S3::Bucket`. Pour les ressources fournies avec l'API Cloud Control, cette valeur sera`RESOURCE`.  
`TargetLogicalId`  <a name="guard-hook-resource-targetlogicalid"></a>
Le `TargetLogicalId` de la ressource en cours d'évaluation. Si l'origine du Hook est CloudFormation, il s'agira de l'ID logique (également appelé nom logique) de la ressource. Si l'origine du Hook est l'API Cloud Control, il s'agira d'une valeur construite.  
`ChangeSetId`  <a name="guard-hook-resource-changesetid"></a>
L'ID de l'ensemble de modifications qui a été exécuté pour provoquer l'invocation du Hook. Cette valeur est vide si le changement de ressource a été initié par l'API Cloud Control ou par les `delete-stack` opérations `create-stack``update-stack`, ou.

`Resources`  <a name="guard-hook-resource-resources"></a>  
`ResourceLogicalID`  <a name="guard-hook-resource-current-resourcelogicalid"></a>
Lorsque l'opération est initiée par CloudFormation, `ResourceLogicalID` il s'agit de l'ID logique de la ressource dans le CloudFormation modèle.  
Lorsque l'opération est initiée par l'API Cloud Control, `ResourceLogicalID` il s'agit d'une combinaison du type de ressource, du nom, de l'ID de l'opération et de l'ID de demande.  
`ResourceType`  <a name="guard-hook-resource-current-resourcetype"></a>
Le nom du type de la ressource (exemple :`AWS::S3::Bucket`).  
`ResourceProperties`  <a name="guard-hook-resource-current-resourceproperties"></a>
Les propriétés proposées pour la ressource en cours de modification. Lorsque le Guard Hook s'exécute contre les modifications CloudFormation des ressources, toutes les fonctions, tous les paramètres et toutes les transformations seront entièrement résolus. Si la ressource est supprimée, cette valeur sera vide.

`Previous`  <a name="guard-hook-resource-previous"></a>  
`ResourceLogicalID`  <a name="guard-hook-resource-previous-resourcelogicalid"></a>
Lorsque l'opération est initiée par CloudFormation, `ResourceLogicalID` il s'agit de l'ID logique de la ressource dans le CloudFormation modèle.  
Lorsque l'opération est initiée par l'API Cloud Control, `ResourceLogicalID` il s'agit d'une combinaison du type de ressource, du nom, de l'ID de l'opération et de l'ID de demande.  
`ResourceType`  <a name="guard-hook-resource-previous-resourcetype"></a>
Le nom du type de la ressource (exemple :`AWS::S3::Bucket`).  
`ResourceProperties`  <a name="guard-hook-resource-previous-resourceproperties"></a>
Les propriétés actuelles associées à la ressource en cours de modification. Si la ressource est supprimée, cette valeur sera vide.

### Exemple d'entrée d'opération de ressource Guard
<a name="guard-hooks-write-rules-resource-operations-example"></a>

L'exemple d'entrée suivant montre un Guard Hook qui recevra la définition de la `AWS::S3::Bucket` ressource à mettre à jour. Il s'agit des données mises à la disposition de Guard pour évaluation.

```
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
```

Pour voir toutes les propriétés disponibles pour le type de ressource, consultez [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).

### Règles de protection en cas de modification des ressources
<a name="guard-hooks-rules-resource-changes"></a>

Lorsqu'un Guard Hook évalue les modifications des ressources, il commence par télécharger toutes les règles configurées avec le Hook. Ces règles sont ensuite évaluées par rapport à l'entrée de ressources. Le Hook échouera si l'une des règles échoue à son évaluation. S'il n'y a aucun échec, le Hook réussira.

L'exemple suivant est une règle de protection qui évalue si la `ObjectLockEnabled` propriété est `true` destinée à un type de `AWS::S3::Bucket` ressource quelconque.

```
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.
  >>
}
```

Lorsque cette règle est exécutée à l'encontre de l'entrée suivante, elle échoue car la `ObjectLockEnabled` propriété n'est pas définie sur`true`.

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

Lorsque cette règle est exécutée à l'encontre de l'entrée suivante, elle est transmise car elle `ObjectLockEnabled` est définie sur`true`.

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

Lorsqu'un Hook échoue, les règles qui ont échoué sont repropagées vers l' CloudFormation API Cloud Control. Si un bucket de journalisation a été configuré pour le Guard Hook, des informations supplémentaires sur les règles y seront fournies. Ces commentaires supplémentaires incluent les `Fix` informations `Violation` et.

## Règles de Stack Operation Guard
<a name="guard-hooks-write-rules-stack-operations"></a>

Lorsqu'une CloudFormation pile est créée, mise à jour ou supprimée, vous pouvez configurer votre Guard Hook pour commencer par évaluer le nouveau modèle et éventuellement empêcher l'opération de pile de se poursuivre. Vous pouvez configurer votre Guard Hook pour cibler `STACK` les opérations dans la `TargetOperations` configuration de votre Hook.

**Topics**
+ [Syntaxe d'entrée Guard Stack](#guard-hooks-write-rules-stack-operations-input)
+ [Exemple d'entrée d'opération Guard Stack](#guard-hooks-write-rules-stack-operations-example)
+ [Règles de protection en cas de changement de pile](#guard-hooks-rules-stack-changes)

### Syntaxe d'entrée Guard Stack
<a name="guard-hooks-write-rules-stack-operations-input"></a>

L'entrée pour les opérations Guard Stack fournit le CloudFormation modèle complet pour l'évaluation de vos règles Guard.

Voici un exemple de forme d'entrée de pile :

```
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 du Compte AWS conteneur de la ressource.  
`StackId`  <a name="guard-hook-stack-stackid"></a>
L'ID de pile de la CloudFormation pile qui fait partie de l'opération de pile.  
`HookTypeName`  <a name="guard-hook-stack-hooktypename"></a>
Le nom du Hook en cours d'exécution.  
`HookTypeVersion`  <a name="guard-hook-stack-hooktypeversion"></a>
Version du Hook en cours d'exécution.  
`InvocationPoint`  <a name="guard-hook-stack-invocationpoint"></a>
Point exact de la logique de provisionnement où le Hook s'exécute.  
*Valeurs valides* : (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-stack-targetname"></a>
Nom de la pile en cours d'évaluation.  
`TargetType`  <a name="guard-hook-stack-targettype"></a>
Cette valeur sera utilisée `STACK` lors de l'exécution en tant que Hook au niveau de la pile.  
`ChangeSetId`  <a name="guard-hook-stack-changesetid"></a>
L'ID de l'ensemble de modifications qui a été exécuté pour provoquer l'invocation du Hook. Cette valeur est vide si l'opération de pile a été initiée par une `delete-stack` opération `create-stack``update-stack`, ou.

`Proposed CloudFormation Template`  <a name="guard-hook-stack-template-current-template"></a>
La valeur complète du CloudFormation modèle qui a été transmise à CloudFormation `create-stack` nos `update-stack` opérations. Cela inclut des éléments tels que `Resources``Outputs`, et`Properties`. Il peut s'agir d'une chaîne JSON ou YAML selon ce qui a été fourni à CloudFormation.  
Dans `delete-stack` les opérations, cette valeur sera vide.

`Previous`  <a name="guard-hook-stack-template-previous-template"></a>
Le dernier CloudFormation modèle déployé avec succès. Cette valeur est vide si la pile est créée ou supprimée.  
Dans `delete-stack` les opérations, cette valeur sera vide.

**Note**  
Les modèles fournis correspondent à ce qui est transmis aux opérations `create` ou aux opérations de `update` pile. Lors de la suppression d'une pile, aucune valeur de modèle n'est fournie.

### Exemple d'entrée d'opération Guard Stack
<a name="guard-hooks-write-rules-stack-operations-example"></a>

L'exemple d'entrée suivant montre un Guard Hook qui recevra un modèle complet et le modèle précédemment déployé. Le modèle de cet exemple utilise le format 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": {}
        }
    }
}
```

### Règles de protection en cas de changement de pile
<a name="guard-hooks-rules-stack-changes"></a>

Lorsqu'un Guard Hook évalue les modifications de pile, il commence par télécharger toutes les règles configurées avec le Hook. Ces règles sont ensuite évaluées par rapport à l'entrée de ressources. Le Hook échouera si l'une des règles échoue à son évaluation. S'il n'y a aucun échec, le Hook réussira.

L'exemple suivant est une règle de protection qui évalue s'il existe des types de `AWS::S3::Bucket` ressources contenant une propriété appelée`BucketEncryption`, avec la valeur `SSEAlgorithm` définie sur `aws:kms` ou`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"
  >>
}
```

Lorsque la règle s'exécute sur le modèle suivant, elle le sera`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}'
```

Lorsque la règle s'exécute sur le modèle suivant, elle le sera`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
```

## Modifier les règles du jeu Operation Guard
<a name="guard-hooks-write-rules-change-set-operations"></a>

Lorsqu'un ensemble de CloudFormation modifications est créé, vous pouvez configurer votre Guard Hook pour évaluer le modèle et les modifications proposées dans l'ensemble de modifications afin de bloquer l'exécution de l'ensemble de modifications.

**Topics**
+ [Syntaxe d'entrée Guard Change Set](#guard-hooks-write-rules-change-set-operations-input)
+ [Exemple d'entrée d'opération du kit Guard Change](#guard-hooks-write-rules-change-set-operations-example)
+ [Règle de protection pour les opérations relatives aux ensembles de modifications](#guard-hooks-rules-change-set-operations)

### Syntaxe d'entrée Guard Change Set
<a name="guard-hooks-write-rules-change-set-operations-input"></a>

Les données entrées dans le set de modifications de Guard sont les données mises à la disposition de vos règles Guard à des fins d'évaluation.

Voici un exemple de forme d'entrée d'un ensemble de modifications :

```
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 syntaxe `ResourceChange` du modèle est la suivante :

```
logicalResourceId: String 
resourceType: String
action: CREATE, UPDATE, DELETE
Numéro de ligne: Number
Avant le contexte: JSON String
Après le contexte: JSON String
```

`HookContext`  <a name="guard-hook-change-set-hookcontext"></a>  
`AWSAccountID`  <a name="guard-hook-change-set-awsaccountid"></a>
L'ID du Compte AWS conteneur de la ressource.  
`StackId`  <a name="guard-hook-change-set-stackid"></a>
L'ID de pile de la CloudFormation pile qui fait partie de l'opération de pile.  
`HookTypeName`  <a name="guard-hook-change-set-hooktypename"></a>
Le nom du Hook en cours d'exécution.  
`HookTypeVersion`  <a name="guard-hook-change-set-hooktypeversion"></a>
Version du Hook en cours d'exécution.  
`InvocationPoint`  <a name="guard-hook-change-set-invocationpoint"></a>
Point exact de la logique de provisionnement où le Hook s'exécute.  
*Valeurs valides* : (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-change-set-targetname"></a>
Nom de la pile en cours d'évaluation.  
`TargetType`  <a name="guard-hook-change-set-targettype"></a>
Cette valeur sera utilisée `CHANGE_SET` lors de l'exécution en tant que Hook au niveau de l'ensemble de modifications.  
`TargetLogicalId`  <a name="guard-hook-change-set-targetlogicalid"></a>
Cette valeur sera l'ARN de l'ensemble de modifications.  
`ChangeSetId`  <a name="guard-hook-change-set-changesetid"></a>
L'ID de l'ensemble de modifications qui a été exécuté pour provoquer l'invocation du Hook. Cette valeur est vide si l'opération de pile a été initiée par une `delete-stack` opération `create-stack``update-stack`, ou.

`Proposed CloudFormation Template`  <a name="guard-hook-change-set-current-template"></a>
 CloudFormation Modèle complet fourni à une `create-change-set` opération. Il peut s'agir d'une chaîne JSON ou YAML selon ce qui a été fourni à CloudFormation.

`Previous`  <a name="guard-hook-change-set-previous-template"></a>
Le dernier CloudFormation modèle déployé avec succès. Cette valeur est vide si la pile est créée ou supprimée.

`Changes`  <a name="guard-hook-change-set-changes"></a>
Le `Changes` modèle. Ceci répertorie les modifications apportées aux ressources.

Modifications    
logicalResourceId  <a name="guard-hook-change-set-change-logicalresourceid"></a>
Nom de ressource logique de la ressource modifiée.  
resourceType  <a name="guard-hook-change-set-change-resourcetype"></a>
Type de ressource qui sera modifié.  
action  <a name="guard-hook-change-set-change-action"></a>
Type d'opération effectuée sur la ressource.  
*Valeurs valides* : (`CREATE`\$1 `UPDATE` \$1`DELETE`)  
Numéro de ligne  <a name="guard-hook-change-set-change-linenumber"></a>
Numéro de ligne du modèle associé à la modification.  
Avant le contexte  <a name="guard-hook-change-set-change-beforecontext"></a>
Une chaîne JSON contenant les propriétés de la ressource avant la modification :  

```
{"properties": {"property1": "value"}}
```  
Après le contexte  <a name="guard-hook-change-set-change-aftercontext"></a>
Une chaîne JSON contenant les propriétés de la ressource après la modification :  

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

### Exemple d'entrée d'opération du kit Guard Change
<a name="guard-hooks-write-rules-change-set-operations-example"></a>

L'exemple d'entrée suivant montre un Guard Hook qui recevra un modèle complet, le modèle précédemment déployé et une liste des modifications apportées aux ressources. Le modèle de cet exemple utilise le format 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\"}}}"
  }
]
```

### Règle de protection pour les opérations relatives aux ensembles de modifications
<a name="guard-hooks-rules-change-set-operations"></a>

L'exemple suivant est une règle Guard qui évalue les modifications apportées aux compartiments Amazon S3 et garantit qu'elles ne `VersionConfiguration` sont pas désactivées.

```
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'
    }
}
```