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.

# Zuweisen und Referenzieren von Variablen in Guard-Regeln
<a name="variables"></a>

Sie können Ihren AWS CloudFormation Guard Regeldateien Variablen zuweisen, um Informationen zu speichern, auf die Sie in Ihren Guard-Regeln verweisen möchten. Guard unterstützt die einmalige Variablenzuweisung. Variablen werden träge ausgewertet, was bedeutet, dass Guard Variablen nur auswertet, wenn Regeln ausgeführt werden.

**Topics**
+ [Zuweisen von Variablen](#assigning-variables)
+ [Variablen referenzieren](#referencing-variables)
+ [Gültigkeitsbereich der Variablen](#variable-scope)
+ [Beispiele für Variablen in Guard-Regeldateien](#variables-examples)

## Zuweisen von Variablen
<a name="assigning-variables"></a>

Verwenden Sie das `let` Schlüsselwort, um eine Variable zu initialisieren und zuzuweisen. Es hat sich bewährt, Snake-Groß- und Kleinschreibung für Variablennamen zu verwenden. Variablen können statische Literale oder dynamische Eigenschaften speichern, die sich aus Abfragen ergeben. Im folgenden Beispiel `ecs_task_definition_task_role_arn` speichert die Variable den statischen Zeichenkettenwert`arn:aws:iam:123456789012:role/my-role-name`.

```
let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-role-name'
```

Im folgenden Beispiel `ecs_tasks` speichert die Variable die Ergebnisse einer Abfrage, die nach allen `AWS::ECS::TaskDefinition` Ressourcen in einer CloudFormation Vorlage sucht. Sie könnten beim Schreiben von Regeln auf Zugriffsinformationen zu diesen Ressourcen verweisen`ecs_tasks`.

```
let ecs_tasks = Resources.*[
    Type == 'AWS::ECS::TaskDefinition'
]
```

## Variablen referenzieren
<a name="referencing-variables"></a>

Verwenden Sie das `%` Präfix, um auf eine Variable zu verweisen.

Basierend auf dem `ecs_task_definition_task_role_arn` Variablenbeispiel in [Zuweisen von Variablen](#assigning-variables) können Sie `ecs_task_definition_task_role_arn` im `query|value literal` Abschnitt einer Guard-Regelklausel darauf verweisen. Durch die Verwendung dieser Referenz wird sichergestellt, dass es sich bei dem für die `TaskDefinitionArn` Eigenschaft einer beliebigen `AWS::ECS::TaskDefinition` Ressource in einer CloudFormation Vorlage angegebenen Wert um den statischen Zeichenkettenwert handelt`arn:aws:iam:123456789012:role/my-role-name`.

```
Resources.*.Properties.TaskDefinitionArn == %ecs_task_definition_role_arn
```

Basierend auf dem `ecs_tasks` Variablenbeispiel in [Zuweisen von Variablen](#assigning-variables) können Sie `ecs_tasks` in einer Abfrage referenzieren (z. B. %ECS\_Tasks.Properties). Zuerst wertet Guard die Variable aus `ecs_tasks` und verwendet dann die zurückgegebenen Werte, um die Hierarchie zu durchqueren. Wenn die Variable in Werte `ecs_tasks` aufgelöst wird, die keine Zeichenfolge sind, gibt Guard einen Fehler aus.

**Anmerkung**  
Derzeit unterstützt Guard die Referenzierung von Variablen in benutzerdefinierten Fehlermeldungen nicht.

## Gültigkeitsbereich der Variablen
<a name="variable-scope"></a>

Der Gültigkeitsbereich bezieht sich auf die Sichtbarkeit von Variablen, die in einer Regeldatei definiert sind. Ein Variablenname kann innerhalb eines Bereichs nur einmal verwendet werden. Es gibt drei Ebenen, auf denen eine Variable deklariert werden kann, oder drei mögliche Variablenbereiche:
+ **Dateiebene** — In der Regel oben in der Regeldatei deklariert, können Sie Variablen auf Dateiebene in allen Regeln innerhalb der Regeldatei verwenden. Sie sind für die gesamte Datei sichtbar.

  In der folgenden Beispiel-Regeldatei `ecs_task_definition_execution_role_arn` werden die Variablen `ecs_task_definition_task_role_arn` und D auf Dateiebene initialisiert.

  ```
  let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-task-role-name'
  let ecs_task_definition_execution_role_arn = 'arn:aws:iam::123456789012:role/my-execution-role-name'
  
  rule check_ecs_task_definition_task_role_arn
  {
      Resources.*.Properties.TaskRoleArn == %ecs_task_definition_task_role_arn
  }
  
  rule check_ecs_task_definition_execution_role_arn
  {
      Resources.*.Properties.ExecutionRoleArn == %ecs_task_definition_execution_role_arn
  }
  ```
+ **Regelebene** — Innerhalb einer Regel deklariert, sind Variablen auf Regelebene nur für diese spezielle Regel sichtbar. Alle Verweise außerhalb der Regel führen zu einem Fehler.

  In der folgenden Beispiel-Regeldatei `ecs_task_definition_execution_role_arn` werden die Variablen `ecs_task_definition_task_role_arn` und D auf Regelebene initialisiert. `ecs_task_definition_task_role_arn`Sie können nur innerhalb der benannten Regel referenziert werden. `check_ecs_task_definition_task_role_arn` Sie können nur innerhalb der `check_ecs_task_definition_execution_role_arn` benannten Regel auf die `ecs_task_definition_execution_role_arn` Variable verweisen.

  ```
  rule check_ecs_task_definition_task_role_arn
  {
      let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-task-role-name'
      Resources.*.Properties.TaskRoleArn == %ecs_task_definition_task_role_arn
  }
  
  rule check_ecs_task_definition_execution_role_arn
  {
      let ecs_task_definition_execution_role_arn = 'arn:aws:iam::123456789012:role/my-execution-role-name'
      Resources.*.Properties.ExecutionRoleArn == %ecs_task_definition_execution_role_arn
  }
  ```
+ **Blockebene** — Innerhalb eines Blocks, z. B. einer `when` Klausel, deklariert, sind Variablen auf Blockebene nur für diesen bestimmten Block sichtbar. Alle Verweise außerhalb des Blocks führen zu einem Fehler.

  In der folgenden Beispiel-Regeldatei `ecs_task_definition_execution_role_arn` werden die Variablen `ecs_task_definition_task_role_arn` und D auf Blockebene innerhalb des `AWS::ECS::TaskDefinition` Typblocks initialisiert. Sie können nur auf die `ecs_task_definition_execution_role_arn` Variablen `ecs_task_definition_task_role_arn` und innerhalb der `AWS::ECS::TaskDefinition` Typblöcke für ihre jeweiligen Regeln verweisen.

  ```
  rule check_ecs_task_definition_task_role_arn
  {
      AWS::ECS::TaskDefinition
      {
          let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-task-role-name'
          Properties.TaskRoleArn == %ecs_task_definition_task_role_arn
      }
  }
  
  rule check_ecs_task_definition_execution_role_arn
  {
      AWS::ECS::TaskDefinition
      {
          let ecs_task_definition_execution_role_arn = 'arn:aws:iam::123456789012:role/my-execution-role-name'
          Properties.ExecutionRoleArn == %ecs_task_definition_execution_role_arn
      }
  }
  ```

## Beispiele für Variablen in Guard-Regeldateien
<a name="variables-examples"></a>

Die folgenden Abschnitte enthalten Beispiele für die statische und dynamische Zuweisung von Variablen.

### Statische Zuweisung
<a name="assigning-static-variables"></a>

Im Folgenden finden Sie eine CloudFormation Beispielvorlage.

```
Resources:
  EcsTask:
    Type: 'AWS::ECS::TaskDefinition'
    Properties:
      TaskRoleArn: 'arn:aws:iam::123456789012:role/my-role-name'
```

Basierend auf dieser Vorlage können Sie eine Regel mit dem Namen schreiben`check_ecs_task_definition_task_role_arn`, die sicherstellt, dass die `TaskRoleArn` Eigenschaft aller `AWS::ECS::TaskDefinition` Vorlagenressourcen `arn:aws:iam::123456789012:role/my-role-name`

```
rule check_ecs_task_definition_task_role_arn
{
    let ecs_task_definition_task_role_arn = 'arn:aws:iam::123456789012:role/my-role-name'
    Resources.*.Properties.TaskRoleArn == %ecs_task_definition_task_role_arn
}
```

Im Rahmen der Regel können Sie eine aufgerufene Variable initialisieren `ecs_task_definition_task_role_arn` und ihr den statischen Zeichenkettenwert `'arn:aws:iam::123456789012:role/my-role-name'` zuweisen. Die Regelklausel überprüft, ob der für die `TaskRoleArn` Eigenschaft der `EcsTask` Ressource angegebene Wert angegeben wurde, `arn:aws:iam::123456789012:role/my-role-name` indem sie auf die `ecs_task_definition_task_role_arn` Variable im Abschnitt verweist. `query|value literal`

### Dynamische Zuweisung
<a name="example-dynamic-assignment"></a>

Im Folgenden finden Sie eine CloudFormation Beispielvorlage.

```
Resources:
  EcsTask:
    Type: 'AWS::ECS::TaskDefinition'
    Properties:
      TaskRoleArn: 'arn:aws:iam::123456789012:role/my-role-name'
```

Basierend auf dieser Vorlage können Sie eine Variable initialisieren, die `ecs_tasks` im Gültigkeitsbereich der Datei aufgerufen wird, und ihr die Abfrage `Resources.*[ Type == 'AWS::ECS::TaskDefinition'` zuweisen. Guard fragt alle Ressourcen in der Eingabevorlage ab und speichert Informationen über sie in`ecs_tasks`. Sie können auch eine Regel mit dem Namen schreiben`check_ecs_task_definition_task_role_arn`, die sicherstellt, dass die `TaskRoleArn` Eigenschaft aller `AWS::ECS::TaskDefinition` Vorlagenressourcen `arn:aws:iam::123456789012:role/my-role-name`

```
let ecs_tasks = Resources.*[
    Type == 'AWS::ECS::TaskDefinition'
]

rule check_ecs_task_definition_task_role_arn
{
    %ecs_tasks.Properties.TaskRoleArn == 'arn:aws:iam::123456789012:role/my-role-name'
}
```

Die Regelklausel überprüft, ob der für die `TaskRoleArn` Eigenschaft der `EcsTask` Ressource angegebene Wert auf die `ecs_task_definition_task_role_arn` Variable im `query` Abschnitt verweist. `arn:aws:iam::123456789012:role/my-role-name`

### Vorlagenkonfiguration wird erzwungen CloudFormation
<a name="example-3"></a>

Lassen Sie uns ein komplexeres Beispiel für einen Produktionsanwendungsfall durchgehen. In diesem Beispiel schreiben wir Guard-Regeln, um strengere Kontrollen bei der Definition von Amazon ECS-Aufgaben zu gewährleisten.

Im Folgenden finden Sie eine CloudFormation Beispielvorlage.

```
Resources:
  EcsTask:
    Type: 'AWS::ECS::TaskDefinition'
    Properties:
      TaskRoleArn: 
        'Fn::GetAtt': [TaskIamRole, Arn]
      ExecutionRoleArn:
        'Fn::GetAtt': [ExecutionIamRole, Arn]

  TaskIamRole:
    Type: 'AWS::IAM::Role'
    Properties:
      PermissionsBoundary: 'arn:aws:iam::123456789012:policy/MyExamplePolicy'

  ExecutionIamRole:
    Type: 'AWS::IAM::Role'
    Properties:
      PermissionsBoundary: 'arn:aws:iam::123456789012:policy/MyExamplePolicy'
```

Basierend auf dieser Vorlage schreiben wir die folgenden Regeln, um sicherzustellen, dass diese Anforderungen erfüllt werden:
+ Jeder `AWS::ECS::TaskDefinition` Ressource in der Vorlage ist sowohl eine Aufgabenrolle als auch eine Ausführungsrolle zugeordnet.
+ Bei den Aufgabenrollen und Ausführungsrollen handelt es sich um AWS Identity and Access Management (IAM-) Rollen.
+ Die Rollen sind in der Vorlage definiert.
+ Die `PermissionsBoundary` Eigenschaft wird für jede Rolle angegeben.

```
# Select all Amazon ECS task definition resources from the template
let ecs_tasks = Resources.*[
    Type == 'AWS::ECS::TaskDefinition'
]

# Select a subset of task definitions whose specified value for the TaskRoleArn property is an Fn::Gett-retrievable attribute
let task_role_refs = some %ecs_tasks.Properties.TaskRoleArn.'Fn::GetAtt'[0]

# Select a subset of TaskDefinitions whose specified value for the ExecutionRoleArn property is an Fn::Gett-retrievable attribute
let execution_role_refs = some %ecs_tasks.Properties.ExecutionRoleArn.'Fn::GetAtt'[0]

# Verify requirement #1
rule all_ecs_tasks_must_have_task_end_execution_roles 
    when %ecs_tasks !empty 
{
    %ecs_tasks.Properties {
        TaskRoleArn exists
        ExecutionRoleArn exists
    }
}

# Verify requirements #2 and #3
rule all_roles_are_local_and_type_IAM
    when all_ecs_tasks_must_have_task_end_execution_roles
{
    let task_iam_references = Resources.%task_role_refs
    let execution_iam_reference = Resources.%execution_role_refs

    when %task_iam_references !empty {
        %task_iam_references.Type == 'AWS::IAM::Role'
    }

    when %execution_iam_reference !empty {
        %execution_iam_reference.Type == 'AWS::IAM::Role'
    }
}

# Verify requirement #4
rule check_role_have_permissions_boundary
    when all_ecs_tasks_must_have_task_end_execution_roles
{
    let task_iam_references = Resources.%task_role_refs
    let execution_iam_reference = Resources.%execution_role_refs

    when %task_iam_references !empty {
        %task_iam_references.Properties.PermissionsBoundary exists
    }

    when %execution_iam_reference !empty {
        %execution_iam_reference.Properties.PermissionsBoundary exists
    }
}
```