Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Componer bloques de reglas con nombre en AWS CloudFormation Guard Al escribir bloques de reglas con nombre AWS CloudFormation Guard, puede usar los dos estilos de composición siguientes: + Dependencia condicional + Dependencia correlacional El uso de cualquiera de estos estilos de composición de dependencias ayuda a promover la reutilización y reduce la verbosidad y la repetición en los bloques de reglas nombradas. **Topics** + [Requisitos previos](#named-rules-prerequisites) + [Composición de dependencias condicionales](#named-rules-conditional-dependency) + [Composición de dependencias correlacionales](#named-rules-correlational-dependency) ## Requisitos previos [Obtén más información sobre los bloques de reglas con nombre en Cómo escribir reglas.](writing-rules.md#named-rule-blocks) ## Composición de dependencias condicionales En este estilo de composición, la evaluación de un `when` bloque o bloque de reglas nominadas depende condicionalmente del resultado de la evaluación de uno o más bloques o cláusulas de reglas nombradas. El siguiente archivo de reglas de Guard de ejemplo contiene bloques de reglas con nombres que muestran las dependencias condicionales. ``` # 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 ... } ``` En el ejemplo anterior, el archivo de reglas `Example-1` tiene los siguientes resultados posibles: + Si `rule_name_A` se evalúa así`PASS`, se evalúan las reglas de Guard `rule_name_B` encapsuladas por. + Si `rule_name_A` se evalúa así`FAIL`, las reglas de Guard encapsuladas por `rule_name_B` no se evalúan. `rule_name_B`se evalúa como. `SKIP` + Si `rule_name_A` se evalúa como tal`SKIP`, las reglas de Guard encapsuladas por `rule_name_B` no se evalúan. `rule_name_B`se evalúa como. `SKIP` **nota** Este caso ocurre si depende `rule_name_A` condicionalmente de una regla que evalúa `FAIL` y da como resultado una evaluación de`rule_name_A`. `SKIP` A continuación se muestra un ejemplo de un elemento de configuración de una base de datos de administración de la configuración (CMDB) a partir de un AWS Config elemento para la información de grupos de seguridad de entrada y salida. En este ejemplo se muestra la composición de dependencias condicionales. ``` 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 } } } } } ``` En el ejemplo anterior, `check_parameter_validity` depende condicionalmente de `check_resource_type_and_parameter` y `check_ip_procotol_and_port_range_validity` depende condicionalmente de. `check_parameter_validity` El siguiente es un elemento de configuración de la base de datos de administración de la configuración (CMDB) que cumple con las reglas anteriores. ``` --- 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 ``` ## Composición de dependencias correlacionales En este estilo de composición, la evaluación de un `when` bloque o de un bloque de reglas nominadas tiene una dependencia correlacional del resultado de la evaluación de una o más reglas de Guard distintas. La dependencia correlacional se puede lograr de la siguiente manera. ``` # 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 ... } ``` Para ayudarle a entender la composición de la dependencia correlacional, revise el siguiente ejemplo de un archivo de reglas de 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' } ``` En el archivo de reglas anterior, `ensure_elbs_are_internal_and_secure` tiene una dependencia correlacional de. `ensure_all_elbs_are_secure` A continuación se muestra un ejemplo de CloudFormation plantilla que se ajusta a las reglas anteriores. ``` 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...' ```