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

# Escreva regras do Guard para avaliar os recursos do Guard Hooks
<a name="guard-hooks-write-rules"></a>

AWS CloudFormation Guard é uma linguagem específica de domínio (DSL) de código aberto e de uso geral que você pode usar para criar. policy-as-code Este tópico explica como usar o Guard para criar exemplos de regras que podem ser executadas no Guard Hook para avaliar CloudFormation e AWS API Cloud Control operar automaticamente. Também se concentrará nos diferentes tipos de entradas disponíveis para as regras do Guard, dependendo de quando o Guard Hook é executado. Um Guard Hook pode ser configurado para ser executado durante os seguintes tipos de operações:
+ Operações de recurso
+ Operações de empilhamento
+ Alterar as operações do conjunto

Para obter mais informações sobre como escrever regras do Guard, consulte [AWS CloudFormation Guard Regras de redação](https://docs.aws.amazon.com/cfn-guard/latest/ug/writing-rules.html)

**Topics**
+ [Regras do Resource Operation Guard](#guard-hooks-write-rules-resource-operations)
+ [Regras do Stack Operation Guard](#guard-hooks-write-rules-stack-operations)
+ [Alterar as regras do conjunto de operações do Guard](#guard-hooks-write-rules-change-set-operations)

## Regras do Resource Operation Guard
<a name="guard-hooks-write-rules-resource-operations"></a>

Sempre que você cria, atualiza ou exclui um recurso, isso é considerado uma operação de recurso. Por exemplo, se você executar a atualização de uma CloudFormation pilha que cria um novo recurso, você concluiu uma operação de recurso. Quando você cria, atualiza ou exclui um recurso usando a Cloud Control API, isso também é considerado uma operação de recurso. Você pode configurar seu Guard Hook para atingir `RESOURCE` e `CLOUD_CONTROL` operar na `TargetOperations` configuração do seu Hook. Quando seu Guard Hook avalia uma operação de recurso, o mecanismo Guard avalia uma entrada de recurso.

**Topics**
+ [Sintaxe de entrada de recursos do Guard](#guard-hooks-write-rules-resource-operations-input)
+ [Exemplo de entrada de operação de recursos do Guard](#guard-hooks-write-rules-resource-operations-example)
+ [Regras de proteção para mudanças de recursos](#guard-hooks-rules-resource-changes)

### Sintaxe de entrada de recursos do Guard
<a name="guard-hooks-write-rules-resource-operations-input"></a>

A entrada de recursos do Guard são os dados disponibilizados para avaliação das regras do Guard.

Veja a seguir um exemplo de formato de uma entrada de recurso:

```
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>
O ID do Conta da AWS que contém o recurso que está sendo avaliado.  
`StackId`  <a name="guard-hook-resource-stackid"></a>
O ID da pilha que faz parte da operação do recurso. CloudFormation Isso estará vazio se o chamador for a Cloud Control API.  
`HookTypeName`  <a name="guard-hook-resource-hooktypename"></a>
O nome do Hook que está funcionando.  
`HookTypeVersion`  <a name="guard-hook-resource-hooktypeversion"></a>
A versão do Hook que está sendo executada.  
`InvocationPoint`  <a name="guard-hook-resource-invocationpoint"></a>
O ponto exato na lógica de provisionamento em que o Hook é executado.  
*Valores válidos*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-resource-targetname"></a>
O tipo de alvo que está sendo avaliado, por exemplo,`AWS::S3::Bucket`.  
`TargetType`  <a name="guard-hook-resource-targettype"></a>
O tipo de alvo que está sendo avaliado, por exemplo`AWS::S3::Bucket`. Para recursos provisionados com a Cloud Control API, esse valor será. `RESOURCE`  
`TargetLogicalId`  <a name="guard-hook-resource-targetlogicalid"></a>
O `TargetLogicalId` do recurso que está sendo avaliado. Se a origem do Hook for CloudFormation, essa será a ID lógica (também conhecida como nome lógico) do recurso. Se a origem do Hook for a Cloud Control API, esse será um valor construído.  
`ChangeSetId`  <a name="guard-hook-resource-changesetid"></a>
O ID do conjunto de alterações que foi executado para causar a invocação do Hook. Esse valor ficará vazio se a alteração do recurso tiver sido iniciada pela Cloud Control API ou pelas `delete-stack` operações `create-stack``update-stack`, ou.

`Resources`  <a name="guard-hook-resource-resources"></a>  
`ResourceLogicalID`  <a name="guard-hook-resource-current-resourcelogicalid"></a>
Quando a operação é iniciada por CloudFormation, `ResourceLogicalID` é a ID lógica do recurso no CloudFormation modelo.  
Quando a operação é iniciada pela Cloud Control API, `ResourceLogicalID` é uma combinação do tipo de recurso, nome, ID da operação e ID da solicitação.  
`ResourceType`  <a name="guard-hook-resource-current-resourcetype"></a>
O nome do tipo do recurso (exemplo:`AWS::S3::Bucket`).  
`ResourceProperties`  <a name="guard-hook-resource-current-resourceproperties"></a>
As propriedades propostas do recurso que está sendo modificado. Quando o Guard Hook estiver em execução contra as alterações do CloudFormation recurso, todas as funções, parâmetros e transformações serão totalmente resolvidos. Se o recurso estiver sendo excluído, esse valor ficará vazio.

`Previous`  <a name="guard-hook-resource-previous"></a>  
`ResourceLogicalID`  <a name="guard-hook-resource-previous-resourcelogicalid"></a>
Quando a operação é iniciada por CloudFormation, `ResourceLogicalID` é a ID lógica do recurso no CloudFormation modelo.  
Quando a operação é iniciada pela Cloud Control API, `ResourceLogicalID` é uma combinação do tipo de recurso, nome, ID da operação e ID da solicitação.  
`ResourceType`  <a name="guard-hook-resource-previous-resourcetype"></a>
O nome do tipo do recurso (exemplo:`AWS::S3::Bucket`).  
`ResourceProperties`  <a name="guard-hook-resource-previous-resourceproperties"></a>
As propriedades atuais associadas ao recurso que está sendo modificado. Se o recurso estiver sendo excluído, esse valor ficará vazio.

### Exemplo de entrada de operação de recursos do Guard
<a name="guard-hooks-write-rules-resource-operations-example"></a>

O exemplo de entrada a seguir mostra um Guard Hook que receberá a definição do `AWS::S3::Bucket` recurso a ser atualizado. Esses são os dados disponíveis para o Guard para avaliação.

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

Para ver todas as propriedades disponíveis para o tipo de recurso, consulte [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).

### Regras de proteção para mudanças de recursos
<a name="guard-hooks-rules-resource-changes"></a>

Quando um Guard Hook avalia as alterações de recursos, ele começa baixando todas as regras configuradas com o Hook. Essas regras são então avaliadas em relação à entrada do recurso. O Hook falhará se alguma regra falhar em sua avaliação. Se não houver falhas, o Hook passará.

O exemplo a seguir é uma regra do Guard que avalia se a `ObjectLockEnabled` propriedade é `true` para algum tipo de `AWS::S3::Bucket` recurso.

```
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 essa regra é executada na entrada a seguir, ela falhará, pois a `ObjectLockEnabled` propriedade não está definida como`true`.

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

Quando essa regra for executada na entrada a seguir, ela será aprovada desde que `ObjectLockEnabled` esteja definida como`true`.

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

Quando um Hook falha, as regras que falharam serão propagadas de volta para a CloudFormation API Cloud Control. Se um bucket de registro tiver sido configurado para o Guard Hook, um feedback adicional sobre as regras será fornecido lá. Esse feedback adicional inclui `Violation` as `Fix` informações e.

## Regras do Stack Operation Guard
<a name="guard-hooks-write-rules-stack-operations"></a>

Quando uma CloudFormation pilha é criada, atualizada ou excluída, você pode configurar seu Guard Hook para começar avaliando o novo modelo e potencialmente impedir que a operação da pilha continue. Você pode configurar seu Guard Hook para direcionar `STACK` as operações na `TargetOperations` configuração do seu Hook.

**Topics**
+ [Sintaxe de entrada da pilha de proteção](#guard-hooks-write-rules-stack-operations-input)
+ [Exemplo de entrada de operação da pilha de proteção](#guard-hooks-write-rules-stack-operations-example)
+ [Regras de proteção para mudanças na pilha](#guard-hooks-rules-stack-changes)

### Sintaxe de entrada da pilha de proteção
<a name="guard-hooks-write-rules-stack-operations-input"></a>

A entrada para as operações de pilha do Guard fornece o CloudFormation modelo completo para avaliação de suas regras do Guard.

Veja a seguir um exemplo de formato de uma entrada de pilha:

```
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>
O ID do Conta da AWS que contém o recurso.  
`StackId`  <a name="guard-hook-stack-stackid"></a>
O ID da pilha que faz parte da operação da CloudFormation pilha.  
`HookTypeName`  <a name="guard-hook-stack-hooktypename"></a>
O nome do Hook que está funcionando.  
`HookTypeVersion`  <a name="guard-hook-stack-hooktypeversion"></a>
A versão do Hook que está sendo executada.  
`InvocationPoint`  <a name="guard-hook-stack-invocationpoint"></a>
O ponto exato na lógica de provisionamento em que o Hook é executado.  
*Valores válidos*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-stack-targetname"></a>
O nome da pilha que está sendo avaliada.  
`TargetType`  <a name="guard-hook-stack-targettype"></a>
Esse valor será `STACK` quando executado como um Hook em nível de pilha.  
`ChangeSetId`  <a name="guard-hook-stack-changesetid"></a>
O ID do conjunto de alterações que foi executado para causar a invocação do Hook. Esse valor estará vazio se a operação de pilha tiver sido iniciada por uma `delete-stack` operação `create-stack``update-stack`, ou.

`Proposed CloudFormation Template`  <a name="guard-hook-stack-template-current-template"></a>
O valor completo do CloudFormation modelo que foi passado para CloudFormation `create-stack` nossas `update-stack` operações. Isso inclui coisas como `Resources``Outputs`, `Properties` e. Ela pode ser uma string JSON ou YAML, dependendo do que foi fornecido. CloudFormation  
Nas `delete-stack` operações, esse valor estará vazio.

`Previous`  <a name="guard-hook-stack-template-previous-template"></a>
O último CloudFormation modelo implantado com sucesso. Esse valor estará vazio se a pilha estiver sendo criada ou excluída.  
Nas `delete-stack` operações, esse valor estará vazio.

**nota**  
Os modelos fornecidos são o que é passado para as operações `create` de `update` empilhamento. Ao excluir uma pilha, nenhum valor de modelo é fornecido.

### Exemplo de entrada de operação da pilha de proteção
<a name="guard-hooks-write-rules-stack-operations-example"></a>

O exemplo de entrada a seguir mostra um Guard Hook que receberá um modelo completo e o modelo implantado anteriormente. O modelo neste exemplo está usando o 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": {}
        }
    }
}
```

### Regras de proteção para mudanças na pilha
<a name="guard-hooks-rules-stack-changes"></a>

Quando um Guard Hook avalia as mudanças na pilha, ele começa baixando todas as regras configuradas com o Hook. Essas regras são então avaliadas em relação à entrada do recurso. O Hook falhará se alguma regra falhar em sua avaliação. Se não houver falhas, o Hook passará.

O exemplo a seguir é uma regra do Guard que avalia se há algum tipo de `AWS::S3::Bucket` recurso contendo uma propriedade chamada`BucketEncryption`, com o `SSEAlgorithm` definido como `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"
  >>
}
```

Quando a regra for executada no modelo a seguir, ela funcionará`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 a regra for executada no modelo a seguir, ela funcionará`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
```

## Alterar as regras do conjunto de operações do Guard
<a name="guard-hooks-write-rules-change-set-operations"></a>

Quando um conjunto de CloudFormation alterações é criado, você pode configurar seu Guard Hook para avaliar o modelo e as alterações propostas no conjunto de alterações para bloquear a execução do conjunto de alterações.

**Topics**
+ [Sintaxe de entrada do conjunto de alterações do Guard](#guard-hooks-write-rules-change-set-operations-input)
+ [Exemplo de entrada de operação do conjunto de mudanças de proteção](#guard-hooks-write-rules-change-set-operations-example)
+ [Regra de proteção para operações de conjunto de alterações](#guard-hooks-rules-change-set-operations)

### Sintaxe de entrada do conjunto de alterações do Guard
<a name="guard-hooks-write-rules-change-set-operations-input"></a>

A entrada do conjunto de alterações do Guard são os dados disponibilizados para avaliação das regras do Guard.

Veja a seguir um exemplo de formato de uma entrada do conjunto de alterações:

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

A sintaxe do `ResourceChange` modelo é:

```
logicalResourceId: String 
resourceType: String
ação: CREATE, UPDATE, DELETE
Número da linha: Number
Antes do contexto: JSON String
Depois do contexto: JSON String
```

`HookContext`  <a name="guard-hook-change-set-hookcontext"></a>  
`AWSAccountID`  <a name="guard-hook-change-set-awsaccountid"></a>
O ID do Conta da AWS que contém o recurso.  
`StackId`  <a name="guard-hook-change-set-stackid"></a>
O ID da pilha que faz parte da operação da CloudFormation pilha.  
`HookTypeName`  <a name="guard-hook-change-set-hooktypename"></a>
O nome do Hook que está funcionando.  
`HookTypeVersion`  <a name="guard-hook-change-set-hooktypeversion"></a>
A versão do Hook que está sendo executada.  
`InvocationPoint`  <a name="guard-hook-change-set-invocationpoint"></a>
O ponto exato na lógica de provisionamento em que o Hook é executado.  
*Valores válidos*: (`CREATE_PRE_PROVISION`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-change-set-targetname"></a>
O nome da pilha que está sendo avaliada.  
`TargetType`  <a name="guard-hook-change-set-targettype"></a>
Esse valor será `CHANGE_SET` quando executado como um Hook de nível de conjunto de alterações.  
`TargetLogicalId`  <a name="guard-hook-change-set-targetlogicalid"></a>
Esse valor será o ARN do conjunto de alterações.  
`ChangeSetId`  <a name="guard-hook-change-set-changesetid"></a>
O ID do conjunto de alterações que foi executado para causar a invocação do Hook. Esse valor estará vazio se a operação de pilha tiver sido iniciada por uma `delete-stack` operação `create-stack``update-stack`, ou.

`Proposed CloudFormation Template`  <a name="guard-hook-change-set-current-template"></a>
O CloudFormation modelo completo que foi fornecido para uma `create-change-set` operação. Ela pode ser uma string JSON ou YAML, dependendo do que foi fornecido. CloudFormation

`Previous`  <a name="guard-hook-change-set-previous-template"></a>
O último CloudFormation modelo implantado com sucesso. Esse valor estará vazio se a pilha estiver sendo criada ou excluída.

`Changes`  <a name="guard-hook-change-set-changes"></a>
O `Changes` modelo. Isso lista as alterações nos recursos.

Alterações    
logicalResourceId  <a name="guard-hook-change-set-change-logicalresourceid"></a>
O nome do recurso lógico do recurso alterado.  
resourceType  <a name="guard-hook-change-set-change-resourcetype"></a>
O tipo de recurso que será alterado.  
ação  <a name="guard-hook-change-set-change-action"></a>
O tipo de operação que está sendo executada no recurso.  
*Valores válidos*: (`CREATE`\$1 `UPDATE` \$1`DELETE`)  
Número da linha  <a name="guard-hook-change-set-change-linenumber"></a>
O número da linha no modelo associado à alteração.  
Antes do contexto  <a name="guard-hook-change-set-change-beforecontext"></a>
Uma sequência JSON de propriedades do recurso antes da alteração:  

```
{"properties": {"property1": "value"}}
```  
Depois do contexto  <a name="guard-hook-change-set-change-aftercontext"></a>
Uma sequência JSON de propriedades do recurso após a alteração:  

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

### Exemplo de entrada de operação do conjunto de mudanças de proteção
<a name="guard-hooks-write-rules-change-set-operations-example"></a>

O exemplo de entrada a seguir mostra um Guard Hook que receberá um modelo completo, o modelo implantado anteriormente e uma lista de alterações de recursos. O modelo neste exemplo está usando o 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\"}}}"
  }
]
```

### Regra de proteção para operações de conjunto de alterações
<a name="guard-hooks-rules-change-set-operations"></a>

O exemplo a seguir é uma regra do Guard que avalia as alterações nos buckets do Amazon S3 e garante `VersionConfiguration` que ela não seja desativada.

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