Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Composer des blocs de règles nommées dans AWS CloudFormation Guard
Lorsque vous écrivez des blocs de règles nommées à l'aide de AWS CloudFormation Guard, vous pouvez utiliser les deux styles de composition suivants :
+ Dépendance conditionnelle
+ Dépendance corrélationnelle
L'utilisation de l'un ou l'autre de ces styles de composition des dépendances contribue à promouvoir la réutilisabilité et à réduire la verbosité et la répétition dans les blocs de règles nommés.
**Topics**
+ [Conditions préalables](#named-rules-prerequisites)
+ [Composition des dépendances conditionnelles](#named-rules-conditional-dependency)
+ [Composition des dépendances corrélationnelles](#named-rules-correlational-dependency)
## Conditions préalables
Pour en savoir plus sur les blocs de règles nommés, consultez [Writing rules](writing-rules.md#named-rule-blocks).
## Composition des dépendances conditionnelles
Dans ce style de composition, l'évaluation d'un `when` bloc ou d'un bloc de règles nommées dépend conditionnellement du résultat de l'évaluation d'un ou de plusieurs autres blocs ou clauses de règles nommées. L'exemple de fichier de règles de garde suivant contient des blocs de règles nommées qui illustrent les dépendances conditionnelles.
```
# 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
...
}
```
Dans l'exemple de fichier de règles précédent, `Example-1` les résultats possibles sont les suivants :
+ Si `rule_name_A` la valeur est égale à`PASS`, les règles Guard encapsulées par `rule_name_B` sont évaluées.
+ Si `rule_name_A` la valeur est égale à`FAIL`, les règles Guard encapsulées par ne `rule_name_B` sont pas évaluées. `rule_name_B`évalue à. `SKIP`
+ Si `rule_name_A` la valeur est égale à`SKIP`, les règles Guard encapsulées par ne `rule_name_B` sont pas évaluées. `rule_name_B`évalue à. `SKIP`
**Note**
Ce cas se produit s'il dépend `rule_name_A` conditionnellement d'une règle qui évalue jusqu'à `FAIL` et aboutit à une `rule_name_A` évaluation vers. `SKIP`
Voici un exemple d'élément de configuration d'une base de données de gestion de configuration (CMDB) provenant d'un AWS Config élément contenant des informations sur les groupes de sécurité d'entrée et de sortie. Cet exemple illustre la composition des dépendances conditionnelles.
```
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
}
}
}
}
}
```
Dans l'exemple précédent, `check_parameter_validity` dépend conditionnellement de `check_resource_type_and_parameter` et `check_ip_procotol_and_port_range_validity` dépend conditionnellement de. `check_parameter_validity` Voici un élément de configuration de la base de données de gestion de la configuration (CMDB) conforme aux règles précédentes.
```
---
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
```
## Composition des dépendances corrélationnelles
Dans ce style de composition, l'évaluation d'un `when` bloc ou d'un bloc à règles nommées dépend corrélationnellement du résultat de l'évaluation d'une ou de plusieurs autres règles Guard. La dépendance corrélationnelle peut être obtenue comme suit.
```
# 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
...
}
```
Pour vous aider à comprendre la composition des dépendances corrélationnelles, consultez l'exemple suivant de fichier de règles Guard.
```
#
# 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'
}
```
Dans le fichier de règles précédent, `ensure_elbs_are_internal_and_secure` possède une dépendance corrélationnelle sur. `ensure_all_elbs_are_secure` Voici un exemple de CloudFormation modèle conforme aux règles précédentes.
```
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...'
```