pulumi-alicloud 3.74.0a1737989015__py3-none-any.whl → 3.75.0__py3-none-any.whl

pulumi_alicloud/nlb/_inputs.py

@@ -15,6 +15,8 @@ else:
 from .. import _utilities
 
 __all__ = [
+    'ListenerProxyProtocolConfigArgs',
+    'ListenerProxyProtocolConfigArgsDict',
     'LoadBalancerDeletionProtectionConfigArgs',
     'LoadBalancerDeletionProtectionConfigArgsDict',
     'LoadBalancerModificationProtectionConfigArgs',
@@ -27,6 +29,78 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class ListenerProxyProtocolConfigArgsDict(TypedDict):
+        proxy_protocol_config_private_link_ep_id_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to enable carrying PrivateLinkEpId to backend servers through Proxy Protocol.
+        """
+        proxy_protocol_config_private_link_eps_id_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to enable carrying PrivateLinkEpsId to backend servers through the Proxy Protocol.
+        """
+        proxy_protocol_config_vpc_id_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to enable carrying VpcId to backend servers through Proxy Protocol.
+        """
+elif False:
+    ListenerProxyProtocolConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ListenerProxyProtocolConfigArgs:
+    def __init__(__self__, *,
+                 proxy_protocol_config_private_link_ep_id_enabled: Optional[pulumi.Input[bool]] = None,
+                 proxy_protocol_config_private_link_eps_id_enabled: Optional[pulumi.Input[bool]] = None,
+                 proxy_protocol_config_vpc_id_enabled: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[bool] proxy_protocol_config_private_link_ep_id_enabled: Whether to enable carrying PrivateLinkEpId to backend servers through Proxy Protocol.
+        :param pulumi.Input[bool] proxy_protocol_config_private_link_eps_id_enabled: Whether to enable carrying PrivateLinkEpsId to backend servers through the Proxy Protocol.
+        :param pulumi.Input[bool] proxy_protocol_config_vpc_id_enabled: Whether to enable carrying VpcId to backend servers through Proxy Protocol.
+        """
+        if proxy_protocol_config_private_link_ep_id_enabled is not None:
+            pulumi.set(__self__, "proxy_protocol_config_private_link_ep_id_enabled", proxy_protocol_config_private_link_ep_id_enabled)
+        if proxy_protocol_config_private_link_eps_id_enabled is not None:
+            pulumi.set(__self__, "proxy_protocol_config_private_link_eps_id_enabled", proxy_protocol_config_private_link_eps_id_enabled)
+        if proxy_protocol_config_vpc_id_enabled is not None:
+            pulumi.set(__self__, "proxy_protocol_config_vpc_id_enabled", proxy_protocol_config_vpc_id_enabled)
+
+    @property
+    @pulumi.getter(name="proxyProtocolConfigPrivateLinkEpIdEnabled")
+    def proxy_protocol_config_private_link_ep_id_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether to enable carrying PrivateLinkEpId to backend servers through Proxy Protocol.
+        """
+        return pulumi.get(self, "proxy_protocol_config_private_link_ep_id_enabled")
+
+    @proxy_protocol_config_private_link_ep_id_enabled.setter
+    def proxy_protocol_config_private_link_ep_id_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "proxy_protocol_config_private_link_ep_id_enabled", value)
+
+    @property
+    @pulumi.getter(name="proxyProtocolConfigPrivateLinkEpsIdEnabled")
+    def proxy_protocol_config_private_link_eps_id_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether to enable carrying PrivateLinkEpsId to backend servers through the Proxy Protocol.
+        """
+        return pulumi.get(self, "proxy_protocol_config_private_link_eps_id_enabled")
+
+    @proxy_protocol_config_private_link_eps_id_enabled.setter
+    def proxy_protocol_config_private_link_eps_id_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "proxy_protocol_config_private_link_eps_id_enabled", value)
+
+    @property
+    @pulumi.getter(name="proxyProtocolConfigVpcIdEnabled")
+    def proxy_protocol_config_vpc_id_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether to enable carrying VpcId to backend servers through Proxy Protocol.
+        """
+        return pulumi.get(self, "proxy_protocol_config_vpc_id_enabled")
+
+    @proxy_protocol_config_vpc_id_enabled.setter
+    def proxy_protocol_config_vpc_id_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "proxy_protocol_config_vpc_id_enabled", value)
+
+
 if not MYPY:
     class LoadBalancerDeletionProtectionConfigArgsDict(TypedDict):
         enabled: NotRequired[pulumi.Input[bool]]
@@ -379,9 +453,7 @@ if not MYPY:
         health_check_connect_port: NotRequired[pulumi.Input[int]]
         """
         The port that you want to use for health checks on backend servers.
-
         Valid values: `0` to `65535`.
