aws-cdk-lib 2.178.2__py3-none-any.whl → 2.179.0__py3-none-any.whl

aws_cdk/aws_elasticloadbalancingv2/__init__.py

@@ -325,6 +325,22 @@ lb = elbv2.ApplicationLoadBalancer(self, "LB",
 )
 ```
 
+### Defining a reserved Application Load Balancer Capacity Unit (LCU)
+
+You can define a [reserved LCU for your Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/capacity-unit-reservation.html).
+To reserve an LCU, you must specify a `minimumCapacityUnit`.
+
+```python
+# vpc: ec2.Vpc
+
+
+lb = elbv2.ApplicationLoadBalancer(self, "LB",
+    vpc=vpc,
+    # Valid value is between 100 and 1500.
+    minimum_capacity_unit=100
+)
+```
+
 ## Defining a Network Load Balancer
 
 Network Load Balancers are defined in a similar way to Application Load
@@ -481,6 +497,26 @@ lb.add_security_group(sg2)
 lb.connections.allow_from_any_ipv4(ec2.Port.tcp(80))
 ```
 
+### Defining a reserved Network Load Balancer Capacity Unit (LCU)
+
+You can define a [reserved LCU for your Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/capacity-unit-reservation.html).
+
+When requesting a LCU reservation, convert your capacity needs from Mbps to LCUs using the conversion rate of 1 LCU to 2.2 Mbps.
+
+To reserve an LCU, you must specify a `minimumCapacityUnit`.
+
+```python
+# vpc: ec2.Vpc
+
+
+lb = elbv2.NetworkLoadBalancer(self, "LB",
+    vpc=vpc,
+    minimum_capacity_unit=5500
+)
+```
+
+**Note**: The `minimumCapacityUnit` value is evenly distributed across all active Availability Zones (AZs) for the network load balancer. The distributed value per AZ must be between 2,750 and 45,000 units.
+
 ## Targets and Target Groups
 
 Application and Network Load Balancers organize load balancing targets in Target
@@ -3033,6 +3069,7 @@ class BaseLoadBalancerLookupOptions:
         "deny_all_igw_traffic": "denyAllIgwTraffic",
         "internet_facing": "internetFacing",
         "load_balancer_name": "loadBalancerName",
+        "minimum_capacity_unit": "minimumCapacityUnit",
         "vpc_subnets": "vpcSubnets",
     },
 )
@@ -3046,6 +3083,7 @@ class BaseLoadBalancerProps:
         deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
         internet_facing: typing.Optional[builtins.bool] = None,
         load_balancer_name: typing.Optional[builtins.str] = None,
+        minimum_capacity_unit: typing.Optional[jsii.Number] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''Shared properties of both Application and Network Load Balancers.
@@ -3056,6 +3094,7 @@ class BaseLoadBalancerProps:
         :param deny_all_igw_traffic: Indicates whether the load balancer blocks traffic through the Internet Gateway (IGW). Default: - false for internet-facing load balancers and true for internal load balancers
         :param internet_facing: Whether the load balancer has an internet-routable address. Default: false
         :param load_balancer_name: Name of the load balancer. Default: - Automatically generated name.
+        :param minimum_capacity_unit: The minimum capacity (LCU) for a load balancer. Default: undefined - ELB default is 0 LCU
         :param vpc_subnets: Which subnets place the load balancer in. Default: - the Vpc default strategy.
 
         :exampleMetadata: fixture=_generated
@@ -3080,6 +3119,7 @@ class BaseLoadBalancerProps:
                 deny_all_igw_traffic=False,
                 internet_facing=False,
                 load_balancer_name="loadBalancerName",
