Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Schreiben Sie Guard-Regeln, um die Ressourcen für Guard Hooks zu evaluieren
<a name="guard-hooks-write-rules"></a>

AWS CloudFormation Guard ist eine domänenspezifische Open-Source-Sprache (DSL) für allgemeine Zwecke, mit der Sie Policy-as-Code erstellen können. In diesem Thema wird erklärt, wie Sie Guard verwenden, um Beispielregeln zu erstellen, die im Guard Hook ausgeführt werden können, um Operationen automatisch auszuwerten. CloudFormation AWS -Cloud-Control- API Es konzentriert sich auch auf die verschiedenen Arten von Eingaben, die für Ihre Guard-Regeln verfügbar sind, je nachdem, wann Ihr Guard Hook ausgeführt wird. Ein Guard Hook kann so konfiguriert werden, dass er während der folgenden Arten von Vorgängen ausgeführt wird:
+ Ressourcenvorgänge
+ Operationen stapeln
+ Operationen ändern

Weitere Informationen zum Schreiben von Guard-Regeln finden Sie unter AWS CloudFormation Guard Regeln [ schreiben ](https://docs.aws.amazon.com/cfn-guard/latest/ug/writing-rules.html)

**Topics**
+ [Guard-Regeln für den Ressourcenbetrieb](#guard-hooks-write-rules-resource-operations)
+ [Regeln für Stack Operation Guard](#guard-hooks-write-rules-stack-operations)
+ [Ändern Sie die Regeln für Operation Guard](#guard-hooks-write-rules-change-set-operations)

## Guard-Regeln für den Ressourcenbetrieb
<a name="guard-hooks-write-rules-resource-operations"></a>

Jedes Mal, wenn Sie eine Ressource erstellen, aktualisieren oder löschen, wird dies als Ressourcenvorgang betrachtet. Wenn Sie beispielsweise die Aktualisierung eines CloudFormation Stacks ausführen, der eine neue Ressource erstellt, haben Sie einen Ressourcenvorgang abgeschlossen. Wenn Sie eine Ressource mithilfe der Cloud Control API erstellen, aktualisieren oder löschen, wird dies ebenfalls als Ressourcenvorgang betrachtet. Sie können Ihren Guard Hook für Ziele `RESOURCE` und `CLOUD_CONTROL` Operationen in der `TargetOperations` Konfiguration für Ihren Hook konfigurieren. Wenn Ihr Guard Hook eine Ressourcenoperation auswertet, wertet die Guard-Engine eine Ressourceneingabe aus.

**Topics**
+ [Syntax zur Eingabe von Guard-Ressourcen](#guard-hooks-write-rules-resource-operations-input)
+ [Beispiel für eine Guard-Resource-Operationseingabe](#guard-hooks-write-rules-resource-operations-example)
+ [Regeln für Änderungen an Ressourcen schützen](#guard-hooks-rules-resource-changes)

### Syntax zur Eingabe von Guard-Ressourcen
<a name="guard-hooks-write-rules-resource-operations-input"></a>

Die Guard-Ressourceneingabe besteht aus den Daten, die Ihren Guard-Regeln zur Auswertung zur Verfügung gestellt werden.

Im Folgenden finden Sie ein Beispiel für die Form einer Ressourceneingabe:

```
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>
Die ID des Objekts AWS-Konto , das die auszuwertende Ressource enthält.  
`StackId`  <a name="guard-hook-resource-stackid"></a>
Die Stack-ID des CloudFormation Stacks, der Teil der Ressourcenoperation ist. Dies ist leer, wenn der Aufrufer die Cloud Control API ist.  
`HookTypeName`  <a name="guard-hook-resource-hooktypename"></a>
Der Name des Hooks, der gerade läuft.  
`HookTypeVersion`  <a name="guard-hook-resource-hooktypeversion"></a>
Die Version des Hooks, der ausgeführt wird.  
`InvocationPoint`  <a name="guard-hook-resource-invocationpoint"></a>
Der genaue Punkt in der Bereitstellungslogik, an dem der Hook ausgeführt wird.  
*Gültige Werte*: (`CREATE_PRE_PROVISION`\| `UPDATE_PRE_PROVISION` \|`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-resource-targetname"></a>
Der Zieltyp, der ausgewertet wird, `AWS::S3::Bucket` z. B.  
`TargetType`  <a name="guard-hook-resource-targettype"></a>
Der Zieltyp, der evaluiert wird, zum Beispiel`AWS::S3::Bucket`. Für Ressourcen, die mit der Cloud Control API bereitgestellt werden`RESOURCE`, lautet dieser Wert.  
`TargetLogicalId`  <a name="guard-hook-resource-targetlogicalid"></a>
Der Wert `TargetLogicalId` der Ressource, die evaluiert wird. Wenn der Ursprung des Hooks ist CloudFormation, ist dies die logische ID (auch bekannt als logischer Name) der Ressource. Wenn der Ursprung des Hooks die Cloud Control API ist, handelt es sich um einen konstruierten Wert.  
`ChangeSetId`  <a name="guard-hook-resource-changesetid"></a>
Die Änderungssatz-ID, die ausgeführt wurde, um den Hook-Aufruf auszulösen. Dieser Wert ist leer, wenn die Ressourcenänderung von der Cloud Control API oder den `delete-stack` Vorgängen, `create-stack``update-stack`, oder initiiert wurde.

`Resources`  <a name="guard-hook-resource-resources"></a>  
`ResourceLogicalID`  <a name="guard-hook-resource-current-resourcelogicalid"></a>
Wenn der Vorgang von initiiert wird CloudFormation, `ResourceLogicalID` ist das die logische ID der Ressource in der CloudFormation Vorlage.  
Wenn der Vorgang von der Cloud Control API initiiert wird, `ResourceLogicalID` handelt es sich um eine Kombination aus Ressourcentyp, Name, Vorgangs-ID und Anforderungs-ID.  
`ResourceType`  <a name="guard-hook-resource-current-resourcetype"></a>
Der Typname der Ressource (Beispiel:`AWS::S3::Bucket`).  
`ResourceProperties`  <a name="guard-hook-resource-current-resourceproperties"></a>
Die vorgeschlagenen Eigenschaften der Ressource, die geändert wird. Wenn der Guard Hook gegen die CloudFormation Ressourcenänderungen ausgeführt wird, werden alle Funktionen, Parameter und Transformationen vollständig aufgelöst. Wenn die Ressource gelöscht wird, ist dieser Wert leer.

`Previous`  <a name="guard-hook-resource-previous"></a>  
`ResourceLogicalID`  <a name="guard-hook-resource-previous-resourcelogicalid"></a>
Wenn der Vorgang von initiiert wird CloudFormation, `ResourceLogicalID` ist das die logische ID der Ressource in der CloudFormation Vorlage.  
Wenn der Vorgang von der Cloud Control API initiiert wird, `ResourceLogicalID` handelt es sich um eine Kombination aus Ressourcentyp, Name, Vorgangs-ID und Anforderungs-ID.  
`ResourceType`  <a name="guard-hook-resource-previous-resourcetype"></a>
Der Typname der Ressource (Beispiel:`AWS::S3::Bucket`).  
`ResourceProperties`  <a name="guard-hook-resource-previous-resourceproperties"></a>
Die aktuellen Eigenschaften, die der Ressource zugeordnet sind, die geändert wird. Wenn die Ressource gelöscht wird, ist dieser Wert leer.

### Beispiel für eine Guard-Resource-Operationseingabe
<a name="guard-hooks-write-rules-resource-operations-example"></a>

Die folgende Beispieleingabe zeigt einen Guard-Hook, der die Definition der zu aktualisierenden `AWS::S3::Bucket` Ressource erhält. Dies sind die Daten, die Guard zur Auswertung zur Verfügung stehen.

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

Alle für den Ressourcentyp verfügbaren Eigenschaften finden Sie unter [AWS::S3::Bucket](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html).

### Regeln für Änderungen an Ressourcen schützen
<a name="guard-hooks-rules-resource-changes"></a>

Wenn ein Guard-Hook Ressourcenänderungen auswertet, lädt er zunächst alle mit dem Hook konfigurierten Regeln herunter. Diese Regeln werden dann anhand der Ressourceneingabe ausgewertet. Der Hook schlägt fehl, wenn Regeln ihre Bewertung nicht bestehen. Wenn es keine Fehler gibt, wird der Hook bestanden.

Das folgende Beispiel ist eine Guard-Regel, die auswertet, ob die `ObjectLockEnabled` Eigenschaft `true` für einen `AWS::S3::Bucket` Ressourcentyp gilt.

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

Wenn diese Regel für die folgende Eingabe ausgeführt wird, schlägt sie fehl, da die `ObjectLockEnabled` Eigenschaft nicht auf `true` festgelegt ist.

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

Wenn diese Regel für die folgende Eingabe ausgeführt wird, ist sie gültig, da die auf gesetzt `ObjectLockEnabled` ist`true`.

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

Wenn ein Hook fehlschlägt, werden die fehlgeschlagenen Regeln zurück an unsere CloudFormation Cloud Control API weitergegeben. Wenn ein Logging-Bucket für den Guard Hook konfiguriert wurde, wird dort zusätzliches Regelfeedback bereitgestellt. Dieses zusätzliche Feedback beinhaltet die `Violation` und `Fix` Informationen.

## Regeln für Stack Operation Guard
<a name="guard-hooks-write-rules-stack-operations"></a>

Wenn ein CloudFormation Stack erstellt, aktualisiert oder gelöscht wird, können Sie Ihren Guard Hook so konfigurieren, dass er mit der Auswertung der neuen Vorlage beginnt und möglicherweise die Fortsetzung des Stack-Vorgangs blockiert. In der Konfiguration für Ihren Hook können Sie Ihren Guard Hook so `TargetOperations` konfigurieren, dass er auf `STACK` Operationen abzielt.

**Topics**
+ [Guard Stack-Eingabesyntax](#guard-hooks-write-rules-stack-operations-input)
+ [Beispiel: Eingabe einer Guard-Stack-Operation](#guard-hooks-write-rules-stack-operations-example)
+ [Schutzregeln für Stack-Änderungen](#guard-hooks-rules-stack-changes)

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

Die Eingabe für Guard-Stack-Operationen stellt die gesamte CloudFormation Vorlage zur Auswertung Ihrer Guard-Regeln bereit.

Das Folgende ist ein Beispiel für die Form einer Stack-Eingabe:

```
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>
Die ID der, die die Ressource AWS-Konto enthält.  
`StackId`  <a name="guard-hook-stack-stackid"></a>
Die Stack-ID des CloudFormation Stacks, der Teil der Stackoperation ist.  
`HookTypeName`  <a name="guard-hook-stack-hooktypename"></a>
Der Name des Hooks, der gerade ausgeführt wird.  
`HookTypeVersion`  <a name="guard-hook-stack-hooktypeversion"></a>
Die Version des Hooks, der ausgeführt wird.  
`InvocationPoint`  <a name="guard-hook-stack-invocationpoint"></a>
Der genaue Punkt in der Bereitstellungslogik, an dem der Hook ausgeführt wird.  
*Gültige Werte*: (`CREATE_PRE_PROVISION`\| `UPDATE_PRE_PROVISION` \|`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-stack-targetname"></a>
Der Name des Stacks, der ausgewertet wird.  
`TargetType`  <a name="guard-hook-stack-targettype"></a>
Dieser Wert wird angegeben, `STACK` wenn er als Hook auf Stackebene ausgeführt wird.  
`ChangeSetId`  <a name="guard-hook-stack-changesetid"></a>
Die Änderungssatz-ID, die ausgeführt wurde, um den Hook-Aufruf auszulösen. Dieser Wert ist leer, wenn der Stack-Vorgang durch eine `create-stack``update-stack`, `delete-stack` OR-Operation initiiert wurde.

`Proposed CloudFormation Template`  <a name="guard-hook-stack-template-current-template"></a>
Der vollständige CloudFormation Vorlagenwert, der an unsere CloudFormation `create-stack` `update-stack` Operationen übergeben wurde. Dazu gehören Dinge wie `Resources``Outputs`, und`Properties`. Es kann eine JSON- oder YAML-Zeichenfolge sein, je nachdem, was bereitgestellt wurde. CloudFormation  
Bei `delete-stack` Operationen ist dieser Wert leer.

`Previous`  <a name="guard-hook-stack-template-previous-template"></a>
Die letzte erfolgreich bereitgestellte CloudFormation Vorlage. Dieser Wert ist leer, wenn der Stapel erstellt oder gelöscht wird.  
Bei `delete-stack` Operationen ist dieser Wert leer.

**Anmerkung**  
Die bereitgestellten Vorlagen sind das, was an `create` oder `update` Stack-Operationen übergeben wird. Beim Löschen eines Stacks werden keine Vorlagenwerte bereitgestellt.

### Beispiel: Eingabe einer Guard-Stack-Operation
<a name="guard-hooks-write-rules-stack-operations-example"></a>

Die folgende Beispieleingabe zeigt einen Guard-Hook, der eine vollständige Vorlage und die zuvor bereitgestellte Vorlage erhält. Die Vorlage in diesem Beispiel verwendet das JSON-Format.

```
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": {}
        }
    }
}
```

### Schutzregeln für Stack-Änderungen
<a name="guard-hooks-rules-stack-changes"></a>

Wenn ein Guard-Hook Stack-Änderungen auswertet, lädt er zunächst alle mit dem Hook konfigurierten Regeln herunter. Diese Regeln werden dann anhand der Ressourceneingabe ausgewertet. Der Hook schlägt fehl, wenn Regeln ihre Bewertung nicht bestehen. Wenn es keine Fehler gibt, wird der Hook bestanden.

Das folgende Beispiel ist eine Guard-Regel, die auswertet, ob es `AWS::S3::Bucket` Ressourcentypen gibt, die eine aufgerufene Eigenschaft enthalten`BucketEncryption`, deren Wert entweder auf `aws:kms` oder `SSEAlgorithm` `AES256` gesetzt ist.

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

Wenn die Regel mit der folgenden Vorlage ausgeführt wird, wird `fail` sie ausgeführt.

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

Wenn die Regel mit der folgenden Vorlage ausgeführt wird, wird sie ausgeführt`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
```

## Ändern Sie die Regeln für Operation Guard
<a name="guard-hooks-write-rules-change-set-operations"></a>

Wenn ein CloudFormation Änderungssatz erstellt wird, können Sie Ihren Guard Hook so konfigurieren, dass die Vorlage und die im Änderungssatz vorgeschlagenen Änderungen ausgewertet werden, um die Ausführung des Änderungssatzes zu blockieren.

**Topics**
+ [Guard-Änderungssatz-Eingabesyntax](#guard-hooks-write-rules-change-set-operations-input)
+ [Beispiel für eine Guard-Change-Set-Operationseingabe](#guard-hooks-write-rules-change-set-operations-example)
+ [Schutzregel für Change-Set-Operationen](#guard-hooks-rules-change-set-operations)

### Guard-Änderungssatz-Eingabesyntax
<a name="guard-hooks-write-rules-change-set-operations-input"></a>

Die Guard-Change-Set-Eingabe besteht aus den Daten, die Ihren Guard-Regeln zur Auswertung zur Verfügung gestellt werden.

Im Folgenden finden Sie ein Beispiel für die Form einer Change-Set-Eingabe:

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

Die `ResourceChange` Modellsyntax lautet:

```
logisch ResourceId: String 
RessourcenTyp: String
action: CREATE, UPDATE, DELETE
Zeilennummer: 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>
Die ID der Ressource AWS-Konto , die die Ressource enthält.  
`StackId`  <a name="guard-hook-change-set-stackid"></a>
Die Stack-ID des CloudFormation Stacks, der Teil der Stackoperation ist.  
`HookTypeName`  <a name="guard-hook-change-set-hooktypename"></a>
Der Name des Hooks, der gerade ausgeführt wird.  
`HookTypeVersion`  <a name="guard-hook-change-set-hooktypeversion"></a>
Die Version des Hooks, der ausgeführt wird.  
`InvocationPoint`  <a name="guard-hook-change-set-invocationpoint"></a>
Der genaue Punkt in der Bereitstellungslogik, an dem der Hook ausgeführt wird.  
*Gültige Werte*: (`CREATE_PRE_PROVISION`\| `UPDATE_PRE_PROVISION` \|`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-change-set-targetname"></a>
Der Name des Stacks, der ausgewertet wird.  
`TargetType`  <a name="guard-hook-change-set-targettype"></a>
Dieser Wert wird angegeben, `CHANGE_SET` wenn er als Hook auf Change-Set-Ebene ausgeführt wird.  
`TargetLogicalId`  <a name="guard-hook-change-set-targetlogicalid"></a>
Dieser Wert wird der ARN des Änderungssatzes sein.  
`ChangeSetId`  <a name="guard-hook-change-set-changesetid"></a>
Die Änderungssatz-ID, die ausgeführt wurde, um den Hook-Aufruf auszulösen. Dieser Wert ist leer, wenn der Stack-Vorgang durch eine `create-stack``update-stack`, `delete-stack` OR-Operation initiiert wurde.

`Proposed CloudFormation Template`  <a name="guard-hook-change-set-current-template"></a>
Die vollständige CloudFormation Vorlage, die für einen `create-change-set` Vorgang bereitgestellt wurde. Es kann sich um eine JSON- oder YAML-Zeichenfolge handeln, je nachdem, was bereitgestellt wurde. CloudFormation

`Previous`  <a name="guard-hook-change-set-previous-template"></a>
Die letzte erfolgreich bereitgestellte CloudFormation Vorlage. Dieser Wert ist leer, wenn der Stapel erstellt oder gelöscht wird.

`Changes`  <a name="guard-hook-change-set-changes"></a>
Das `Changes` Modell. Dies listet die Ressourcenänderungen auf.

Änderungen    
logisch ResourceId  <a name="guard-hook-change-set-change-logicalresourceid"></a>
Der logische Ressourcenname der geänderten Ressource.  
RessourcenTyp  <a name="guard-hook-change-set-change-resourcetype"></a>
Der Ressourcentyp, der geändert wird.  
action  <a name="guard-hook-change-set-change-action"></a>
Die Art der Operation, die für die Ressource ausgeführt wird.  
*Gültige Werte*: (`CREATE`\| `UPDATE` \|`DELETE`)  
Zeilennummer  <a name="guard-hook-change-set-change-linenumber"></a>
Die Zeilennummer in der Vorlage, die der Änderung zugeordnet ist.  
BeforeContext  <a name="guard-hook-change-set-change-beforecontext"></a>
Eine JSON-Zeichenfolge mit Eigenschaften der Ressource vor der Änderung:  

```
{"properties": {"property1": "value"}}
```  
AfterContext  <a name="guard-hook-change-set-change-aftercontext"></a>
Eine JSON-Zeichenfolge mit Eigenschaften der Ressource nach der Änderung:  

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

### Beispiel für eine Guard-Change-Set-Operationseingabe
<a name="guard-hooks-write-rules-change-set-operations-example"></a>

Die folgende Beispieleingabe zeigt einen Guard-Hook, der eine vollständige Vorlage, die zuvor bereitgestellte Vorlage und eine Liste von Ressourcenänderungen erhält. Die Vorlage in diesem Beispiel verwendet das JSON-Format.

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

### Schutzregel für Change-Set-Operationen
<a name="guard-hooks-rules-change-set-operations"></a>

Das folgende Beispiel ist eine Guard-Regel, die Änderungen an Amazon S3-Buckets auswertet und sicherstellt, dass diese `VersionConfiguration` nicht deaktiviert werden.

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