-
         Default value: `0`. If you set the value to 0, the port of the backend server is used for health checks.
         """
         health_check_connect_timeout: NotRequired[pulumi.Input[int]]
@@ -397,6 +469,10 @@ if not MYPY:
         """
         Specifies whether to enable the health check feature. Valid values:
         """
+        health_check_exp: NotRequired[pulumi.Input[str]]
+        """
+        health check response character string. The value contains a maximum of 512 characters
+        """
         health_check_http_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
         """
         The HTTP status codes to return for health checks. Separate multiple HTTP status codes with commas (,). Valid values: `http\\_2xx` (default), `http\\_3xx`, `http\\_4xx`, and `http\\_5xx`.
@@ -406,11 +482,13 @@ if not MYPY:
         health_check_interval: NotRequired[pulumi.Input[int]]
         """
         The interval at which health checks are performed. Unit: seconds.
-
         Valid values: `5` to `50`.
-
         Default value: `10`.
         """
+        health_check_req: NotRequired[pulumi.Input[str]]
+        """
+        UDP healthy check request string, the value is a character string of 512 characters
+        """
         health_check_type: NotRequired[pulumi.Input[str]]
         """
         The protocol that you want to use for health checks. Valid values: `TCP` (default) and `HTTP`.
@@ -426,9 +504,7 @@ if not MYPY:
         healthy_threshold: NotRequired[pulumi.Input[int]]
         """
         The number of times that an unhealthy backend server must consecutively pass health checks before it is declared healthy. In this case, the health status changes from `fail` to `success`.
-
         Valid values: `2` to `10`.
-
         Default value: `2`.
         """
         http_check_method: NotRequired[pulumi.Input[str]]
@@ -440,9 +516,7 @@ if not MYPY:
         unhealthy_threshold: NotRequired[pulumi.Input[int]]
         """
         The number of times that a healthy backend server must consecutively fail health checks before it is declared unhealthy. In this case, the health status changes from `success` to `fail`.
-
         Valid values: `2` to `10`.
-
         Default value: `2`.
         """
 elif False:
@@ -455,8 +529,10 @@ class ServerGroupHealthCheckArgs:
                  health_check_connect_timeout: Optional[pulumi.Input[int]] = None,
                  health_check_domain: Optional[pulumi.Input[str]] = None,
                  health_check_enabled: Optional[pulumi.Input[bool]] = None,
+                 health_check_exp: Optional[pulumi.Input[str]] = None,
                  health_check_http_codes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  health_check_interval: Optional[pulumi.Input[int]] = None,
+                 health_check_req: Optional[pulumi.Input[str]] = None,
                  health_check_type: Optional[pulumi.Input[str]] = None,
                  health_check_url: Optional[pulumi.Input[str]] = None,
                  healthy_threshold: Optional[pulumi.Input[int]] = None,
@@ -464,22 +540,20 @@ class ServerGroupHealthCheckArgs:
                  unhealthy_threshold: Optional[pulumi.Input[int]] = None):
         """
         :param pulumi.Input[int] health_check_connect_port: The port that you want to use for health checks on backend servers.
-               
                Valid values: `0` to `65535`.
-               
                Default value: `0`. If you set the value to 0, the port of the backend server is used for health checks.
         :param pulumi.Input[int] health_check_connect_timeout: The maximum timeout period of a health check. Unit: seconds. Valid values: `1` to `300`. Default value: `5`.
         :param pulumi.Input[str] health_check_domain: The domain name that you want to use for health checks. Valid values:
                - `$SERVER_IP`: the private IP address of a backend server.
         :param pulumi.Input[bool] health_check_enabled: Specifies whether to enable the health check feature. Valid values:
+        :param pulumi.Input[str] health_check_exp: health check response character string. The value contains a maximum of 512 characters
         :param pulumi.Input[Sequence[pulumi.Input[str]]] health_check_http_codes: The HTTP status codes to return for health checks. Separate multiple HTTP status codes with commas (,). Valid values: `http\\_2xx` (default), `http\\_3xx`, `http\\_4xx`, and `http\\_5xx`.
                
                > **NOTE:**  This parameter takes effect only when `HealthCheckType` is set to `HTTP`.
         :param pulumi.Input[int] health_check_interval: The interval at which health checks are performed. Unit: seconds.
-               
                Valid values: `5` to `50`.
-               
                Default value: `10`.
+        :param pulumi.Input[str] health_check_req: UDP healthy check request string, the value is a character string of 512 characters
         :param pulumi.Input[str] health_check_type: The protocol that you want to use for health checks. Valid values: `TCP` (default) and `HTTP`.
         :param pulumi.Input[str] health_check_url: The path to which health check requests are sent.
                
