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.

# AWS Config Benutzerdefinierte Richtlinienregeln erstellen
<a name="evaluate-config_develop-rules_cfn-guard"></a>

Sie können AWS Config benutzerdefinierte Richtlinienregeln über die AWS-Managementkonsole AWS CLI, oder AWS Config API erstellen.

## AWS Config Benutzerdefinierte Richtlinienregeln hinzufügen
<a name="config-custom-policy-rules-add"></a>

------
#### [ Using the console ]

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Config Konsole zu [https://console.aws.amazon.com/config/Hause](https://console.aws.amazon.com/config/home).

1. Vergewissern Sie sich im AWS-Managementkonsole Menü, dass die Regionsauswahl auf eine AWS Region eingestellt ist, die AWS Config Regeln unterstützt. Die Liste der unterstützten Regionen finden Sie unter [AWS Config -Regionen und -Endpunkte](https://docs.aws.amazon.com/general/latest/gr/awsconfig.html) im *Allgemeine Amazon Web Services-Referenz*. 

1. Klicken Sie im linken Navigationsbereich auf die Option **Regeln**. 

1. Wählen Sie auf der Seite **Rules (Regeln)** die Option **Add Rule (Regel hinzufügen)** aus. 

1. Wählen Sie auf der Seite **Regeltyp angeben** die Option **Benutzerdefinierte Regel mit Guard erstellen** aus.

1. Auf der Seite **Regel konfigurieren** konfigurieren Sie die Regel, indem Sie die folgenden Schritte ausführen:

   1. Geben Sie unter **Regelname** einen eindeutigen Namen für die Regel ein.

   1. Geben Sie unter **Beschreibung** eine Beschreibung für die Regel ein.

   1. Wählen Sie für die **Guard-Runtime-Version** das Laufzeitsystem für Ihre AWS Config benutzerdefinierte Richtlinienregel aus.

   1. Unter **Regelinhalt** können Sie die benutzerdefinierte Guard-Richtlinie für Ihre Regel angeben. 

   1. Wählen Sie für den **Testmodus** aus, wann Sie im Prozess der Ressourcenerstellung und -verwaltung Ihre Ressourcen bewerten AWS Config möchten. Je nach Regel AWS Config können Sie Ihre Ressourcenkonfigurationen auswerten, bevor eine Ressource bereitgestellt wurde, nachdem eine Ressource bereitgestellt wurde oder beides.

      1. Wählen Sie **Proaktive Auswertung einschalten** aus, damit Auswertungen der Konfigurationseinstellungen Ihrer Ressourcen ausgeführt werden können, bevor diese bereitgestellt werden.

         Nachdem Sie die proaktive Evaluierung aktiviert haben, können Sie mithilfe der [StartResourceEvaluation](https://docs.aws.amazon.com/config/latest/APIReference/API_StartResourceEvaluation.html)API und [GetResourceEvaluationSummary](https://docs.aws.amazon.com/config/latest/APIReference/API_GetResourceEvaluationSummary.html)der API überprüfen, ob die Ressourcen, die Sie in diesen Befehlen angeben, durch die proaktiven Regeln in Ihrem Konto in Ihrer Region als NON\$1COMPLIANT gekennzeichnet werden.

          Weitere Informationen zur Verwendung dieser Befehle finden Sie unter [Evaluieren Ihrer Ressourcen](https://docs.aws.amazon.com/config/latest/developerguide/evaluating-your-resources.html#evaluating-your-resources-proactive) mithilfe von Regeln. AWS Config Eine Liste der verwalteten Regeln, die die proaktive Evaluierung unterstützen, finden Sie unter [Liste der AWS Config verwalteten Regeln nach Testmodus](https://docs.aws.amazon.com/config/latest/developerguide/managed-rules-by-evaluation-mode.html).

      1. Wählen Sie **Detektivische Auswertung einschalten** aus, um die Konfigurationseinstellungen Ihrer vorhandenen Ressourcen auszuwerten.

         Bei der detektiven Evaluierung werden AWS Config benutzerdefinierte Richtlinienregeln durch **Konfigurationsänderungen** initiiert. Diese Option ist vorab ausgewählt.
         +  **Ressourcen**: Wenn eine Ressource, die dem angegebenen Ressourcentyp oder dem Typ und dem Bezeichner entspricht, erstellt, geändert oder gelöscht wird
         +  **Tags**: Wenn eine Ressource mit einem bestimmten angegebenen Tag erstellt, geändert oder gelöscht wird
         +  **Alle Änderungen** — Wenn eine von aufgezeichnete Ressource erstellt, geändert oder gelöscht AWS Config wird.

         AWS Config führt die Auswertung aus, wenn eine Änderung an einer Ressource erkannt wird, die dem Geltungsbereich der Regel entspricht. Sie können den Umfang verwenden, um zu beschränken, welche Ressourcen Auswertungen initiieren. Andernfalls werden Auswertungen initiiert, wenn eine nach der Bereitstellung bereitgestellte Ressource geändert wird.

   1. Unter **Parameter** können Sie die Werte für die bereitgestellten Schlüssel anpassen, falls Ihre Regel Parameter enthält. Ein Parameter ist ein Attribut, über das Ihre Ressourcen verfügen müssen, damit sie als regelkonform gelten.

1. **Überprüfen Sie auf der Seite Überprüfen und erstellen** alle Ihre Auswahlen, bevor Sie die Regel zu Ihrer AWS-Konto hinzufügen.

1. Wenn Sie mit der Überprüfung Ihrer Regeln fertig sind, wählen Sie **Regel hinzufügen** aus.

------
#### [ Using the AWS CLI ]

Verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/configservice/put-config-rule.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-config-rule.html).

Das `Owner`-Feld sollte den Wert `CUSTOM_POLICY` aufweisen. Die folgenden zusätzlichen Felder sind für AWS Config benutzerdefinierte Richtlinienregeln erforderlich:
+ `Runtime`: Das Laufzeitsystem für Ihre AWS Config benutzerdefinierten Policy-Regeln.
+ `PolicyText`: Die Richtliniendefinition, die die Logik für Ihre benutzerdefinierten AWS Config -Richtlinienregeln enthält.
+ `EnableDebugLogDelivery`: Der boolesche Ausdruck zur Aktivierung der Debug-Protokollierung für Ihre AWS Config benutzerdefinierte Policy-Regel. Der Standardwert ist `false`.

------
#### [ Using the API Reference ]

Verwenden Sie die Aktion „[PutConfigRule](https://docs.aws.amazon.com/config/latest/APIReference/API_PutConfigRule.html)“.

Das `Owner`-Feld sollte den Wert `CUSTOM_POLICY` aufweisen. Die folgenden zusätzlichen Felder sind für AWS Config benutzerdefinierte Richtlinienregeln erforderlich:
+ `Runtime`: Das Laufzeitsystem für Ihre AWS Config benutzerdefinierten Policy-Regeln.
+ `PolicyText`: Die Richtliniendefinition, die die Logik für Ihre benutzerdefinierten AWS Config -Richtlinienregeln enthält.
+ `EnableDebugLogDelivery`: Der boolesche Ausdruck zur Aktivierung der Debug-Protokollierung für Ihre AWS Config benutzerdefinierte Policy-Regel. Der Standardwert ist `false`.

------

## Regelinhalt für AWS Config benutzerdefinierte Richtlinienregeln schreiben
<a name="config-custom-policy-rules"></a>

Mit AWS Config benutzerdefinierten Richtlinienregeln können Sie die domänenspezifische Sprache (DSL) von AWS CloudFormation Guard verwenden, um Ressourcenkonfigurationen zu bewerten. Dieses Thema enthält Muster und bewährte Methoden für das Schreiben benutzerdefinierter Richtlinienregeln.

Weitere Informationen zum Schreiben von Regeln mit Guard finden Sie unter [Writing Guard-Regeln](https://docs.aws.amazon.com/cfn-guard/latest/ug/writing-rules.html) im AWS CloudFormation Guard-Benutzerhandbuch und unter den [Betriebsmodi von AWS CloudFormation Guard 2.0](https://github.com/aws-cloudformation/cloudformation-guard/tree/main/guard) im GitHub Guard-Repository.

### Grundlegende Regelstruktur
<a name="config-custom-policy-rules-structure"></a>

Verwenden Sie das folgende Basisformat, um Regeln zu erstellen:

```
# Basic rule format
rule <rule_name> when
    resourceType == "<AWS::Service::Resource>" {
    # Evaluation clauses
}

# Example with filtering
let resources_of_type = Resources.*[ Type == 'AWS::Service::Resource' ]
rule check_resources when %resources_of_type !empty {
    %resources_of_type.configuration.property == expected_value
}
```

### Zentrale Komponenten
<a name="config-custom-policy-rules-components"></a>

configuration  
Enthält den Inhalt für die Ressourcenkonfiguration.

supplementaryConfiguration  
Enthält zusätzliche Inhalte für die Ressourcenkonfiguration. AWS Config gibt dieses Feld für bestimmte Ressourcentypen zurück, um die für das Konfigurationsfeld zurückgegebenen Informationen zu ergänzen.

RessourcenTyp  
AWS Ressourcentyp wird ausgewertet.

resourceId  
Die ID der Ressource (zum Beispiel`sg-xxxxxx`).

accountId  
Die 12-stellige AWS-Konto ID, die der Ressource zugeordnet ist.

### Allgemeine Muster
<a name="config-custom-policy-rules-patterns"></a>

------
#### [ Status checks ]

```
let allowed_status = ['ACTIVE', 'RUNNING']
rule check_resource_status when
    resourceType == "AWS::Service::Resource" {
    configuration.status IN %allowed_status
}
```

------
#### [ Required properties ]

```
rule check_required_properties when
    resourceType == "AWS::Service::Resource" {
    configuration.propertyName exists
    configuration.propertyName is_string  # or is_list, is_struct
}
```

------
#### [ Query blocks ]

```
configuration.Properties {
    property1 exists
    property2 is_string
    property3 IN [allowed_value1, allowed_value2]
}
```

------
#### [ Conditional evaluation ]

```
when configuration.feature_enabled == true {
    configuration.feature_settings exists
    configuration.feature_settings is_struct
}
```

------
#### [ Custom messages ]

```
rule check_compliance when
    resourceType == "AWS::Service::Resource" {
    configuration.property == expected_value <<Custom error message explaining the requirement>>
}}
```

------

### Erweiterte Funktionen
<a name="config-custom-policy-rules-advanced"></a>

------
#### [ Range checks ]

```
rule check_numeric_limits {
    # Inclusive range (lower_limit <= value <= upper_limit)
    configuration.value IN r[minimum_value, maximum_value]  

    # Exclusive range (lower_limit < value < upper_limit)
    configuration.value IN r(exclusive_min, exclusive_max)  

    # Left inclusive, right exclusive (lower_limit <= value < upper_limit)
    configuration.value IN r[minimum_value, exclusive_max)

    # Left exclusive, right inclusive (lower_limit < value <= upper_limit)
    configuration.value IN r(exclusive_min, maximum_value]
}
```

------
#### [ Combining conditions ]

```
# AND conditions (implicit through new lines)
condition_1
condition_2

# OR conditions (explicit)
condition_3 OR
condition_4
```

------
#### [ Chaining rules ]

```
rule check_prerequisites {
    configuration.required_setting exists
}

rule check_details when check_prerequisites {
    configuration.required_setting == expected_value
}
```

------

### Best Practices
<a name="config-custom-policy-rules-best-practices"></a>
+ Verwenden Sie Variablen mit `let` Anweisungen, um die Lesbarkeit zu verbessern.
+ Gruppenbezogene Prüfungen mithilfe benannter Regelblöcke.
+ Fügen Sie beschreibende Kommentare hinzu.
+ Verwenden Sie die entsprechenden Operatoren (`exists`,`is_string`,`is_list`).
+ Verwenden Sie Regex-Muster ohne Berücksichtigung der Groß-/Kleinschreibung.

### Beispiel: dynamodb-pitr-enabled
<a name="config-custom-policy-rules-example"></a>

Das folgende Beispiel zeigt die Richtliniendefinition für eine AWS Config benutzerdefinierte Richtlinienregelversion der verwalteten Regel. AWS Config [dynamodb-pitr-enabled](dynamodb-pitr-enabled.md) Diese Regel prüft, ob für DynamoDB-Tabellen Point-in-Time Recovery aktiviert ist.

```
# Check if DynamoDB tables have Point-in-Time Recovery enabled
let status = ['ACTIVE']

rule tableisactive when
    resourceType == "AWS::DynamoDB::Table" {
    configuration.tableStatus == %status
}

rule checkcompliance when
    resourceType == "AWS::DynamoDB::Table"
    tableisactive {
    let pitr = supplementaryConfiguration.ContinuousBackupsDescription.pointInTimeRecoveryDescription.pointInTimeRecoveryStatus
    %pitr == "ENABLED" <<DynamoDB tables must have Point-in-Time Recovery enabled>>
}
```