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.
# Blöcke mit benannten Regeln verfassen in AWS CloudFormation Guard
Beim Schreiben von Blöcken mit benannten Regeln können Sie die AWS CloudFormation Guard folgenden zwei Kompositionsstile verwenden:
+ Bedingte Abhängigkeit
+ Korrelationale Abhängigkeit
Die Verwendung einer dieser Arten der Abhängigkeitszusammensetzung trägt zur Wiederverwendbarkeit bei und reduziert die Ausführlichkeit und Wiederholungen in Blöcken mit benannten Regeln.
**Topics**
+ [Voraussetzungen](#named-rules-prerequisites)
+ [Zusammensetzung bedingter Abhängigkeiten](#named-rules-conditional-dependency)
+ [Zusammensetzung korrelativer Abhängigkeiten](#named-rules-correlational-dependency)
## Voraussetzungen
[Weitere Informationen zu Blöcken mit benannten Regeln finden Sie unter Regeln schreiben.](writing-rules.md#named-rule-blocks)
## Zusammensetzung bedingter Abhängigkeiten
Bei diesem Kompositionsstil hängt die Auswertung eines `when` Blocks oder eines Blocks mit benannten Regeln bedingt vom Ergebnis der Auswertung eines oder mehrerer anderer Blöcke oder Klauseln mit benannten Regeln ab. Die folgende Beispieldatei mit Guard-Regeln enthält Blöcke mit benannten Regeln, die bedingte Abhängigkeiten veranschaulichen.
```
# Named-rule block, rule_name_A
rule rule_name_A {
Guard_rule_1
Guard_rule_2
...
}
# Example-1, Named-rule block, rule_name_B, takes a conditional dependency on rule_name_A
rule rule_name_B when rule_name_A {
Guard_rule_3
Guard_rule_4
...
}
# Example-2, when block takes a conditional dependency on rule_name_A
when rule_name_A {
Guard_rule_3
Guard_rule_4
...
}
# Example-3, Named-rule block, rule_name_C, takes a conditional dependency on rule_name_A ^ rule_name_B
rule rule_name_C when rule_name_A
rule_name_B {
Guard_rule_3
Guard_rule_4
...
}
# Example-4, Named-rule block, rule_name_D, takes a conditional dependency on (rule_name_A v clause_A) ^ clause_B ^ rule_name_B
rule rule_name_D when rule_name_A OR
clause_A
clause_B
rule_name_B {
Guard_rule_3
Guard_rule_4
...
}
```
`Example-1`Hat in der vorherigen Beispiel-Regeldatei die folgenden möglichen Ergebnisse:
+ Bei der `rule_name_A` Auswertung mit werden `PASS` die von `rule_name_B` eingekapselten Guard-Regeln ausgewertet.
+ Bei der `rule_name_A` Auswertung mit werden die von `FAIL` gekapselten Guard-Regeln nicht ausgewertet. `rule_name_B` `rule_name_B`wird als ausgewertet. `SKIP`
+ Wenn als `rule_name_A` Ergebnis ausgewertet wird`SKIP`, werden die von `rule_name_B` gekapselten Guard-Regeln nicht ausgewertet. `rule_name_B`wird als ausgewertet. `SKIP`
**Anmerkung**
Dieser Fall tritt auf, wenn es `rule_name_A` bedingt von einer Regel abhängt, die als ausgewertet wird `FAIL` und zu einer Auswertung mit führt. `rule_name_A` `SKIP`
Im Folgenden finden Sie ein Beispiel für ein Configuration Management Database (CMDB) -Konfigurationselement aus einem AWS Config Element für Sicherheitsgruppeninformationen für eingehenden und ausgehenden Datenverkehr. Dieses Beispiel veranschaulicht die Zusammensetzung bedingter Abhängigkeiten.
```
rule check_resource_type_and_parameter {
resourceType == /AWS::EC2::SecurityGroup/
InputParameters.TcpBlockedPorts NOT EMPTY
}
rule check_parameter_validity when check_resource_type_and_parameter {
InputParameters.TcpBlockedPorts[*] {
this in r[0,65535]
}
}
rule check_ip_procotol_and_port_range_validity when check_parameter_validity {
let ports = InputParameters.TcpBlockedPorts[*]
#
# select all ipPermission instances that can be reached by ANY IP address
# IPv4 or IPv6 and not UDP
#
let configuration = configuration.ipPermissions[
some ipv4Ranges[*].cidrIp == "0.0.0.0/0" or
some ipv6Ranges[*].cidrIpv6 == "::/0"
ipProtocol != 'udp' ]
when %configuration !empty {
%configuration {
ipProtocol != '-1'
when fromPort exists
toPort exists {
let ip_perm_block = this
%ports {
this < %ip_perm_block.fromPort or
this > %ip_perm_block.toPort
}
}
}
}
}
```
Im vorherigen Beispiel `check_parameter_validity` ist bedingt abhängig von `check_resource_type_and_parameter` und `check_ip_procotol_and_port_range_validity` ist bedingt abhängig von. `check_parameter_validity` Im Folgenden finden Sie ein Konfigurationselement für die Configuration Management Database (CMDB), das den obigen Regeln entspricht.
```
---
version: '1.3'
resourceType: 'AWS::EC2::SecurityGroup'
resourceId: sg-12345678abcdefghi
configuration:
description: Delete-me-after-testing
groupName: good-sg-test-delete-me
ipPermissions:
- fromPort: 172
ipProtocol: tcp
ipv6Ranges: []
prefixListIds: []
toPort: 172
userIdGroupPairs: []
ipv4Ranges:
- cidrIp: 0.0.0.0/0
ipRanges:
- 0.0.0.0/0
- fromPort: 89
ipProtocol: tcp
ipv6Ranges:
- cidrIpv6: '::/0'
prefixListIds: []
toPort: 89
userIdGroupPairs: []
ipv4Ranges:
- cidrIp: 0.0.0.0/0
ipRanges:
- 0.0.0.0/0
ipPermissionsEgress:
- ipProtocol: '-1'
ipv6Ranges: []
prefixListIds: []
userIdGroupPairs: []
ipv4Ranges:
- cidrIp: 0.0.0.0/0
ipRanges:
- 0.0.0.0/0
tags:
- key: Name
value: good-sg-delete-me
vpcId: vpc-0123abcd
InputParameters:
TcpBlockedPorts:
- 3389
- 20
- 110
- 142
- 1434
- 5500
supplementaryConfiguration: {}
resourceTransitionStatus: None
```
## Zusammensetzung korrelativer Abhängigkeiten
Bei diesem Kompositionsstil besteht bei der Auswertung eines `when` Blocks oder eines Blocks mit benannten Regeln eine korrelative Abhängigkeit vom Bewertungsergebnis einer oder mehrerer anderer Guard-Regeln. Korrelationsabhängigkeit kann wie folgt erreicht werden.
```
# Named-rule block, rule_name_A, takes a correlational dependency on all of the Guard rules encapsulated by the named-rule block
rule rule_name_A {
Guard_rule_1
Guard_rule_2
...
}
# when block takes a correlational dependency on all of the Guard rules encapsulated by the when block
when condition {
Guard_rule_1
Guard_rule_2
...
}
```
Sehen Sie sich das folgende Beispiel für eine Guard-Regeldatei an, um die Zusammensetzung korrelativer Abhängigkeiten besser zu verstehen.
```
#
# Allowed valid protocols for AWS::ElasticLoadBalancingV2::Listener resources
#
let allowed_protocols = [ "HTTPS", "TLS" ]
let elbs = Resources.*[ Type == 'AWS::ElasticLoadBalancingV2::Listener' ]
#
# If there are AWS::ElasticLoadBalancingV2::Listener resources present, ensure that they have protocols specified from the
# list of allowed protocols and that the Certificates property is not empty
#
rule ensure_all_elbs_are_secure when %elbs !empty {
%elbs.Properties {
Protocol in %allowed_protocols
Certificates !empty
}
}
#
# In addition to secure settings, ensure that AWS::ElasticLoadBalancingV2::Listener resources are private
#
rule ensure_elbs_are_internal_and_secure when %elbs !empty {
ensure_all_elbs_are_secure
%elbs.Properties.Scheme == 'internal'
}
```
Hat in der vorherigen Regeldatei `ensure_elbs_are_internal_and_secure` eine korrelative Abhängigkeit von. `ensure_all_elbs_are_secure` Im Folgenden finden Sie eine CloudFormation Beispielvorlage, die den vorherigen Regeln entspricht.
```
Resources:
ServiceLBPublicListener46709EAA:
Type: 'AWS::ElasticLoadBalancingV2::Listener'
Properties:
Scheme: internal
Protocol: HTTPS
Certificates:
- CertificateArn: 'arn:aws:acm...'
ServiceLBPublicListener4670GGG:
Type: 'AWS::ElasticLoadBalancingV2::Listener'
Properties:
Scheme: internal
Protocol: HTTPS
Certificates:
- CertificateArn: 'arn:aws:acm...'
```