@@ -487,17 +561,13 @@ class ServerGroupHealthCheckArgs:
                
                > **NOTE:**  This parameter takes effect only when `HealthCheckType` is set to `HTTP`.
         :param pulumi.Input[int] healthy_threshold: The number of times that an unhealthy backend server must consecutively pass health checks before it is declared healthy. In this case, the health status changes from `fail` to `success`.
-               
                Valid values: `2` to `10`.
-               
                Default value: `2`.
         :param pulumi.Input[str] http_check_method: The HTTP method that is used for health checks. Valid values: `GET` (default) and `HEAD`.
                
                > **NOTE:**  This parameter takes effect only when `HealthCheckType` is set to `HTTP`.
         :param pulumi.Input[int] unhealthy_threshold: The number of times that a healthy backend server must consecutively fail health checks before it is declared unhealthy. In this case, the health status changes from `success` to `fail`.
-               
                Valid values: `2` to `10`.
-               
                Default value: `2`.
         """
         if health_check_connect_port is not None:
@@ -508,10 +578,14 @@ class ServerGroupHealthCheckArgs:
             pulumi.set(__self__, "health_check_domain", health_check_domain)
         if health_check_enabled is not None:
             pulumi.set(__self__, "health_check_enabled", health_check_enabled)
+        if health_check_exp is not None:
+            pulumi.set(__self__, "health_check_exp", health_check_exp)
         if health_check_http_codes is not None:
             pulumi.set(__self__, "health_check_http_codes", health_check_http_codes)
         if health_check_interval is not None:
             pulumi.set(__self__, "health_check_interval", health_check_interval)
+        if health_check_req is not None:
+            pulumi.set(__self__, "health_check_req", health_check_req)
         if health_check_type is not None:
             pulumi.set(__self__, "health_check_type", health_check_type)
         if health_check_url is not None:
@@ -528,9 +602,7 @@ class ServerGroupHealthCheckArgs:
     def health_check_connect_port(self) -> Optional[pulumi.Input[int]]:
         """
         The port that you want to use for health checks on backend servers.
-
         Valid values: `0` to `65535`.
-
         Default value: `0`. If you set the value to 0, the port of the backend server is used for health checks.
         """
         return pulumi.get(self, "health_check_connect_port")
@@ -576,6 +648,18 @@ class ServerGroupHealthCheckArgs:
     def health_check_enabled(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "health_check_enabled", value)
 
+    @property
+    @pulumi.getter(name="healthCheckExp")
+    def health_check_exp(self) -> Optional[pulumi.Input[str]]:
+        """
+        health check response character string. The value contains a maximum of 512 characters
+        """
+        return pulumi.get(self, "health_check_exp")
+
+    @health_check_exp.setter
+    def health_check_exp(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "health_check_exp", value)
+
     @property
     @pulumi.getter(name="healthCheckHttpCodes")
     def health_check_http_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
@@ -595,9 +679,7 @@ class ServerGroupHealthCheckArgs:
     def health_check_interval(self) -> Optional[pulumi.Input[int]]:
         """
         The interval at which health checks are performed. Unit: seconds.
-
         Valid values: `5` to `50`.
-
         Default value: `10`.
         """
         return pulumi.get(self, "health_check_interval")
@@ -606,6 +688,18 @@ class ServerGroupHealthCheckArgs:
     def health_check_interval(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "health_check_interval", value)
 
+    @property
+    @pulumi.getter(name="healthCheckReq")
+    def health_check_req(self) -> Optional[pulumi.Input[str]]:
+        """
+        UDP healthy check request string, the value is a character string of 512 characters
+        """
+        return pulumi.get(self, "health_check_req")
+
+    @health_check_req.setter
+    def health_check_req(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "health_check_req", value)
+
     @property
     @pulumi.getter(name="healthCheckType")
     def health_check_type(self) -> Optional[pulumi.Input[str]]:
@@ -639,9 +733,7 @@ class ServerGroupHealthCheckArgs:
     def healthy_threshold(self) -> Optional[pulumi.Input[int]]:
         """
         The number of times that an unhealthy backend server must consecutively pass health checks before it is declared healthy. In this case, the health status changes from `fail` to `success`.
-
         Valid values: `2` to `10`.
-
         Default value: `2`.
         """
         return pulumi.get(self, "healthy_threshold")
@@ -669,9 +761,7 @@ class ServerGroupHealthCheckArgs:
     def unhealthy_threshold(self) -> Optional[pulumi.Input[int]]:
         """
         The number of times that a healthy backend server must consecutively fail health checks before it is declared unhealthy. In this case, the health status changes from `success` to `fail`.
-
         Valid values: `2` to `10`.