+                minimum_capacity_unit=123,
                 vpc_subnets=ec2.SubnetSelection(
                     availability_zones=["availabilityZones"],
                     one_per_az=False,
@@ -3100,6 +3140,7 @@ class BaseLoadBalancerProps:
             check_type(argname="argument deny_all_igw_traffic", value=deny_all_igw_traffic, expected_type=type_hints["deny_all_igw_traffic"])
             check_type(argname="argument internet_facing", value=internet_facing, expected_type=type_hints["internet_facing"])
             check_type(argname="argument load_balancer_name", value=load_balancer_name, expected_type=type_hints["load_balancer_name"])
+            check_type(argname="argument minimum_capacity_unit", value=minimum_capacity_unit, expected_type=type_hints["minimum_capacity_unit"])
             check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "vpc": vpc,
@@ -3114,6 +3155,8 @@ class BaseLoadBalancerProps:
             self._values["internet_facing"] = internet_facing
         if load_balancer_name is not None:
             self._values["load_balancer_name"] = load_balancer_name
+        if minimum_capacity_unit is not None:
+            self._values["minimum_capacity_unit"] = minimum_capacity_unit
         if vpc_subnets is not None:
             self._values["vpc_subnets"] = vpc_subnets
 
@@ -3174,6 +3217,17 @@ class BaseLoadBalancerProps:
         result = self._values.get("load_balancer_name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def minimum_capacity_unit(self) -> typing.Optional[jsii.Number]:
+        '''The minimum capacity (LCU) for a load balancer.
+
+        :default: undefined - ELB default is 0 LCU
+
+        :see: https://exampleloadbalancer.com/ondemand_capacity_reservation_calculator.html
+        '''
+        result = self._values.get("minimum_capacity_unit")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def vpc_subnets(self) -> typing.Optional[_SubnetSelection_e57d76df]:
         '''Which subnets place the load balancer in.
@@ -17294,6 +17348,7 @@ class NetworkLoadBalancer(
         deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
         internet_facing: typing.Optional[builtins.bool] = None,
         load_balancer_name: typing.Optional[builtins.str] = None,
+        minimum_capacity_unit: typing.Optional[jsii.Number] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''
@@ -17311,6 +17366,7 @@ class NetworkLoadBalancer(
         :param deny_all_igw_traffic: Indicates whether the load balancer blocks traffic through the Internet Gateway (IGW). Default: - false for internet-facing load balancers and true for internal load balancers
         :param internet_facing: Whether the load balancer has an internet-routable address. Default: false
         :param load_balancer_name: Name of the load balancer. Default: - Automatically generated name.
+        :param minimum_capacity_unit: The minimum capacity (LCU) for a load balancer. Default: undefined - ELB default is 0 LCU
         :param vpc_subnets: Which subnets place the load balancer in. Default: - the Vpc default strategy.
         '''
         if __debug__:
@@ -17330,6 +17386,7 @@ class NetworkLoadBalancer(
             deny_all_igw_traffic=deny_all_igw_traffic,
             internet_facing=internet_facing,
             load_balancer_name=load_balancer_name,
+            minimum_capacity_unit=minimum_capacity_unit,
             vpc_subnets=vpc_subnets,
         )
 
@@ -18118,6 +18175,7 @@ class NetworkLoadBalancerLookupOptions(BaseLoadBalancerLookupOptions):
         "deny_all_igw_traffic": "denyAllIgwTraffic",
         "internet_facing": "internetFacing",
         "load_balancer_name": "loadBalancerName",
+        "minimum_capacity_unit": "minimumCapacityUnit",
         "vpc_subnets": "vpcSubnets",
         "client_routing_policy": "clientRoutingPolicy",
         "enable_prefix_for_ipv6_source_nat": "enablePrefixForIpv6SourceNat",
@@ -18137,6 +18195,7 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
         deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
         internet_facing: typing.Optional[builtins.bool] = None,
         load_balancer_name: typing.Optional[builtins.str] = None,
+        minimum_capacity_unit: typing.Optional[jsii.Number] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
         client_routing_policy: typing.Optional[ClientRoutingPolicy] = None,
         enable_prefix_for_ipv6_source_nat: typing.Optional[builtins.bool] = None,
@@ -18153,6 +18212,7 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
         :param deny_all_igw_traffic: Indicates whether the load balancer blocks traffic through the Internet Gateway (IGW). Default: - false for internet-facing load balancers and true for internal load balancers
         :param internet_facing: Whether the load balancer has an internet-routable address. Default: false
         :param load_balancer_name: Name of the load balancer. Default: - Automatically generated name.
+        :param minimum_capacity_unit: The minimum capacity (LCU) for a load balancer. Default: undefined - ELB default is 0 LCU
         :param vpc_subnets: Which subnets place the load balancer in. Default: - the Vpc default strategy.
         :param client_routing_policy: The AZ affinity routing policy. Default: - AZ affinity is disabled.
         :param enable_prefix_for_ipv6_source_nat: Indicates whether to use an IPv6 prefix from each subnet for source NAT. The IP address type must be IpAddressType.DUALSTACK. Default: undefined - NLB default behavior is false
@@ -18189,6 +18249,7 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
             check_type(argname="argument deny_all_igw_traffic", value=deny_all_igw_traffic, expected_type=type_hints["deny_all_igw_traffic"])
             check_type(argname="argument internet_facing", value=internet_facing, expected_type=type_hints["internet_facing"])
             check_type(argname="argument load_balancer_name", value=load_balancer_name, expected_type=type_hints["load_balancer_name"])
+            check_type(argname="argument minimum_capacity_unit", value=minimum_capacity_unit, expected_type=type_hints["minimum_capacity_unit"])
             check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
             check_type(argname="argument client_routing_policy", value=client_routing_policy, expected_type=type_hints["client_routing_policy"])
             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"])
@@ -18209,6 +18270,8 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
             self._values["internet_facing"] = internet_facing
         if load_balancer_name is not None:
             self._values["load_balancer_name"] = load_balancer_name
+        if minimum_capacity_unit is not None:
+            self._values["minimum_capacity_unit"] = minimum_capacity_unit
         if vpc_subnets is not None:
             self._values["vpc_subnets"] = vpc_subnets
         if client_routing_policy is not None:
@@ -18281,6 +18344,17 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
         result = self._values.get("load_balancer_name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def minimum_capacity_unit(self) -> typing.Optional[jsii.Number]:
+        '''The minimum capacity (LCU) for a load balancer.
+
+        :default: undefined - ELB default is 0 LCU
+
+        :see: https://exampleloadbalancer.com/ondemand_capacity_reservation_calculator.html
+        '''
+        result = self._values.get("minimum_capacity_unit")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def vpc_subnets(self) -> typing.Optional[_SubnetSelection_e57d76df]:
         '''Which subnets place the load balancer in.
@@ -21280,6 +21354,7 @@ class ApplicationLoadBalancerLookupOptions(BaseLoadBalancerLookupOptions):
         "deny_all_igw_traffic": "denyAllIgwTraffic",
         "internet_facing": "internetFacing",
         "load_balancer_name": "loadBalancerName",
+        "minimum_capacity_unit": "minimumCapacityUnit",
         "vpc_subnets": "vpcSubnets",
         "client_keep_alive": "clientKeepAlive",
         "desync_mitigation_mode": "desyncMitigationMode",
@@ -21305,6 +21380,7 @@ class ApplicationLoadBalancerProps(BaseLoadBalancerProps):
         deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
         internet_facing: typing.Optional[builtins.bool] = None,
         load_balancer_name: typing.Optional[builtins.str] = None,
+        minimum_capacity_unit: typing.Optional[jsii.Number] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
         client_keep_alive: typing.Optional[_Duration_4839e8c3] = None,
         desync_mitigation_mode: typing.Optional[DesyncMitigationMode] = None,
@@ -21327,6 +21403,7 @@ class ApplicationLoadBalancerProps(BaseLoadBalancerProps):
         :param deny_all_igw_traffic: Indicates whether the load balancer blocks traffic through the Internet Gateway (IGW). Default: - false for internet-facing load balancers and true for internal load balancers
         :param internet_facing: Whether the load balancer has an internet-routable address. Default: false
         :param load_balancer_name: Name of the load balancer. Default: - Automatically generated name.
+        :param minimum_capacity_unit: The minimum capacity (LCU) for a load balancer. Default: undefined - ELB default is 0 LCU
         :param vpc_subnets: Which subnets place the load balancer in. Default: - the Vpc default strategy.
         :param client_keep_alive: The client keep alive duration. The valid range is 60 to 604800 seconds (1 minute to 7 days). Default: - Duration.seconds(3600)
         :param desync_mitigation_mode: Determines how the load balancer handles requests that might pose a security risk to your application. Default: DesyncMitigationMode.DEFENSIVE
@@ -21386,6 +21463,7 @@ class ApplicationLoadBalancerProps(BaseLoadBalancerProps):
             check_type(argname="argument deny_all_igw_traffic", value=deny_all_igw_traffic, expected_type=type_hints["deny_all_igw_traffic"])
             check_type(argname="argument internet_facing", value=internet_facing, expected_type=type_hints["internet_facing"])
             check_type(argname="argument load_balancer_name", value=load_balancer_name, expected_type=type_hints["load_balancer_name"])
+            check_type(argname="argument minimum_capacity_unit", value=minimum_capacity_unit, expected_type=type_hints["minimum_capacity_unit"])
             check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
             check_type(argname="argument client_keep_alive", value=client_keep_alive, expected_type=type_hints["client_keep_alive"])
             check_type(argname="argument desync_mitigation_mode", value=desync_mitigation_mode, expected_type=type_hints["desync_mitigation_mode"])
@@ -21412,6 +21490,8 @@ class ApplicationLoadBalancerProps(BaseLoadBalancerProps):
             self._values["internet_facing"] = internet_facing
         if load_balancer_name is not None:
             self._values["load_balancer_name"] = load_balancer_name
+        if minimum_capacity_unit is not None:
+            self._values["minimum_capacity_unit"] = minimum_capacity_unit
         if vpc_subnets is not None:
             self._values["vpc_subnets"] = vpc_subnets
         if client_keep_alive is not None:
@@ -21496,6 +21576,17 @@ class ApplicationLoadBalancerProps(BaseLoadBalancerProps):
         result = self._values.get("load_balancer_name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def minimum_capacity_unit(self) -> typing.Optional[jsii.Number]:
+        '''The minimum capacity (LCU) for a load balancer.
+
+        :default: undefined - ELB default is 0 LCU
+
+        :see: https://exampleloadbalancer.com/ondemand_capacity_reservation_calculator.html
+        '''
+        result = self._values.get("minimum_capacity_unit")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def vpc_subnets(self) -> typing.Optional[_SubnetSelection_e57d76df]:
         '''Which subnets place the load balancer in.
@@ -23688,6 +23779,7 @@ class ApplicationLoadBalancer(
         deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
         internet_facing: typing.Optional[builtins.bool] = None,
         load_balancer_name: typing.Optional[builtins.str] = None,
+        minimum_capacity_unit: typing.Optional[jsii.Number] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''
@@ -23711,6 +23803,7 @@ class ApplicationLoadBalancer(
         :param deny_all_igw_traffic: Indicates whether the load balancer blocks traffic through the Internet Gateway (IGW). Default: - false for internet-facing load balancers and true for internal load balancers
         :param internet_facing: Whether the load balancer has an internet-routable address. Default: false
         :param load_balancer_name: Name of the load balancer. Default: - Automatically generated name.
+        :param minimum_capacity_unit: The minimum capacity (LCU) for a load balancer. Default: undefined - ELB default is 0 LCU
         :param vpc_subnets: Which subnets place the load balancer in. Default: - the Vpc default strategy.
         '''
         if __debug__:
@@ -23736,6 +23829,7 @@ class ApplicationLoadBalancer(
             deny_all_igw_traffic=deny_all_igw_traffic,
             internet_facing=internet_facing,
             load_balancer_name=load_balancer_name,
+            minimum_capacity_unit=minimum_capacity_unit,
             vpc_subnets=vpc_subnets,
         )
 
@@ -26160,6 +26254,7 @@ def _typecheckingstub__36614588a5e075aa6e7ea0a4d41053b09874f2590b227cd5d62f34299
     deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
     internet_facing: typing.Optional[builtins.bool] = None,
     load_balancer_name: typing.Optional[builtins.str] = None,
+    minimum_capacity_unit: typing.Optional[jsii.Number] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -27528,6 +27623,7 @@ def _typecheckingstub__e1c7a4c1332bdc807d1e25aa5d69eea6e1f3bf6a88ddd30dac9a64c93
     deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
     internet_facing: typing.Optional[builtins.bool] = None,
     load_balancer_name: typing.Optional[builtins.str] = None,
+    minimum_capacity_unit: typing.Optional[jsii.Number] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -27621,6 +27717,7 @@ def _typecheckingstub__195ab659ca9cd1c401d6d2d1a1f5cb0aaf7dd80f06dbc724020ac0cc3
     deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
     internet_facing: typing.Optional[builtins.bool] = None,
     load_balancer_name: typing.Optional[builtins.str] = None,
+    minimum_capacity_unit: typing.Optional[jsii.Number] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     client_routing_policy: typing.Optional[ClientRoutingPolicy] = None,
     enable_prefix_for_ipv6_source_nat: typing.Optional[builtins.bool] = None,
@@ -27873,6 +27970,7 @@ def _typecheckingstub__e43cf75024913d9be0d5d621a5f2c2c7be60a57898a54967cd54179b2
     deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
     internet_facing: typing.Optional[builtins.bool] = None,
     load_balancer_name: typing.Optional[builtins.str] = None,
+    minimum_capacity_unit: typing.Optional[jsii.Number] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     client_keep_alive: typing.Optional[_Duration_4839e8c3] = None,
     desync_mitigation_mode: typing.Optional[DesyncMitigationMode] = None,
@@ -28272,6 +28370,7 @@ def _typecheckingstub__22d249b6cdbe3ce0dfc1a873ef276c65fe89ce6a5dba0603fae0a5755
     deny_all_igw_traffic: typing.Optional[builtins.bool] = None,
     internet_facing: typing.Optional[builtins.bool] = None,
     load_balancer_name: typing.Optional[builtins.str] = None,
+    minimum_capacity_unit: typing.Optional[jsii.Number] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""

aws_cdk/aws_events/__init__.py

@@ -10629,27 +10629,21 @@ class RuleProps(EventCommonOptions):
 
         Example::
 
-            import aws_cdk.aws_lambda as lambda_
+            import aws_cdk.aws_redshiftserverless as redshiftserverless
             
+            # workgroup: redshiftserverless.CfnWorkgroup
             
-            fn = lambda_.Function(self, "MyFunc",
-                runtime=lambda_.Runtime.NODEJS_LATEST,
-                handler="index.handler",
-                code=lambda_.Code.from_inline("exports.handler = handler.toString()")
-            )
             
-            rule = events.Rule(self, "rule",
-                event_pattern=events.EventPattern(
-                    source=["aws.ec2"]
-                )
+            rule = events.Rule(self, "Rule",
+                schedule=events.Schedule.rate(cdk.Duration.hours(1))
             )
             
-            queue = sqs.Queue(self, "Queue")
+            dlq = sqs.Queue(self, "DeadLetterQueue")
             
-            rule.add_target(targets.LambdaFunction(fn,
-                dead_letter_queue=queue,  # Optional: add a dead letter queue
-                max_event_age=Duration.hours(2),  # Optional: set the maxEventAge retry policy
-                retry_attempts=2
+            rule.add_target(targets.RedshiftQuery(workgroup.attr_workgroup_workgroup_arn,
+                database="dev",
+                dead_letter_queue=dlq,
+                sql=["SELECT * FROM foo", "SELECT * FROM baz"]
             ))
         '''
         if isinstance(event_pattern, dict):