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 Ressourcen für Guard Hooks auszuwerten
<a name="guard-hooks-write-rules"></a>

AWS CloudFormation Guard ist eine domänenspezifische Open-Source-Sprache (DSL) für allgemeine Zwecke, die Sie zum Verfassen verwenden können. policy-as-code In diesem Thema wird erklärt, wie Sie Guard verwenden, um Beispielregeln zu erstellen, die im Guard Hook ausgeführt werden können, um automatische Auswertungen CloudFormation und AWS -Cloud-Control- API Operationen durchzuführen. Es wird sich auch auf die verschiedenen Arten von Eingaben konzentrieren, 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
+ Set-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)
+ [Stack Operation Guard-Regeln](#guard-hooks-write-rules-stack-operations)
+ [Ändern Sie die festgelegten Operation-Guard-Regeln](#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 in der `TargetOperations` Konfiguration für Ihren Hook so konfigurieren, dass er auf Ziele `RESOURCE` und `CLOUD_CONTROL` Operationen ausgerichtet ist. Wenn Ihr Guard Hook eine Ressourcenoperation auswertet, bewertet die Guard-Engine eine Ressourceneingabe.

**Topics**
+ [Syntax der Guard-Ressourceneingabe](#guard-hooks-write-rules-resource-operations-input)
+ [Beispiel für eine Eingabe für einen Guard-Ressourcenvorgang](#guard-hooks-write-rules-resource-operations-example)
+ [Regeln für Ressourcenänderungen schützen](#guard-hooks-rules-resource-changes)

### Syntax der Guard-Ressourceneingabe
<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 der Ressource AWS-Konto , die ausgewertet wird, enthält.  
`StackId`  <a name="guard-hook-resource-stackid"></a>
Die Stack-ID des CloudFormation Stacks, der Teil des Ressourcenvorgangs 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`\$1 `UPDATE_PRE_PROVISION` \$1`DELETE_PRE_PROVISION`)  
`TargetName`  <a name="guard-hook-resource-targetname"></a>
Der Zieltyp, der ausgewertet wird, zum Beispiel`AWS::S3::Bucket`.  
`TargetType`  <a name="guard-hook-resource-targettype"></a>
Der Zieltyp, der ausgewertet wird, zum Beispiel`AWS::S3::Bucket`. Für Ressourcen, die mit der Cloud Control API bereitgestellt wurden, lautet dieser Wert. `RESOURCE`  
`TargetLogicalId`  <a name="guard-hook-resource-targetlogicalid"></a>
Der Wert `TargetLogicalId` der Ressource, die bewertet wird. Wenn der Ursprung des Hooks ist CloudFormation, ist dies die logische ID (auch als logischer Name bezeichnet) 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 durch die Cloud Control API oder die `create-stack` `delete-stack` Operationen, oder initiiert wurde. `update-stack`

`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 dies 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 läuft, 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 dies 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 Eingabe für einen Guard-Ressourcenvorgang
<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 empfängt. 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 [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).

### Regeln für Ressourcenänderungen 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 bewertet. 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 beliebigen `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 anhand der folgenden Eingabe ausgeführt wird, schlägt sie fehl, da die `ObjectLockEnabled` Eigenschaft nicht auf `true` gesetzt 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, gilt sie als erfolgreich, 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 `Fix` Informationen `Violation` und.

## Stack Operation Guard-Regeln
<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 zunächst die neue Vorlage auswertet und möglicherweise die Fortsetzung des Stack-Vorgangs blockiert. Sie können Ihren Guard Hook in der `TargetOperations` Konfiguration für Ihren Hook so konfigurieren, dass er auf bestimmte `STACK` Operationen abzielt.

**Topics**
+ [Guard Stack-Eingabesyntax](#guard-hooks-write-rules-stack-operations-input)
+ [Beispiel für die Eingabe einer Guard-Stack-Operation](#guard-hooks-write-rules-stack-operations-example)
+ [Regeln für Stack-Änderungen schützen](#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 bietet die gesamte CloudFormation Vorlage für die Auswertung Ihrer Guard-Regeln.

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 Ressource AWS-Konto , die die Ressource enthält.  
`StackId`  <a name="guard-hook-stack-stackid"></a>
Die Stack-ID des CloudFormation Stacks, der Teil des Stack-Vorgangs ist.  
`HookTypeName`  <a name="guard-hook-stack-hooktypename"></a>
Der Name des Hooks, der gerade läuft.  
`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`\$1 `UPDATE_PRE_PROVISION` \$1`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 verwendet, `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 die Stack-Operation durch eine `create-stack``update-stack`, oder `delete-stack` -Operation initiiert wurde.

`Proposed CloudFormation Template`  <a name="guard-hook-stack-template-current-template"></a>
Der vollständige CloudFormation Vorlagenwert, der an CloudFormation `create-stack` `update-stack` Oder-Operationen übergeben wurde. Dazu gehören Dinge wie `Resources``Outputs`, und`Properties`. Es kann sich um eine JSON- oder YAML-Zeichenfolge handeln, 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 Stack erstellt oder gelöscht wird.  
Bei `delete-stack` Operationen ist dieser Wert leer.

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

### Beispiel für die 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": {}
        }
    }
}
```

### Regeln für Stack-Änderungen schützen
<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 bewertet. 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 Eigenschaft namens enthalten`BucketEncryption`, wobei die Eigenschaft 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 für die folgende 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 für die folgende 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 festgelegten Operation-Guard-Regeln
<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 er die Vorlage und die im Änderungssatz vorgeschlagenen Änderungen auswertet, um die Ausführung des Änderungssatzes zu blockieren.

**Topics**
+ [Eingabesyntax des Guard-Änderungssatzes](#guard-hooks-write-rules-change-set-operations-input)
+ [Beispiel für die Eingabe einer Guard-Change-Set-Operation](#guard-hooks-write-rules-change-set-operations-example)
+ [Schutzregel für Change-Set-Operationen](#guard-hooks-rules-change-set-operations)

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

Bei der Eingabe des Guard-Änderungssatzes handelt es sich um die Daten, die Ihren Guard-Regeln zur Auswertung zur Verfügung gestellt werden.

Im Folgenden finden Sie ein Beispiel für die Form einer Eingabe für einen Änderungssatz:

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

```
logicalResourceId: String 
RessourcenTyp: String
action: CREATE, UPDATE, DELETE
Zeilennummer: Number
BeforeContext: JSON String
Nach dem Kontext: 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 des Stack-Vorgangs ist.  
`HookTypeName`  <a name="guard-hook-change-set-hooktypename"></a>
Der Name des Hooks, der gerade läuft.  
`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`\$1 `UPDATE_PRE_PROVISION` \$1`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 verwendet, `CHANGE_SET` wenn er als Hook auf Change-Set-Ebene ausgeführt wird.  
`TargetLogicalId`  <a name="guard-hook-change-set-targetlogicalid"></a>
Dieser Wert ist der ARN des Änderungssatzes.  
`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 die Stack-Operation durch eine `create-stack``update-stack`, oder `delete-stack` -Operation initiiert wurde.

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

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

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

Änderungen    
logicalResourceId  <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 des Vorgangs, der auf der Ressource ausgeführt wird.  
*Gültige Werte*: (`CREATE`\$1 `UPDATE` \$1`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"}}
```  
Nach dem Kontext  <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 die Eingabe einer Guard-Change-Set-Operation
<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 S3-Buckets auswertet und sicherstellt, dass diese nicht `VersionConfiguration` deaktiviert sind.

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