-
         Default value: `2`.
         """
         return pulumi.get(self, "unhealthy_threshold")

pulumi_alicloud/nlb/listener.py

@@ -13,6 +13,8 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from . import outputs
+from ._inputs import *
 
 __all__ = ['ListenerArgs', 'Listener']
 
@@ -33,6 +35,7 @@ class ListenerArgs:
                  idle_timeout: Optional[pulumi.Input[int]] = None,
                  listener_description: Optional[pulumi.Input[str]] = None,
                  mss: Optional[pulumi.Input[int]] = None,
+                 proxy_protocol_config: Optional[pulumi.Input['ListenerProxyProtocolConfigArgs']] = None,
                  proxy_protocol_enabled: Optional[pulumi.Input[bool]] = None,
                  sec_sensor_enabled: Optional[pulumi.Input[bool]] = None,
                  security_policy_id: Optional[pulumi.Input[str]] = None,
@@ -42,7 +45,6 @@ class ListenerArgs:
         """
         The set of arguments for constructing a Listener resource.
         :param pulumi.Input[int] listener_port: The listener port. Valid values: `0` to `65535`.
-               
                If you set the value to `0`, the listener listens by port range. If you set the value to `0`, you must specify `StartPort` and `EndPort`.
         :param pulumi.Input[str] listener_protocol: The listening protocol. Valid values: `TCP`, `UDP`, and `TCPSSL`.
         :param pulumi.Input[str] load_balancer_id: The ID of the Network Load Balancer (NLB) instance.
@@ -70,11 +72,11 @@ class ListenerArgs:
                > **NOTE:**  This parameter is required when `ListenerPort` is set to `0`.
         :param pulumi.Input[int] idle_timeout: The timeout period of idle connections. Unit: seconds. Valid values: `1` to `900`. Default value: `900`.
         :param pulumi.Input[str] listener_description: Enter a name for the listener.
-               
                The description must be 2 to 256 characters in length, and can contain letters, digits, commas (,), periods (.), semicolons (;), forward slashes (/), at signs (@), underscores (\\_), and hyphens (-).
         :param pulumi.Input[int] mss: The maximum size of a TCP segment. Unit: bytes. Valid values: `0` to `1500`. `0` specifies that the maximum segment size remains unchanged.
                
                > **NOTE:**  This parameter is supported only by TCP listeners and listeners that use SSL over TCP.
+        :param pulumi.Input['ListenerProxyProtocolConfigArgs'] proxy_protocol_config: The Proxy Protocol is used to carry the VpcId, PrivateLinkEpId, and PrivateLinkEpsId information to the backend server for configuration. See `proxy_protocol_config` below.
         :param pulumi.Input[bool] proxy_protocol_enabled: Specifies whether to use the Proxy protocol to pass client IP addresses to backend servers. Valid values:
         :param pulumi.Input[bool] sec_sensor_enabled: Specifies whether to enable fine-grained monitoring. Valid values:
         :param pulumi.Input[str] security_policy_id: The security policy ID. System security policies and custom security policies are supported.
@@ -112,6 +114,8 @@ class ListenerArgs:
             pulumi.set(__self__, "listener_description", listener_description)
         if mss is not None:
             pulumi.set(__self__, "mss", mss)
+        if proxy_protocol_config is not None:
+            pulumi.set(__self__, "proxy_protocol_config", proxy_protocol_config)
         if proxy_protocol_enabled is not None:
             pulumi.set(__self__, "proxy_protocol_enabled", proxy_protocol_enabled)
         if sec_sensor_enabled is not None:
@@ -130,7 +134,6 @@ class ListenerArgs:
     def listener_port(self) -> pulumi.Input[int]:
         """
         The listener port. Valid values: `0` to `65535`.
-
         If you set the value to `0`, the listener listens by port range. If you set the value to `0`, you must specify `StartPort` and `EndPort`.
         """
         return pulumi.get(self, "listener_port")
@@ -290,7 +293,6 @@ class ListenerArgs:
     def listener_description(self) -> Optional[pulumi.Input[str]]:
         """
         Enter a name for the listener.
-
         The description must be 2 to 256 characters in length, and can contain letters, digits, commas (,), periods (.), semicolons (;), forward slashes (/), at signs (@), underscores (\\_), and hyphens (-).
         """
         return pulumi.get(self, "listener_description")
@@ -313,6 +315,18 @@ class ListenerArgs:
     def mss(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "mss", value)
 
+    @property
+    @pulumi.getter(name="proxyProtocolConfig")
+    def proxy_protocol_config(self) -> Optional[pulumi.Input['ListenerProxyProtocolConfigArgs']]:
+        """
+        The Proxy Protocol is used to carry the VpcId, PrivateLinkEpId, and PrivateLinkEpsId information to the backend server for configuration. See `proxy_protocol_config` below.
+        """
+        return pulumi.get(self, "proxy_protocol_config")
+
+    @proxy_protocol_config.setter
+    def proxy_protocol_config(self, value: Optional[pulumi.Input['ListenerProxyProtocolConfigArgs']]):
+        pulumi.set(self, "proxy_protocol_config", value)
+
     @property
     @pulumi.getter(name="proxyProtocolEnabled")
     def proxy_protocol_enabled(self) -> Optional[pulumi.Input[bool]]:
