aws-cdk-lib 2.189.1__py3-none-any.whl → 2.191.0__py3-none-any.whl

aws_cdk/aws_elasticloadbalancingv2/__init__.py

@@ -433,6 +433,77 @@ listener = lb.add_listener("Listener",
 )
 ```
 
+### Configuring a subnet information for a Network Load Balancer
+
+You can specify the subnets for a Network Load Balancer easily by setting the `vpcSubnets` property.
+
+```python
+# vpc: ec2.Vpc
+
+
+lb = elbv2.NetworkLoadBalancer(self, "LB",
+    vpc=vpc,
+    vpc_subnets=ec2.SubnetSelection(
+        subnet_type=ec2.SubnetType.PRIVATE
+    )
+)
+```
+
+If you want to configure detailed information about the subnets, you can use the `subnetMappings` property as follows:
+
+```python
+# vpc: ec2.IVpc
+# dualstack_vpc: ec2.IVpc
+# subnet: ec2.ISubnet
+# dualstack_subnet: ec2.ISubnet
+# cfn_eip: ec2.CfnEIP
+
+
+# Internet facing Network Load Balancer with an Elastic IPv4 address
+elbv2.NetworkLoadBalancer(self, "InternetFacingLb",
+    vpc=vpc,
+    internet_facing=True,
+    subnet_mappings=[elbv2.SubnetMapping(
+        subnet=subnet,
+        # The allocation ID of the Elastic IP address
+        allocation_id=cfn_eip.attr_allocation_id
+    )
+    ]
+)
+
+# Internal Network Load Balancer with a private IPv4 address
+elbv2.NetworkLoadBalancer(self, "InternalLb",
+    vpc=vpc,
+    internet_facing=False,
+    subnet_mappings=[elbv2.SubnetMapping(
+        subnet=subnet,
+        # The private IPv4 address from the subnet
+        # The address must be in the subnet's CIDR range and
+        # can not be configured for a internet facing Network Load Balancer.
+        private_ipv4_address="10.0.12.29"
+    )
+    ]
+)
+
+# Dualstack Network Load Balancer with an IPv6 address and prefix for source NAT
+elbv2.NetworkLoadBalancer(self, "DualstackLb",
+    vpc=dualstack_vpc,
+    # Configure the dualstack Network Load Balancer
+    ip_address_type=elbv2.IpAddressType.DUAL_STACK,
+    enable_prefix_for_ipv6_source_nat=True,
+    subnet_mappings=[elbv2.SubnetMapping(
+        subnet=dualstack_subnet,
+        # The IPv6 address from the subnet
+        # `ipAddresstype` must be `DUAL_STACK` or `DUAL_STACK_WITHOUT_PUBLIC_IPV4` to set the IPv6 address.
+        ipv6_address="2001:db8:1234:1a00::10",
+        # The IPv6 prefix to use for source NAT
+        # `enablePrefixForIpv6SourceNat` must be `true` to set `sourceNatIpv6Prefix`.
+        source_nat_ipv6_prefix=elbv2.SourceNatIpv6Prefix.auto_assigned()
+    )
+    ]
+)
+```
+
 ### Network Load Balancer attributes
 
 You can modify attributes of Network Load Balancers:
@@ -1140,6 +1211,7 @@ from ..aws_ec2 import (
     Connections as _Connections_0f31fce8,
     IConnectable as _IConnectable_10015a05,
     ISecurityGroup as _ISecurityGroup_acf8a799,
+    ISubnet as _ISubnet_d57d1229,
     IVpc as _IVpc_f30d5663,
     IVpcEndpointServiceLoadBalancer as _IVpcEndpointServiceLoadBalancer_34cbc6e3,
     Port as _Port_85922693,
@@ -17373,6 +17445,7 @@ class NetworkLoadBalancer(
         enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.bool] = None,
         ip_address_type: typing.Optional[IpAddressType] = None,
         security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
+        subnet_mappings: typing.Optional[typing.Sequence[typing.Union["SubnetMapping", typing.Dict[builtins.str, typing.Any]]]] = None,
         zonal_shift: typing.Optional[builtins.bool] = None,
         vpc: _IVpc_f30d5663,
         cross_zone_enabled: typing.Optional[builtins.bool] = None,
@@ -17391,6 +17464,7 @@ class NetworkLoadBalancer(
         :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. Default: true
         :param ip_address_type: The type of IP addresses to use. If you want to add a UDP or TCP_UDP listener to the load balancer, you must choose IPv4. Default: IpAddressType.IPV4
         :param security_groups: Security groups to associate with this load balancer. Default: - No security groups associated with the load balancer.
+        :param subnet_mappings: Subnet information for the load balancer. Default: undefined - The VPC default strategy for subnets is used
         :param zonal_shift: Indicates whether zonal shift is enabled. Default: false
         :param vpc: The VPC network to place the load balancer in.
         :param cross_zone_enabled: Indicates whether cross-zone load balancing is enabled. Default: - false for Network Load Balancers and true for Application Load Balancers. This can not be ``false`` for Application Load Balancers.
@@ -17411,6 +17485,7 @@ class NetworkLoadBalancer(
             enforce_security_group_inbound_rules_on_private_link_traffic=enforce_security_group_inbound_rules_on_private_link_traffic,
             ip_address_type=ip_address_type,
             security_groups=security_groups,
+            subnet_mappings=subnet_mappings,
             zonal_shift=zonal_shift,
             vpc=vpc,
             cross_zone_enabled=cross_zone_enabled,
@@ -18214,6 +18289,7 @@ class NetworkLoadBalancerLookupOptions(BaseLoadBalancerLookupOptions):
         "enforce_security_group_inbound_rules_on_private_link_traffic": "enforceSecurityGroupInboundRulesOnPrivateLinkTraffic",
         "ip_address_type": "ipAddressType",
         "security_groups": "securityGroups",
+        "subnet_mappings": "subnetMappings",
         "zonal_shift": "zonalShift",
     },
 )
@@ -18234,6 +18310,7 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
         enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.bool] = None,
         ip_address_type: typing.Optional[IpAddressType] = None,
         security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
+        subnet_mappings: typing.Optional[typing.Sequence[typing.Union["SubnetMapping", typing.Dict[builtins.str, typing.Any]]]] = None,
         zonal_shift: typing.Optional[builtins.bool] = None,
     ) -> None:
         '''Properties for a network load balancer.
@@ -18251,6 +18328,7 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
         :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. Default: true
         :param ip_address_type: The type of IP addresses to use. If you want to add a UDP or TCP_UDP listener to the load balancer, you must choose IPv4. Default: IpAddressType.IPV4
         :param security_groups: Security groups to associate with this load balancer. Default: - No security groups associated with the load balancer.
+        :param subnet_mappings: Subnet information for the load balancer. Default: undefined - The VPC default strategy for subnets is used
         :param zonal_shift: Indicates whether zonal shift is enabled. Default: false
 
         :exampleMetadata: infused
@@ -18288,6 +18366,7 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
             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"])
             check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
+            check_type(argname="argument subnet_mappings", value=subnet_mappings, expected_type=type_hints["subnet_mappings"])
             check_type(argname="argument zonal_shift", value=zonal_shift, expected_type=type_hints["zonal_shift"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "vpc": vpc,
@@ -18316,6 +18395,8 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
             self._values["ip_address_type"] = ip_address_type
         if security_groups is not None:
             self._values["security_groups"] = security_groups
+        if subnet_mappings is not None:
+            self._values["subnet_mappings"] = subnet_mappings
         if zonal_shift is not None:
             self._values["zonal_shift"] = zonal_shift
 
@@ -18450,6 +18531,15 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
         result = self._values.get("security_groups")
         return typing.cast(typing.Optional[typing.List[_ISecurityGroup_acf8a799]], result)
 
+    @builtins.property
+    def subnet_mappings(self) -> typing.Optional[typing.List["SubnetMapping"]]:
+        '''Subnet information for the load balancer.
+
+        :default: undefined - The VPC default strategy for subnets is used
+        '''
+        result = self._values.get("subnet_mappings")
+        return typing.cast(typing.Optional[typing.List["SubnetMapping"]], result)
+
     @builtins.property
     def zonal_shift(self) -> typing.Optional[builtins.bool]:
         '''Indicates whether zonal shift is enabled.
@@ -19234,6 +19324,102 @@ class RevocationType(enum.Enum):
     '''A signed list of revoked certificates.'''
 
 
+class SourceNatIpv6Prefix(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.SourceNatIpv6Prefix",
+):
+    '''The prefix to use for source NAT for a dual-stack network load balancer with UDP listeners.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # vpc: ec2.IVpc
+        # dualstack_vpc: ec2.IVpc
+        # subnet: ec2.ISubnet
+        # dualstack_subnet: ec2.ISubnet
+        # cfn_eip: ec2.CfnEIP
+        
+        
+        # Internet facing Network Load Balancer with an Elastic IPv4 address
+        elbv2.NetworkLoadBalancer(self, "InternetFacingLb",
+            vpc=vpc,
+            internet_facing=True,
+            subnet_mappings=[elbv2.SubnetMapping(
+                subnet=subnet,
+                # The allocation ID of the Elastic IP address
+                allocation_id=cfn_eip.attr_allocation_id
+            )
+            ]
+        )
+        
+        # Internal Network Load Balancer with a private IPv4 address
+        elbv2.NetworkLoadBalancer(self, "InternalLb",
+            vpc=vpc,
+            internet_facing=False,
+            subnet_mappings=[elbv2.SubnetMapping(
+                subnet=subnet,
+                # The private IPv4 address from the subnet
+                # The address must be in the subnet's CIDR range and
+                # can not be configured for a internet facing Network Load Balancer.
+                private_ipv4_address="10.0.12.29"
+            )
+            ]
+        )
+        
+        # Dualstack Network Load Balancer with an IPv6 address and prefix for source NAT
+        elbv2.NetworkLoadBalancer(self, "DualstackLb",
+            vpc=dualstack_vpc,
+            # Configure the dualstack Network Load Balancer
+            ip_address_type=elbv2.IpAddressType.DUAL_STACK,
+            enable_prefix_for_ipv6_source_nat=True,
+            subnet_mappings=[elbv2.SubnetMapping(
+                subnet=dualstack_subnet,
+                # The IPv6 address from the subnet
+                # `ipAddresstype` must be `DUAL_STACK` or `DUAL_STACK_WITHOUT_PUBLIC_IPV4` to set the IPv6 address.
+                ipv6_address="2001:db8:1234:1a00::10",
+                # The IPv6 prefix to use for source NAT
+                # `enablePrefixForIpv6SourceNat` must be `true` to set `sourceNatIpv6Prefix`.
+                source_nat_ipv6_prefix=elbv2.SourceNatIpv6Prefix.auto_assigned()
+            )
+            ]
+        )
+    '''
+
+    def __init__(self, prefix: builtins.str) -> None:
+        '''
+        :param prefix: The IPv6 prefix.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__8d55714f5f91498510c90c4dda1351b8a7df895b813a9a7497de8b105f014317)
+            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
+        jsii.create(self.__class__, self, [prefix])
+
+    @jsii.member(jsii_name="autoAssigned")
+    @builtins.classmethod
+    def auto_assigned(cls) -> "SourceNatIpv6Prefix":
+        '''Use an automatically assigned IPv6 prefix.'''
+        return typing.cast("SourceNatIpv6Prefix", jsii.sinvoke(cls, "autoAssigned", []))
+
+    @jsii.member(jsii_name="fromIpv6Prefix")
+    @builtins.classmethod
+    def from_ipv6_prefix(cls, prefix: builtins.str) -> "SourceNatIpv6Prefix":
+        '''Use a custom IPv6 prefix with /80 netmask.
+
+        :param prefix: The IPv6 prefix.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__7931008bfd4762535b77272b55f89bbaa4ed5fceb99b2c3a2e557b0f4bc30a4f)
+            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
+        return typing.cast("SourceNatIpv6Prefix", jsii.sinvoke(cls, "fromIpv6Prefix", [prefix]))
+
+    @builtins.property
+    @jsii.member(jsii_name="prefix")
+    def prefix(self) -> builtins.str:
+        '''The IPv6 prefix.'''
+        return typing.cast(builtins.str, jsii.get(self, "prefix"))
+
+
 @jsii.enum(jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.SslPolicy")
 class SslPolicy(enum.Enum):
     '''Elastic Load Balancing provides the following security policies for Application Load Balancers.
@@ -19374,6 +19560,134 @@ class SslPolicy(enum.Enum):
     '''
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.SubnetMapping",
+    jsii_struct_bases=[],
+    name_mapping={
+        "subnet": "subnet",
+        "allocation_id": "allocationId",
+        "ipv6_address": "ipv6Address",
+        "private_ipv4_address": "privateIpv4Address",
+        "source_nat_ipv6_prefix": "sourceNatIpv6Prefix",
+    },
+)
+class SubnetMapping:
+    def __init__(
+        self,
+        *,
+        subnet: _ISubnet_d57d1229,
+        allocation_id: typing.Optional[builtins.str] = None,
+        ipv6_address: typing.Optional[builtins.str] = None,
+        private_ipv4_address: typing.Optional[builtins.str] = None,
+        source_nat_ipv6_prefix: typing.Optional[SourceNatIpv6Prefix] = None,
+    ) -> None:
+        '''Specifies a subnet for a load balancer.
+
+        :param subnet: The subnet.
+        :param allocation_id: The allocation ID of the Elastic IP address for an internet-facing load balancer. Default: undefined - AWS default is to allocate a new IP address for internet-facing load balancers
+        :param ipv6_address: The IPv6 address. Default: undefined - AWS default is to allocate an IPv6 address from the subnet's pool
+        :param private_ipv4_address: The private IPv4 address for an internal load balancer. Default: undefined - AWS default is to allocate a private IPv4 address from the subnet's pool
+        :param source_nat_ipv6_prefix: The IPv6 prefix to use for source NAT for a dual-stack network load balancer with UDP listeners. Specify an IPv6 prefix (/80 netmask) from the subnet CIDR block or ``SourceNatIpv6Prefix.autoAssigned()`` to use an IPv6 prefix selected at random from the subnet CIDR block. Default: undefined - AWS default is ``SourceNatIpv6Prefix.autoAssigned()`` for IPv6 load balancers
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_ec2 as ec2
+            from aws_cdk import aws_elasticloadbalancingv2 as elbv2
+            
+            # source_nat_ipv6_prefix: elbv2.SourceNatIpv6Prefix
+            # subnet: ec2.Subnet
+            
+            subnet_mapping = elbv2.SubnetMapping(
+                subnet=subnet,
+            
+                # the properties below are optional
+                allocation_id="allocationId",
+                ipv6_address="ipv6Address",
+                private_ipv4_address="privateIpv4Address",
+                source_nat_ipv6_prefix=source_nat_ipv6_prefix
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__54c4b71e184eedb0fbc0e4df901ecb043d8b11ba2ec0429907b6acd6ced55e82)
+            check_type(argname="argument subnet", value=subnet, expected_type=type_hints["subnet"])
+            check_type(argname="argument allocation_id", value=allocation_id, expected_type=type_hints["allocation_id"])
+            check_type(argname="argument ipv6_address", value=ipv6_address, expected_type=type_hints["ipv6_address"])
+            check_type(argname="argument private_ipv4_address", value=private_ipv4_address, expected_type=type_hints["private_ipv4_address"])
+            check_type(argname="argument source_nat_ipv6_prefix", value=source_nat_ipv6_prefix, expected_type=type_hints["source_nat_ipv6_prefix"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "subnet": subnet,
+        }
+        if allocation_id is not None:
+            self._values["allocation_id"] = allocation_id
+        if ipv6_address is not None:
+            self._values["ipv6_address"] = ipv6_address
+        if private_ipv4_address is not None:
+            self._values["private_ipv4_address"] = private_ipv4_address
+        if source_nat_ipv6_prefix is not None:
+            self._values["source_nat_ipv6_prefix"] = source_nat_ipv6_prefix
+
+    @builtins.property
+    def subnet(self) -> _ISubnet_d57d1229:
+        '''The subnet.'''
+        result = self._values.get("subnet")
+        assert result is not None, "Required property 'subnet' is missing"
+        return typing.cast(_ISubnet_d57d1229, result)
+
+    @builtins.property
+    def allocation_id(self) -> typing.Optional[builtins.str]:
+        '''The allocation ID of the Elastic IP address for an internet-facing load balancer.
+
+        :default: undefined - AWS default is to allocate a new IP address for internet-facing load balancers
+        '''
+        result = self._values.get("allocation_id")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def ipv6_address(self) -> typing.Optional[builtins.str]:
+        '''The IPv6 address.
+
+        :default: undefined - AWS default is to allocate an IPv6 address from the subnet's pool
+        '''
+        result = self._values.get("ipv6_address")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def private_ipv4_address(self) -> typing.Optional[builtins.str]:
+        '''The private IPv4 address for an internal load balancer.
+
+        :default: undefined - AWS default is to allocate a private IPv4 address from the subnet's pool
+        '''
+        result = self._values.get("private_ipv4_address")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def source_nat_ipv6_prefix(self) -> typing.Optional[SourceNatIpv6Prefix]:
+        '''The IPv6 prefix to use for source NAT for a dual-stack network load balancer with UDP listeners.
+
+        Specify an IPv6 prefix (/80 netmask) from the subnet CIDR block
+        or ``SourceNatIpv6Prefix.autoAssigned()`` to use an IPv6 prefix selected at random from the subnet CIDR block.
+
+        :default: undefined - AWS default is ``SourceNatIpv6Prefix.autoAssigned()`` for IPv6 load balancers
+        '''
+        result = self._values.get("source_nat_ipv6_prefix")
+        return typing.cast(typing.Optional[SourceNatIpv6Prefix], 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 "SubnetMapping(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.TargetGroupAttributes",
     jsii_struct_bases=[],
@@ -26051,7 +26365,9 @@ __all__ = [
     "RedirectOptions",
     "RevocationContent",
     "RevocationType",
+    "SourceNatIpv6Prefix",
     "SslPolicy",
+    "SubnetMapping",
     "TargetGroupAttributes",
     "TargetGroupBase",
     "TargetGroupIpAddressType",
@@ -27639,6 +27955,7 @@ def _typecheckingstub__e1c7a4c1332bdc807d1e25aa5d69eea6e1f3bf6a88ddd30dac9a64c93
     enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.bool] = None,
     ip_address_type: typing.Optional[IpAddressType] = None,
     security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
+    subnet_mappings: typing.Optional[typing.Sequence[typing.Union[SubnetMapping, typing.Dict[builtins.str, typing.Any]]]] = None,
     zonal_shift: typing.Optional[builtins.bool] = None,
     vpc: _IVpc_f30d5663,
     cross_zone_enabled: typing.Optional[builtins.bool] = None,
@@ -27747,6 +28064,7 @@ def _typecheckingstub__195ab659ca9cd1c401d6d2d1a1f5cb0aaf7dd80f06dbc724020ac0cc3
     enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.bool] = None,
     ip_address_type: typing.Optional[IpAddressType] = None,
     security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
+    subnet_mappings: typing.Optional[typing.Sequence[typing.Union[SubnetMapping, typing.Dict[builtins.str, typing.Any]]]] = None,
     zonal_shift: typing.Optional[builtins.bool] = None,
 ) -> None:
     """Type checking stubs"""
@@ -27809,6 +28127,29 @@ def _typecheckingstub__a2d98c0c87c9335126a85af9c46b02ccfdb480d04d96fb422b8f62f17
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__8d55714f5f91498510c90c4dda1351b8a7df895b813a9a7497de8b105f014317(
+    prefix: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__7931008bfd4762535b77272b55f89bbaa4ed5fceb99b2c3a2e557b0f4bc30a4f(
+    prefix: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__54c4b71e184eedb0fbc0e4df901ecb043d8b11ba2ec0429907b6acd6ced55e82(
+    *,
+    subnet: _ISubnet_d57d1229,
+    allocation_id: typing.Optional[builtins.str] = None,
+    ipv6_address: typing.Optional[builtins.str] = None,
+    private_ipv4_address: typing.Optional[builtins.str] = None,
+    source_nat_ipv6_prefix: typing.Optional[SourceNatIpv6Prefix] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__37df8dc72952ae228e1a00919ab4c7fcae58e15f47e4e6bc9c1dfdb923d23dcd(
     *,
     target_group_arn: builtins.str,