aws-cdk-lib 2.215.0__py3-none-any.whl → 2.217.0__py3-none-any.whl

aws_cdk/aws_elasticloadbalancingv2/__init__.py

@@ -771,6 +771,28 @@ ipv6_network_target_group = elbv2.NetworkTargetGroup(self, "Ipv6NetworkTargetGro
 )
 ```
 
+### Target Group level health setting for Application Load Balancers and Network Load Balancers
+
+You can set target group health setting at target group level by setting `targetGroupHealth` property.
+
+For more information, see [How Elastic Load Balancing works](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes).
+
+```python
+# vpc: ec2.Vpc
+
+
+target_group = elbv2.ApplicationTargetGroup(self, "TargetGroup",
+    vpc=vpc,
+    port=80,
+    target_group_health=elbv2.TargetGroupHealth(
+        dns_minimum_healthy_target_count=3,
+        dns_minimum_healthy_target_percentage=70,
+        routing_minimum_healthy_target_count=2,
+        routing_minimum_healthy_target_percentage=50
+    )
+)
+```
+
 ## Using Lambda Targets
 
 To use a Lambda Function as a target, use the integration class in the
@@ -3564,6 +3586,7 @@ class BaseNetworkListenerProps:
         "deregistration_delay": "deregistrationDelay",
         "health_check": "healthCheck",
         "ip_address_type": "ipAddressType",
+        "target_group_health": "targetGroupHealth",
         "target_group_name": "targetGroupName",
         "target_type": "targetType",
         "vpc": "vpc",
@@ -3577,6 +3600,7 @@ class BaseTargetGroupProps:
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union["HealthCheck", typing.Dict[builtins.str, typing.Any]]] = None,
         ip_address_type: typing.Optional["TargetGroupIpAddressType"] = None,
+        target_group_health: typing.Optional[typing.Union["TargetGroupHealth", typing.Dict[builtins.str, typing.Any]]] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional["TargetType"] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -3587,6 +3611,7 @@ class BaseTargetGroupProps:
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
         :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
+        :param target_group_health: Configuring target group health. Default: - use default configuration
         :param target_group_name: The name of the target group. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, and must not begin or end with a hyphen. Default: - Automatically generated.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -3619,6 +3644,12 @@ class BaseTargetGroupProps:
                     unhealthy_threshold_count=123
                 ),
                 ip_address_type=elbv2.TargetGroupIpAddressType.IPV4,
+                target_group_health=elbv2.TargetGroupHealth(
+                    dns_minimum_healthy_target_count=123,
+                    dns_minimum_healthy_target_percentage=123,
+                    routing_minimum_healthy_target_count=123,
+                    routing_minimum_healthy_target_percentage=123
+                ),
                 target_group_name="targetGroupName",
                 target_type=elbv2.TargetType.INSTANCE,
                 vpc=vpc
@@ -3626,12 +3657,15 @@ class BaseTargetGroupProps:
         '''
         if isinstance(health_check, dict):
             health_check = HealthCheck(**health_check)
+        if isinstance(target_group_health, dict):
+            target_group_health = TargetGroupHealth(**target_group_health)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__b5e7f5d87f70cb030d7ac44f4637a5d73814a6c8b1c1bff9adf19ede879e36bb)
             check_type(argname="argument cross_zone_enabled", value=cross_zone_enabled, expected_type=type_hints["cross_zone_enabled"])
             check_type(argname="argument deregistration_delay", value=deregistration_delay, expected_type=type_hints["deregistration_delay"])
             check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument ip_address_type", value=ip_address_type, expected_type=type_hints["ip_address_type"])
+            check_type(argname="argument target_group_health", value=target_group_health, expected_type=type_hints["target_group_health"])
             check_type(argname="argument target_group_name", value=target_group_name, expected_type=type_hints["target_group_name"])
             check_type(argname="argument target_type", value=target_type, expected_type=type_hints["target_type"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
@@ -3644,6 +3678,8 @@ class BaseTargetGroupProps:
             self._values["health_check"] = health_check
         if ip_address_type is not None:
             self._values["ip_address_type"] = ip_address_type
+        if target_group_health is not None:
+            self._values["target_group_health"] = target_group_health
         if target_group_name is not None:
             self._values["target_group_name"] = target_group_name
         if target_type is not None:
@@ -3693,6 +3729,17 @@ class BaseTargetGroupProps:
         result = self._values.get("ip_address_type")
         return typing.cast(typing.Optional["TargetGroupIpAddressType"], result)
 
+    @builtins.property
+    def target_group_health(self) -> typing.Optional["TargetGroupHealth"]:
+        '''Configuring target group health.
+
+        :default: - use default configuration
+
+        :see: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes
+        '''
+        result = self._values.get("target_group_health")
+        return typing.cast(typing.Optional["TargetGroupHealth"], result)
+
     @builtins.property
     def target_group_name(self) -> typing.Optional[builtins.str]:
         '''The name of the target group.
@@ -4323,6 +4370,7 @@ class CfnListenerRuleProps:
     jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.CfnLoadBalancerProps",
     jsii_struct_bases=[],
     name_mapping={
+        "enable_capacity_reservation_provision_stabilize": "enableCapacityReservationProvisionStabilize",
         "enable_prefix_for_ipv6_source_nat": "enablePrefixForIpv6SourceNat",
         "enforce_security_group_inbound_rules_on_private_link_traffic": "enforceSecurityGroupInboundRulesOnPrivateLinkTraffic",
         "ip_address_type": "ipAddressType",
@@ -4342,6 +4390,7 @@ class CfnLoadBalancerProps:
     def __init__(
         self,
         *,
+        enable_capacity_reservation_provision_stabilize: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
         enable_prefix_for_ipv6_source_nat: typing.Optional[builtins.str] = None,
         enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.str] = None,
         ip_address_type: typing.Optional[builtins.str] = None,
@@ -4358,6 +4407,7 @@ class CfnLoadBalancerProps:
     ) -> None:
         '''Properties for defining a ``CfnLoadBalancer``.
 
+        :param enable_capacity_reservation_provision_stabilize: Default: - false
         :param enable_prefix_for_ipv6_source_nat: [Network Load Balancers with UDP listeners] Indicates whether to use an IPv6 prefix from each subnet for source NAT. The IP address type must be ``dualstack`` . The default value is ``off`` .
         :param enforce_security_group_inbound_rules_on_private_link_traffic: Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through AWS PrivateLink . The default is ``on`` . You can't configure this property on a Network Load Balancer unless you associated a security group with the load balancer when you created it.
         :param ip_address_type: The IP address type. Internal load balancers must use ``ipv4`` . [Application Load Balancers] The possible values are ``ipv4`` (IPv4 addresses), ``dualstack`` (IPv4 and IPv6 addresses), and ``dualstack-without-public-ipv4`` (public IPv6 addresses and private IPv4 and IPv6 addresses). Application Load Balancer authentication supports IPv4 addresses only when connecting to an Identity Provider (IdP) or Amazon Cognito endpoint. Without a public IPv4 address the load balancer can't complete the authentication process, resulting in HTTP 500 errors. [Network Load Balancers and Gateway Load Balancers] The possible values are ``ipv4`` (IPv4 addresses) and ``dualstack`` (IPv4 and IPv6 addresses).
@@ -4382,6 +4432,7 @@ class CfnLoadBalancerProps:
             from aws_cdk import aws_elasticloadbalancingv2 as elbv2
             
             cfn_load_balancer_props = elbv2.CfnLoadBalancerProps(
+                enable_capacity_reservation_provision_stabilize=False,
                 enable_prefix_for_ipv6_source_nat="enablePrefixForIpv6SourceNat",
                 enforce_security_group_inbound_rules_on_private_link_traffic="enforceSecurityGroupInboundRulesOnPrivateLinkTraffic",
                 ip_address_type="ipAddressType",
@@ -4415,6 +4466,7 @@ class CfnLoadBalancerProps:
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__6b1eb30cea756dc45f625ec82ab8cba6ea31d24595a925a4aabceb7e6605bcde)
+            check_type(argname="argument enable_capacity_reservation_provision_stabilize", value=enable_capacity_reservation_provision_stabilize, expected_type=type_hints["enable_capacity_reservation_provision_stabilize"])
             check_type(argname="argument enable_prefix_for_ipv6_source_nat", value=enable_prefix_for_ipv6_source_nat, expected_type=type_hints["enable_prefix_for_ipv6_source_nat"])
             check_type(argname="argument enforce_security_group_inbound_rules_on_private_link_traffic", value=enforce_security_group_inbound_rules_on_private_link_traffic, expected_type=type_hints["enforce_security_group_inbound_rules_on_private_link_traffic"])
             check_type(argname="argument ip_address_type", value=ip_address_type, expected_type=type_hints["ip_address_type"])
@@ -4429,6 +4481,8 @@ class CfnLoadBalancerProps:
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
             check_type(argname="argument type", value=type, expected_type=type_hints["type"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if enable_capacity_reservation_provision_stabilize is not None:
+            self._values["enable_capacity_reservation_provision_stabilize"] = enable_capacity_reservation_provision_stabilize
         if enable_prefix_for_ipv6_source_nat is not None:
             self._values["enable_prefix_for_ipv6_source_nat"] = enable_prefix_for_ipv6_source_nat
         if enforce_security_group_inbound_rules_on_private_link_traffic is not None:
@@ -4456,6 +4510,18 @@ class CfnLoadBalancerProps:
         if type is not None:
             self._values["type"] = type
 
+    @builtins.property
+    def enable_capacity_reservation_provision_stabilize(
+        self,
+    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+        '''
+        :default: - false
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-loadbalancer.html#cfn-elasticloadbalancingv2-loadbalancer-enablecapacityreservationprovisionstabilize
+        '''
+        result = self._values.get("enable_capacity_reservation_provision_stabilize")
+        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
     @builtins.property
     def enable_prefix_for_ipv6_source_nat(self) -> typing.Optional[builtins.str]:
         '''[Network Load Balancers with UDP listeners] Indicates whether to use an IPv6 prefix from each subnet for source NAT.
@@ -13435,6 +13501,7 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
         "deregistration_delay": "deregistrationDelay",
         "health_check": "healthCheck",
         "ip_address_type": "ipAddressType",
+        "target_group_health": "targetGroupHealth",
         "target_group_name": "targetGroupName",
         "target_type": "targetType",
         "vpc": "vpc",
@@ -13454,6 +13521,7 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
         ip_address_type: typing.Optional["TargetGroupIpAddressType"] = None,
+        target_group_health: typing.Optional[typing.Union["TargetGroupHealth", typing.Dict[builtins.str, typing.Any]]] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional["TargetType"] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -13470,6 +13538,7 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
         :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
+        :param target_group_health: Configuring target group health. Default: - use default configuration
         :param target_group_name: The name of the target group. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, and must not begin or end with a hyphen. Default: - Automatically generated.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -13517,12 +13586,15 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
         '''
         if isinstance(health_check, dict):
             health_check = HealthCheck(**health_check)
+        if isinstance(target_group_health, dict):
+            target_group_health = TargetGroupHealth(**target_group_health)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__5f1086cffe813b24d7b8ff7c124bffc37ca7e22afda9f6af7ad869d92f7c65b2)
             check_type(argname="argument cross_zone_enabled", value=cross_zone_enabled, expected_type=type_hints["cross_zone_enabled"])
             check_type(argname="argument deregistration_delay", value=deregistration_delay, expected_type=type_hints["deregistration_delay"])
             check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument ip_address_type", value=ip_address_type, expected_type=type_hints["ip_address_type"])
+            check_type(argname="argument target_group_health", value=target_group_health, expected_type=type_hints["target_group_health"])
             check_type(argname="argument target_group_name", value=target_group_name, expected_type=type_hints["target_group_name"])
             check_type(argname="argument target_type", value=target_type, expected_type=type_hints["target_type"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
@@ -13543,6 +13615,8 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
             self._values["health_check"] = health_check
         if ip_address_type is not None:
             self._values["ip_address_type"] = ip_address_type
+        if target_group_health is not None:
+            self._values["target_group_health"] = target_group_health
         if target_group_name is not None:
             self._values["target_group_name"] = target_group_name
         if target_type is not None:
@@ -13602,6 +13676,17 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
         result = self._values.get("ip_address_type")
         return typing.cast(typing.Optional["TargetGroupIpAddressType"], result)
 
+    @builtins.property
+    def target_group_health(self) -> typing.Optional["TargetGroupHealth"]:
+        '''Configuring target group health.
+
+        :default: - use default configuration
+
+        :see: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes
+        '''
+        result = self._values.get("target_group_health")
+        return typing.cast(typing.Optional["TargetGroupHealth"], result)
+
     @builtins.property
     def target_group_name(self) -> typing.Optional[builtins.str]:
         '''The name of the target group.
@@ -14845,6 +14930,126 @@ class _TargetGroupBaseProxy(TargetGroupBase):
 typing.cast(typing.Any, TargetGroupBase).__jsii_proxy_class__ = lambda : _TargetGroupBaseProxy
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.TargetGroupHealth",
+    jsii_struct_bases=[],
+    name_mapping={
+        "dns_minimum_healthy_target_count": "dnsMinimumHealthyTargetCount",
+        "dns_minimum_healthy_target_percentage": "dnsMinimumHealthyTargetPercentage",
+        "routing_minimum_healthy_target_count": "routingMinimumHealthyTargetCount",
+        "routing_minimum_healthy_target_percentage": "routingMinimumHealthyTargetPercentage",
+    },
+)
+class TargetGroupHealth:
+    def __init__(
+        self,
+        *,
+        dns_minimum_healthy_target_count: typing.Optional[jsii.Number] = None,
+        dns_minimum_healthy_target_percentage: typing.Optional[jsii.Number] = None,
+        routing_minimum_healthy_target_count: typing.Optional[jsii.Number] = None,
+        routing_minimum_healthy_target_percentage: typing.Optional[jsii.Number] = None,
+    ) -> None:
+        '''Properties for configuring a target group health.
+
+        :param dns_minimum_healthy_target_count: The minimum number of targets that must be healthy for DNS failover. If below this value, mark the zone as unhealthy in DNS. Use 0 for "off". Default: 1
+        :param dns_minimum_healthy_target_percentage: The minimum percentage of targets that must be healthy for DNS failover. If below this value, mark the zone as unhealthy in DNS. Use 0 for "off". Default: 0
+        :param routing_minimum_healthy_target_count: The minimum number of targets that must be healthy for unhealthy state routing. If below this value, send traffic to all targets including unhealthy ones. Default: 1
+        :param routing_minimum_healthy_target_percentage: The minimum percentage of targets that must be healthy for unhealthy state routing. If below this value, send traffic to all targets including unhealthy ones. Use 0 for "off". Default: 0
+
+        :see: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes
+        :exampleMetadata: infused
+
+        Example::
+
+            # vpc: ec2.Vpc
+            
+            
+            target_group = elbv2.ApplicationTargetGroup(self, "TargetGroup",
+                vpc=vpc,
+                port=80,
+                target_group_health=elbv2.TargetGroupHealth(
+                    dns_minimum_healthy_target_count=3,
+                    dns_minimum_healthy_target_percentage=70,
+                    routing_minimum_healthy_target_count=2,
+                    routing_minimum_healthy_target_percentage=50
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__50b92a6e3fb50861786c29f006a421debbe4bf2e446caaef18d21a99c0e35f73)
+            check_type(argname="argument dns_minimum_healthy_target_count", value=dns_minimum_healthy_target_count, expected_type=type_hints["dns_minimum_healthy_target_count"])
+            check_type(argname="argument dns_minimum_healthy_target_percentage", value=dns_minimum_healthy_target_percentage, expected_type=type_hints["dns_minimum_healthy_target_percentage"])
+            check_type(argname="argument routing_minimum_healthy_target_count", value=routing_minimum_healthy_target_count, expected_type=type_hints["routing_minimum_healthy_target_count"])
+            check_type(argname="argument routing_minimum_healthy_target_percentage", value=routing_minimum_healthy_target_percentage, expected_type=type_hints["routing_minimum_healthy_target_percentage"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if dns_minimum_healthy_target_count is not None:
+            self._values["dns_minimum_healthy_target_count"] = dns_minimum_healthy_target_count
+        if dns_minimum_healthy_target_percentage is not None:
+            self._values["dns_minimum_healthy_target_percentage"] = dns_minimum_healthy_target_percentage
+        if routing_minimum_healthy_target_count is not None:
+            self._values["routing_minimum_healthy_target_count"] = routing_minimum_healthy_target_count
+        if routing_minimum_healthy_target_percentage is not None:
+            self._values["routing_minimum_healthy_target_percentage"] = routing_minimum_healthy_target_percentage
+
+    @builtins.property
+    def dns_minimum_healthy_target_count(self) -> typing.Optional[jsii.Number]:
+        '''The minimum number of targets that must be healthy for DNS failover.
+
+        If below this value, mark the zone as unhealthy in DNS.
+        Use 0 for "off".
+
+        :default: 1
+        '''
+        result = self._values.get("dns_minimum_healthy_target_count")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def dns_minimum_healthy_target_percentage(self) -> typing.Optional[jsii.Number]:
+        '''The minimum percentage of targets that must be healthy for DNS failover.
+
+        If below this value, mark the zone as unhealthy in DNS.
+        Use 0 for "off".
+
+        :default: 0
+        '''
+        result = self._values.get("dns_minimum_healthy_target_percentage")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def routing_minimum_healthy_target_count(self) -> typing.Optional[jsii.Number]:
+        '''The minimum number of targets that must be healthy for unhealthy state routing.
+
+        If below this value, send traffic to all targets including unhealthy ones.
+
+        :default: 1
+        '''
+        result = self._values.get("routing_minimum_healthy_target_count")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def routing_minimum_healthy_target_percentage(self) -> typing.Optional[jsii.Number]:
+        '''The minimum percentage of targets that must be healthy for unhealthy state routing.
+
+        If below this value, send traffic to all targets including unhealthy ones.
+        Use 0 for "off".
+
+        :default: 0
+        '''
+        result = self._values.get("routing_minimum_healthy_target_percentage")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "TargetGroupHealth(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.enum(jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.TargetGroupIpAddressType")
 class TargetGroupIpAddressType(enum.Enum):
     '''The IP address type of targets registered with a target group.
@@ -17118,6 +17323,7 @@ class ApplicationLoadBalancerProps(BaseLoadBalancerProps):
         "deregistration_delay": "deregistrationDelay",
         "health_check": "healthCheck",
         "ip_address_type": "ipAddressType",
+        "target_group_health": "targetGroupHealth",
         "target_group_name": "targetGroupName",
         "target_type": "targetType",
         "vpc": "vpc",
@@ -17141,6 +17347,7 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
         ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
+        target_group_health: typing.Optional[typing.Union[TargetGroupHealth, typing.Dict[builtins.str, typing.Any]]] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional[TargetType] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -17161,6 +17368,7 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
         :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
+        :param target_group_health: Configuring target group health. Default: - use default configuration
         :param target_group_name: The name of the target group. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, and must not begin or end with a hyphen. Default: - Automatically generated.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -17196,12 +17404,15 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         '''
         if isinstance(health_check, dict):
             health_check = HealthCheck(**health_check)
+        if isinstance(target_group_health, dict):
+            target_group_health = TargetGroupHealth(**target_group_health)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__0fbf37aa0a91cb985ce7a336a6188364cc38400538c1653e53453287c780e881)
             check_type(argname="argument cross_zone_enabled", value=cross_zone_enabled, expected_type=type_hints["cross_zone_enabled"])
             check_type(argname="argument deregistration_delay", value=deregistration_delay, expected_type=type_hints["deregistration_delay"])
             check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
             check_type(argname="argument ip_address_type", value=ip_address_type, expected_type=type_hints["ip_address_type"])
+            check_type(argname="argument target_group_health", value=target_group_health, expected_type=type_hints["target_group_health"])
             check_type(argname="argument target_group_name", value=target_group_name, expected_type=type_hints["target_group_name"])
             check_type(argname="argument target_type", value=target_type, expected_type=type_hints["target_type"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
@@ -17224,6 +17435,8 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
             self._values["health_check"] = health_check
         if ip_address_type is not None:
             self._values["ip_address_type"] = ip_address_type
+        if target_group_health is not None:
+            self._values["target_group_health"] = target_group_health
         if target_group_name is not None:
             self._values["target_group_name"] = target_group_name
         if target_type is not None:
@@ -17293,6 +17506,17 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         result = self._values.get("ip_address_type")
         return typing.cast(typing.Optional[TargetGroupIpAddressType], result)
 
+    @builtins.property
+    def target_group_health(self) -> typing.Optional[TargetGroupHealth]:
+        '''Configuring target group health.
+
+        :default: - use default configuration
+
+        :see: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes
+        '''
+        result = self._values.get("target_group_health")
+        return typing.cast(typing.Optional[TargetGroupHealth], result)
+
     @builtins.property
     def target_group_name(self) -> typing.Optional[builtins.str]:
         '''The name of the target group.
@@ -21706,6 +21930,7 @@ class CfnLoadBalancer(
         from aws_cdk import aws_elasticloadbalancingv2 as elbv2
         
         cfn_load_balancer = elbv2.CfnLoadBalancer(self, "MyCfnLoadBalancer",
+            enable_capacity_reservation_provision_stabilize=False,
             enable_prefix_for_ipv6_source_nat="enablePrefixForIpv6SourceNat",
             enforce_security_group_inbound_rules_on_private_link_traffic="enforceSecurityGroupInboundRulesOnPrivateLinkTraffic",
             ip_address_type="ipAddressType",
@@ -21743,6 +21968,7 @@ class CfnLoadBalancer(
         scope: _constructs_77d1e7e8.Construct,
         id: builtins.str,
         *,
+        enable_capacity_reservation_provision_stabilize: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
         enable_prefix_for_ipv6_source_nat: typing.Optional[builtins.str] = None,
         enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.str] = None,
         ip_address_type: typing.Optional[builtins.str] = None,
@@ -21760,6 +21986,7 @@ class CfnLoadBalancer(
         '''
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
+        :param enable_capacity_reservation_provision_stabilize: Default: - false
         :param enable_prefix_for_ipv6_source_nat: [Network Load Balancers with UDP listeners] Indicates whether to use an IPv6 prefix from each subnet for source NAT. The IP address type must be ``dualstack`` . The default value is ``off`` .
         :param enforce_security_group_inbound_rules_on_private_link_traffic: Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through AWS PrivateLink . The default is ``on`` . You can't configure this property on a Network Load Balancer unless you associated a security group with the load balancer when you created it.
         :param ip_address_type: The IP address type. Internal load balancers must use ``ipv4`` . [Application Load Balancers] The possible values are ``ipv4`` (IPv4 addresses), ``dualstack`` (IPv4 and IPv6 addresses), and ``dualstack-without-public-ipv4`` (public IPv6 addresses and private IPv4 and IPv6 addresses). Application Load Balancer authentication supports IPv4 addresses only when connecting to an Identity Provider (IdP) or Amazon Cognito endpoint. Without a public IPv4 address the load balancer can't complete the authentication process, resulting in HTTP 500 errors. [Network Load Balancers and Gateway Load Balancers] The possible values are ``ipv4`` (IPv4 addresses) and ``dualstack`` (IPv4 and IPv6 addresses).
@@ -21779,6 +22006,7 @@ class CfnLoadBalancer(
             check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = CfnLoadBalancerProps(
+            enable_capacity_reservation_provision_stabilize=enable_capacity_reservation_provision_stabilize,
             enable_prefix_for_ipv6_source_nat=enable_prefix_for_ipv6_source_nat,
             enforce_security_group_inbound_rules_on_private_link_traffic=enforce_security_group_inbound_rules_on_private_link_traffic,
             ip_address_type=ip_address_type,
@@ -21905,6 +22133,23 @@ class CfnLoadBalancer(
         '''Tag Manager which manages the tags for this resource.'''
         return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))
 
+    @builtins.property
+    @jsii.member(jsii_name="enableCapacityReservationProvisionStabilize")
+    def enable_capacity_reservation_provision_stabilize(
+        self,
+    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "enableCapacityReservationProvisionStabilize"))
+
+    @enable_capacity_reservation_provision_stabilize.setter
+    def enable_capacity_reservation_provision_stabilize(
+        self,
+        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__db326b5431980db555d148f9ae3420eff076c5f4436bcac08ce2f9c7154eefce)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "enableCapacityReservationProvisionStabilize", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="enablePrefixForIpv6SourceNat")
     def enable_prefix_for_ipv6_source_nat(self) -> typing.Optional[builtins.str]:
@@ -24765,6 +25010,7 @@ class NetworkTargetGroup(
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
         ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
+        target_group_health: typing.Optional[typing.Union[TargetGroupHealth, typing.Dict[builtins.str, typing.Any]]] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional[TargetType] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -24782,6 +25028,7 @@ class NetworkTargetGroup(
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
         :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
+        :param target_group_health: Configuring target group health. Default: - use default configuration
         :param target_group_name: The name of the target group. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, and must not begin or end with a hyphen. Default: - Automatically generated.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -24801,6 +25048,7 @@ class NetworkTargetGroup(
             deregistration_delay=deregistration_delay,
             health_check=health_check,
             ip_address_type=ip_address_type,
+            target_group_health=target_group_health,
             target_group_name=target_group_name,
             target_type=target_type,
             vpc=vpc,
@@ -27042,6 +27290,7 @@ class ApplicationTargetGroup(
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
         ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
+        target_group_health: typing.Optional[typing.Union[TargetGroupHealth, typing.Dict[builtins.str, typing.Any]]] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional[TargetType] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -27063,6 +27312,7 @@ class ApplicationTargetGroup(
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
         :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
+        :param target_group_health: Configuring target group health. Default: - use default configuration
         :param target_group_name: The name of the target group. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, and must not begin or end with a hyphen. Default: - Automatically generated.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -27086,6 +27336,7 @@ class ApplicationTargetGroup(
             deregistration_delay=deregistration_delay,
             health_check=health_check,
             ip_address_type=ip_address_type,
+            target_group_health=target_group_health,
             target_group_name=target_group_name,
             target_type=target_type,
             vpc=vpc,
@@ -27897,6 +28148,7 @@ __all__ = [
     "SubnetMapping",
     "TargetGroupAttributes",
     "TargetGroupBase",
+    "TargetGroupHealth",
     "TargetGroupIpAddressType",
     "TargetGroupLoadBalancingAlgorithmType",
     "TargetGroupReference",
@@ -28141,6 +28393,7 @@ def _typecheckingstub__b5e7f5d87f70cb030d7ac44f4637a5d73814a6c8b1c1bff9adf19ede8
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
     ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
+    target_group_health: typing.Optional[typing.Union[TargetGroupHealth, typing.Dict[builtins.str, typing.Any]]] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -28183,6 +28436,7 @@ def _typecheckingstub__ca75076613edf0bf6ade8ee145bc71de34aa66567d90d5721bd40f862
 
 def _typecheckingstub__6b1eb30cea756dc45f625ec82ab8cba6ea31d24595a925a4aabceb7e6605bcde(
     *,
+    enable_capacity_reservation_provision_stabilize: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     enable_prefix_for_ipv6_source_nat: typing.Optional[builtins.str] = None,
     enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.str] = None,
     ip_address_type: typing.Optional[builtins.str] = None,
@@ -28782,6 +29036,7 @@ def _typecheckingstub__5f1086cffe813b24d7b8ff7c124bffc37ca7e22afda9f6af7ad869d92
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
     ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
+    target_group_health: typing.Optional[typing.Union[TargetGroupHealth, typing.Dict[builtins.str, typing.Any]]] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -28892,6 +29147,16 @@ def _typecheckingstub__7c19dd8de36c1c86ebd89e7c24379bf1b20a6e5f343db95042864bf02
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__50b92a6e3fb50861786c29f006a421debbe4bf2e446caaef18d21a99c0e35f73(
+    *,
+    dns_minimum_healthy_target_count: typing.Optional[jsii.Number] = None,
+    dns_minimum_healthy_target_percentage: typing.Optional[jsii.Number] = None,
+    routing_minimum_healthy_target_count: typing.Optional[jsii.Number] = None,
+    routing_minimum_healthy_target_percentage: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__7b22d0445cb034b55d9115fd027b3d892bce86e7f1261aa808a4125edf21d635(
     *,
     target_group_arn: builtins.str,
@@ -29086,6 +29351,7 @@ def _typecheckingstub__0fbf37aa0a91cb985ce7a336a6188364cc38400538c1653e53453287c
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
     ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
+    target_group_health: typing.Optional[typing.Union[TargetGroupHealth, typing.Dict[builtins.str, typing.Any]]] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -29572,6 +29838,7 @@ def _typecheckingstub__907e1e3e88136a6a7bdcdac293563447ed893c77b9f7b1e7154fb1749
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
+    enable_capacity_reservation_provision_stabilize: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     enable_prefix_for_ipv6_source_nat: typing.Optional[builtins.str] = None,
     enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.str] = None,
     ip_address_type: typing.Optional[builtins.str] = None,
@@ -29601,6 +29868,12 @@ def _typecheckingstub__1a178a2aa61d40ebc079a81b6caeba1ff6649a54d784e4ce75ed79b7e
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__db326b5431980db555d148f9ae3420eff076c5f4436bcac08ce2f9c7154eefce(
+    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__38b5ad2c151ce05a51bb2ba1eaa4eb8a906d379df6a66c99f7a4f368bf663f77(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -30183,6 +30456,7 @@ def _typecheckingstub__eebfbf2a20edd0baf4d455f02dd34d748c5eccfa9a5268e5e2ebec245
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
     ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
+    target_group_health: typing.Optional[typing.Union[TargetGroupHealth, typing.Dict[builtins.str, typing.Any]]] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -30471,6 +30745,7 @@ def _typecheckingstub__e179515c9d6138007cc1b74835b75f10a179c1f5ef977cbe4188c778c
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
     ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
+    target_group_health: typing.Optional[typing.Union[TargetGroupHealth, typing.Dict[builtins.str, typing.Any]]] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,

aws_cdk/aws_elasticsearch/__init__.py

@@ -5593,7 +5593,7 @@ class CfnDomain(
                The ``AWS::Elasticsearch::Domain`` resource is being replaced by the `AWS::OpenSearchService::Domain <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-opensearchservice-domain.html>`_ resource. While the legacy Elasticsearch resource and options are still supported, we recommend modifying your existing Cloudformation templates to use the new OpenSearch Service resource, which supports both OpenSearch and Elasticsearch. For more information about the service rename, see `New resource types <https://docs.aws.amazon.com/opensearch-service/latest/developerguide/rename.html#rename-resource>`_ in the *Amazon OpenSearch Service Developer Guide* .
 
             :param custom_endpoint: The fully qualified URL for your custom endpoint. Required if you enabled a custom endpoint for the domain.
-            :param custom_endpoint_certificate_arn: The AWS Certificate Manager ARN for your domain's SSL/TLS certificate. Required if you enabled a custom endpoint for the domain.
+            :param custom_endpoint_certificate_arn: The Certificate Manager ARN for your domain's SSL/TLS certificate. Required if you enabled a custom endpoint for the domain.
             :param custom_endpoint_enabled: True to enable a custom endpoint for the domain. If enabled, you must also provide values for ``CustomEndpoint`` and ``CustomEndpointCertificateArn`` .
             :param enforce_https: True to require that all traffic to the domain arrive over HTTPS.
             :param tls_security_policy: The minimum TLS version required for traffic to the domain. Valid values are TLS 1.3 (recommended) or 1.2:. - ``Policy-Min-TLS-1-0-2019-07`` - ``Policy-Min-TLS-1-2-2019-07``
@@ -5647,7 +5647,7 @@ class CfnDomain(
 
         @builtins.property
         def custom_endpoint_certificate_arn(self) -> typing.Optional[builtins.str]:
-            '''The AWS Certificate Manager ARN for your domain's SSL/TLS certificate.
+            '''The Certificate Manager ARN for your domain's SSL/TLS certificate.
 
             Required if you enabled a custom endpoint for the domain.