@@ -408,7 +422,9 @@ class _ListenerState:
                  listener_protocol: Optional[pulumi.Input[str]] = None,
                  load_balancer_id: Optional[pulumi.Input[str]] = None,
                  mss: Optional[pulumi.Input[int]] = None,
+                 proxy_protocol_config: Optional[pulumi.Input['ListenerProxyProtocolConfigArgs']] = None,
                  proxy_protocol_enabled: Optional[pulumi.Input[bool]] = None,
+                 region_id: Optional[pulumi.Input[str]] = None,
                  sec_sensor_enabled: Optional[pulumi.Input[bool]] = None,
                  security_policy_id: Optional[pulumi.Input[str]] = None,
                  server_group_id: Optional[pulumi.Input[str]] = None,
@@ -440,17 +456,18 @@ class _ListenerState:
                > **NOTE:**  This parameter is required when `ListenerPort` is set to `0`.
         :param pulumi.Input[int] idle_timeout: The timeout period of idle connections. Unit: seconds. Valid values: `1` to `900`. Default value: `900`.
         :param pulumi.Input[str] listener_description: Enter a name for the listener.
-               
                The description must be 2 to 256 characters in length, and can contain letters, digits, commas (,), periods (.), semicolons (;), forward slashes (/), at signs (@), underscores (\\_), and hyphens (-).
         :param pulumi.Input[int] listener_port: The listener port. Valid values: `0` to `65535`.
-               
                If you set the value to `0`, the listener listens by port range. If you set the value to `0`, you must specify `StartPort` and `EndPort`.
         :param pulumi.Input[str] listener_protocol: The listening protocol. Valid values: `TCP`, `UDP`, and `TCPSSL`.
         :param pulumi.Input[str] load_balancer_id: The ID of the Network Load Balancer (NLB) instance.
         :param pulumi.Input[int] mss: The maximum size of a TCP segment. Unit: bytes. Valid values: `0` to `1500`. `0` specifies that the maximum segment size remains unchanged.
                
                > **NOTE:**  This parameter is supported only by TCP listeners and listeners that use SSL over TCP.
+        :param pulumi.Input['ListenerProxyProtocolConfigArgs'] proxy_protocol_config: The Proxy Protocol is used to carry the VpcId, PrivateLinkEpId, and PrivateLinkEpsId information to the backend server for configuration. See `proxy_protocol_config` below.
         :param pulumi.Input[bool] proxy_protocol_enabled: Specifies whether to use the Proxy protocol to pass client IP addresses to backend servers. Valid values:
+        :param pulumi.Input[str] region_id: The ID of the region where the Network Load Balancer (NLB) instance is deployed.
+               You can call the [DescribeRegions](https://www.alibabacloud.com/help/en/doc-detail/443657.html) operation to query the most recent region list.
         :param pulumi.Input[bool] sec_sensor_enabled: Specifies whether to enable fine-grained monitoring. Valid values:
         :param pulumi.Input[str] security_policy_id: The security policy ID. System security policies and custom security policies are supported.
                
@@ -490,8 +507,12 @@ class _ListenerState:
             pulumi.set(__self__, "load_balancer_id", load_balancer_id)
         if mss is not None:
             pulumi.set(__self__, "mss", mss)
+        if proxy_protocol_config is not None:
+            pulumi.set(__self__, "proxy_protocol_config", proxy_protocol_config)
         if proxy_protocol_enabled is not None:
             pulumi.set(__self__, "proxy_protocol_enabled", proxy_protocol_enabled)
+        if region_id is not None:
+            pulumi.set(__self__, "region_id", region_id)
         if sec_sensor_enabled is not None:
             pulumi.set(__self__, "sec_sensor_enabled", sec_sensor_enabled)
         if security_policy_id is not None:
@@ -620,7 +641,6 @@ class _ListenerState:
     def listener_description(self) -> Optional[pulumi.Input[str]]:
         """
         Enter a name for the listener.
-
         The description must be 2 to 256 characters in length, and can contain letters, digits, commas (,), periods (.), semicolons (;), forward slashes (/), at signs (@), underscores (\\_), and hyphens (-).
         """
         return pulumi.get(self, "listener_description")
@@ -634,7 +654,6 @@ class _ListenerState:
     def listener_port(self) -> Optional[pulumi.Input[int]]:
         """
         The listener port. Valid values: `0` to `65535`.
-
         If you set the value to `0`, the listener listens by port range. If you set the value to `0`, you must specify `StartPort` and `EndPort`.
         """
         return pulumi.get(self, "listener_port")
@@ -681,6 +700,18 @@ class _ListenerState:
     def mss(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "mss", value)
 
+    @property
+    @pulumi.getter(name="proxyProtocolConfig")
+    def proxy_protocol_config(self) -> Optional[pulumi.Input['ListenerProxyProtocolConfigArgs']]:
+        """
+        The Proxy Protocol is used to carry the VpcId, PrivateLinkEpId, and PrivateLinkEpsId information to the backend server for configuration. See `proxy_protocol_config` below.
+        """
+        return pulumi.get(self, "proxy_protocol_config")
+
+    @proxy_protocol_config.setter
+    def proxy_protocol_config(self, value: Optional[pulumi.Input['ListenerProxyProtocolConfigArgs']]):
+        pulumi.set(self, "proxy_protocol_config", value)
+
     @property
     @pulumi.getter(name="proxyProtocolEnabled")
     def proxy_protocol_enabled(self) -> Optional[pulumi.Input[bool]]:
@@ -693,6 +724,19 @@ class _ListenerState:
     def proxy_protocol_enabled(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "proxy_protocol_enabled", value)
 
+    @property
+    @pulumi.getter(name="regionId")
+    def region_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ID of the region where the Network Load Balancer (NLB) instance is deployed.
+        You can call the [DescribeRegions](https://www.alibabacloud.com/help/en/doc-detail/443657.html) operation to query the most recent region list.
+        """
+        return pulumi.get(self, "region_id")
+
+    @region_id.setter
+    def region_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "region_id", value)
+
     @property
     @pulumi.getter(name="secSensorEnabled")
     def sec_sensor_enabled(self) -> Optional[pulumi.Input[bool]]:
@@ -790,6 +834,7 @@ class Listener(pulumi.CustomResource):
                  listener_protocol: Optional[pulumi.Input[str]] = None,
                  load_balancer_id: Optional[pulumi.Input[str]] = None,
                  mss: Optional[pulumi.Input[int]] = None,
+                 proxy_protocol_config: Optional[pulumi.Input[Union['ListenerProxyProtocolConfigArgs', 'ListenerProxyProtocolConfigArgsDict']]] = None,
                  proxy_protocol_enabled: Optional[pulumi.Input[bool]] = None,
                  sec_sensor_enabled: Optional[pulumi.Input[bool]] = None,
                  security_policy_id: Optional[pulumi.Input[str]] = None,
@@ -799,9 +844,9 @@ class Listener(pulumi.CustomResource):
                  tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  __props__=None):
         """
-        Provides a NLB Listener resource.
+        Provides a Network Load Balancer (NLB) Listener resource.
 
-        For information about NLB Listener and how to use it, see [What is Listener](https://www.alibabacloud.com/help/en/server-load-balancer/latest/api-nlb-2022-04-30-createlistener).
+        For information about Network Load Balancer (NLB) Listener and how to use it, see [What is Listener](https://www.alibabacloud.com/help/en/server-load-balancer/latest/api-nlb-2022-04-30-createlistener).
 
         > **NOTE:** Available since v1.191.0.
 
@@ -899,7 +944,7 @@ class Listener(pulumi.CustomResource):
 
         ## Import
 
-        NLB Listener can be imported using the id, e.g.
+        Network Load Balancer (NLB) Listener can be imported using the id, e.g.
 
         ```sh
         $ pulumi import alicloud:nlb/listener:Listener example <id>
@@ -930,16 +975,15 @@ class Listener(pulumi.CustomResource):
                > **NOTE:**  This parameter is required when `ListenerPort` is set to `0`.
         :param pulumi.Input[int] idle_timeout: The timeout period of idle connections. Unit: seconds. Valid values: `1` to `900`. Default value: `900`.
         :param pulumi.Input[str] listener_description: Enter a name for the listener.
-               
                The description must be 2 to 256 characters in length, and can contain letters, digits, commas (,), periods (.), semicolons (;), forward slashes (/), at signs (@), underscores (\\_), and hyphens (-).
         :param pulumi.Input[int] listener_port: The listener port. Valid values: `0` to `65535`.
-               
                If you set the value to `0`, the listener listens by port range. If you set the value to `0`, you must specify `StartPort` and `EndPort`.
         :param pulumi.Input[str] listener_protocol: The listening protocol. Valid values: `TCP`, `UDP`, and `TCPSSL`.
         :param pulumi.Input[str] load_balancer_id: The ID of the Network Load Balancer (NLB) instance.
         :param pulumi.Input[int] mss: The maximum size of a TCP segment. Unit: bytes. Valid values: `0` to `1500`. `0` specifies that the maximum segment size remains unchanged.
                
                > **NOTE:**  This parameter is supported only by TCP listeners and listeners that use SSL over TCP.
+        :param pulumi.Input[Union['ListenerProxyProtocolConfigArgs', 'ListenerProxyProtocolConfigArgsDict']] proxy_protocol_config: The Proxy Protocol is used to carry the VpcId, PrivateLinkEpId, and PrivateLinkEpsId information to the backend server for configuration. See `proxy_protocol_config` below.
         :param pulumi.Input[bool] proxy_protocol_enabled: Specifies whether to use the Proxy protocol to pass client IP addresses to backend servers. Valid values:
         :param pulumi.Input[bool] sec_sensor_enabled: Specifies whether to enable fine-grained monitoring. Valid values:
         :param pulumi.Input[str] security_policy_id: The security policy ID. System security policies and custom security policies are supported.
@@ -961,9 +1005,9 @@ class Listener(pulumi.CustomResource):
                  args: ListenerArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        Provides a NLB Listener resource.
+        Provides a Network Load Balancer (NLB) Listener resource.
 
-        For information about NLB Listener and how to use it, see [What is Listener](https://www.alibabacloud.com/help/en/server-load-balancer/latest/api-nlb-2022-04-30-createlistener).
+        For information about Network Load Balancer (NLB) Listener and how to use it, see [What is Listener](https://www.alibabacloud.com/help/en/server-load-balancer/latest/api-nlb-2022-04-30-createlistener).
 
         > **NOTE:** Available since v1.191.0.
 
@@ -1061,7 +1105,7 @@ class Listener(pulumi.CustomResource):
 
         ## Import
 
-        NLB Listener can be imported using the id, e.g.
+        Network Load Balancer (NLB) Listener can be imported using the id, e.g.
 
         ```sh
         $ pulumi import alicloud:nlb/listener:Listener example <id>
@@ -1095,6 +1139,7 @@ class Listener(pulumi.CustomResource):
                  listener_protocol: Optional[pulumi.Input[str]] = None,
                  load_balancer_id: Optional[pulumi.Input[str]] = None,
                  mss: Optional[pulumi.Input[int]] = None,
+                 proxy_protocol_config: Optional[pulumi.Input[Union['ListenerProxyProtocolConfigArgs', 'ListenerProxyProtocolConfigArgsDict']]] = None,
                  proxy_protocol_enabled: Optional[pulumi.Input[bool]] = None,
                  sec_sensor_enabled: Optional[pulumi.Input[bool]] = None,
                  security_policy_id: Optional[pulumi.Input[str]] = None,
@@ -1130,6 +1175,7 @@ class Listener(pulumi.CustomResource):
                 raise TypeError("Missing required property 'load_balancer_id'")
             __props__.__dict__["load_balancer_id"] = load_balancer_id
             __props__.__dict__["mss"] = mss
+            __props__.__dict__["proxy_protocol_config"] = proxy_protocol_config
             __props__.__dict__["proxy_protocol_enabled"] = proxy_protocol_enabled
             __props__.__dict__["sec_sensor_enabled"] = sec_sensor_enabled
             __props__.__dict__["security_policy_id"] = security_policy_id
@@ -1139,6 +1185,7 @@ class Listener(pulumi.CustomResource):
             __props__.__dict__["start_port"] = start_port
             __props__.__dict__["status"] = status
             __props__.__dict__["tags"] = tags
+            __props__.__dict__["region_id"] = None
         super(Listener, __self__).__init__(
             'alicloud:nlb/listener:Listener',
             resource_name,
@@ -1162,7 +1209,9 @@ class Listener(pulumi.CustomResource):
             listener_protocol: Optional[pulumi.Input[str]] = None,
             load_balancer_id: Optional[pulumi.Input[str]] = None,
             mss: Optional[pulumi.Input[int]] = None,
+            proxy_protocol_config: Optional[pulumi.Input[Union['ListenerProxyProtocolConfigArgs', 'ListenerProxyProtocolConfigArgsDict']]] = None,
             proxy_protocol_enabled: Optional[pulumi.Input[bool]] = None,
+            region_id: Optional[pulumi.Input[str]] = None,
             sec_sensor_enabled: Optional[pulumi.Input[bool]] = None,
             security_policy_id: Optional[pulumi.Input[str]] = None,
             server_group_id: Optional[pulumi.Input[str]] = None,
@@ -1199,17 +1248,18 @@ class Listener(pulumi.CustomResource):
                > **NOTE:**  This parameter is required when `ListenerPort` is set to `0`.
         :param pulumi.Input[int] idle_timeout: The timeout period of idle connections. Unit: seconds. Valid values: `1` to `900`. Default value: `900`.
         :param pulumi.Input[str] listener_description: Enter a name for the listener.
-               
                The description must be 2 to 256 characters in length, and can contain letters, digits, commas (,), periods (.), semicolons (;), forward slashes (/), at signs (@), underscores (\\_), and hyphens (-).
         :param pulumi.Input[int] listener_port: The listener port. Valid values: `0` to `65535`.
-               
                If you set the value to `0`, the listener listens by port range. If you set the value to `0`, you must specify `StartPort` and `EndPort`.
         :param pulumi.Input[str] listener_protocol: The listening protocol. Valid values: `TCP`, `UDP`, and `TCPSSL`.
         :param pulumi.Input[str] load_balancer_id: The ID of the Network Load Balancer (NLB) instance.
         :param pulumi.Input[int] mss: The maximum size of a TCP segment. Unit: bytes. Valid values: `0` to `1500`. `0` specifies that the maximum segment size remains unchanged.
                
                > **NOTE:**  This parameter is supported only by TCP listeners and listeners that use SSL over TCP.
+        :param pulumi.Input[Union['ListenerProxyProtocolConfigArgs', 'ListenerProxyProtocolConfigArgsDict']] proxy_protocol_config: The Proxy Protocol is used to carry the VpcId, PrivateLinkEpId, and PrivateLinkEpsId information to the backend server for configuration. See `proxy_protocol_config` below.
         :param pulumi.Input[bool] proxy_protocol_enabled: Specifies whether to use the Proxy protocol to pass client IP addresses to backend servers. Valid values:
+        :param pulumi.Input[str] region_id: The ID of the region where the Network Load Balancer (NLB) instance is deployed.
+               You can call the [DescribeRegions](https://www.alibabacloud.com/help/en/doc-detail/443657.html) operation to query the most recent region list.
         :param pulumi.Input[bool] sec_sensor_enabled: Specifies whether to enable fine-grained monitoring. Valid values:
         :param pulumi.Input[str] security_policy_id: The security policy ID. System security policies and custom security policies are supported.
                
@@ -1240,7 +1290,9 @@ class Listener(pulumi.CustomResource):
         __props__.__dict__["listener_protocol"] = listener_protocol
         __props__.__dict__["load_balancer_id"] = load_balancer_id
         __props__.__dict__["mss"] = mss
+        __props__.__dict__["proxy_protocol_config"] = proxy_protocol_config
         __props__.__dict__["proxy_protocol_enabled"] = proxy_protocol_enabled
+        __props__.__dict__["region_id"] = region_id
         __props__.__dict__["sec_sensor_enabled"] = sec_sensor_enabled
         __props__.__dict__["security_policy_id"] = security_policy_id
         __props__.__dict__["server_group_id"] = server_group_id
@@ -1332,7 +1384,6 @@ class Listener(pulumi.CustomResource):
     def listener_description(self) -> pulumi.Output[Optional[str]]:
         """
         Enter a name for the listener.
-
         The description must be 2 to 256 characters in length, and can contain letters, digits, commas (,), periods (.), semicolons (;), forward slashes (/), at signs (@), underscores (\\_), and hyphens (-).
         """
         return pulumi.get(self, "listener_description")
@@ -1342,7 +1393,6 @@ class Listener(pulumi.CustomResource):
     def listener_port(self) -> pulumi.Output[int]:
         """
         The listener port. Valid values: `0` to `65535`.
-
         If you set the value to `0`, the listener listens by port range. If you set the value to `0`, you must specify `StartPort` and `EndPort`.
         """
         return pulumi.get(self, "listener_port")
@@ -1373,6 +1423,14 @@ class Listener(pulumi.CustomResource):
         """
         return pulumi.get(self, "mss")
 
+    @property
+    @pulumi.getter(name="proxyProtocolConfig")
+    def proxy_protocol_config(self) -> pulumi.Output['outputs.ListenerProxyProtocolConfig']:
+        """
+        The Proxy Protocol is used to carry the VpcId, PrivateLinkEpId, and PrivateLinkEpsId information to the backend server for configuration. See `proxy_protocol_config` below.
+        """
+        return pulumi.get(self, "proxy_protocol_config")
+
     @property
     @pulumi.getter(name="proxyProtocolEnabled")
     def proxy_protocol_enabled(self) -> pulumi.Output[bool]:
@@ -1381,6 +1439,15 @@ class Listener(pulumi.CustomResource):
         """
         return pulumi.get(self, "proxy_protocol_enabled")
 
+    @property
+    @pulumi.getter(name="regionId")
+    def region_id(self) -> pulumi.Output[str]:
+        """
+        The ID of the region where the Network Load Balancer (NLB) instance is deployed.
+        You can call the [DescribeRegions](https://www.alibabacloud.com/help/en/doc-detail/443657.html) operation to query the most recent region list.
+        """
+        return pulumi.get(self, "region_id")
+
     @property
     @pulumi.getter(name="secSensorEnabled")
     def sec_sensor_enabled(self) -> pulumi.Output[bool]: