pulumi-alicloud 3.75.0a1741324537__py3-none-any.whl → 3.76.0__py3-none-any.whl

pulumi_alicloud/nlb/outputs.py

@@ -16,6 +16,7 @@ from .. import _utilities
 from . import outputs
 
 __all__ = [
+    'ListenerProxyProtocolConfig',
     'LoadBalancerDeletionProtectionConfig',
     'LoadBalancerModificationProtectionConfig',
     'LoadBalancerZoneMapping',
@@ -31,6 +32,70 @@ __all__ = [
     'GetZonesZoneResult',
 ]
 
+@pulumi.output_type
+class ListenerProxyProtocolConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "proxyProtocolConfigPrivateLinkEpIdEnabled":
+            suggest = "proxy_protocol_config_private_link_ep_id_enabled"
+        elif key == "proxyProtocolConfigPrivateLinkEpsIdEnabled":
+            suggest = "proxy_protocol_config_private_link_eps_id_enabled"
+        elif key == "proxyProtocolConfigVpcIdEnabled":
+            suggest = "proxy_protocol_config_vpc_id_enabled"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ListenerProxyProtocolConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ListenerProxyProtocolConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ListenerProxyProtocolConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 proxy_protocol_config_private_link_ep_id_enabled: Optional[bool] = None,
+                 proxy_protocol_config_private_link_eps_id_enabled: Optional[bool] = None,
+                 proxy_protocol_config_vpc_id_enabled: Optional[bool] = None):
+        """
+        :param bool proxy_protocol_config_private_link_ep_id_enabled: Whether to enable carrying PrivateLinkEpId to backend servers through Proxy Protocol.
+        :param bool proxy_protocol_config_private_link_eps_id_enabled: Whether to enable carrying PrivateLinkEpsId to backend servers through the Proxy Protocol.
+        :param 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[bool]:
+        """
+        Whether to enable carrying PrivateLinkEpId to backend servers through Proxy Protocol.
+        """
+        return pulumi.get(self, "proxy_protocol_config_private_link_ep_id_enabled")
+
+    @property
+    @pulumi.getter(name="proxyProtocolConfigPrivateLinkEpsIdEnabled")
+    def proxy_protocol_config_private_link_eps_id_enabled(self) -> Optional[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")
+
+    @property
+    @pulumi.getter(name="proxyProtocolConfigVpcIdEnabled")
+    def proxy_protocol_config_vpc_id_enabled(self) -> Optional[bool]:
+        """
+        Whether to enable carrying VpcId to backend servers through Proxy Protocol.
+        """
+        return pulumi.get(self, "proxy_protocol_config_vpc_id_enabled")
+
+
 @pulumi.output_type
 class LoadBalancerDeletionProtectionConfig(dict):
     @staticmethod
@@ -182,8 +247,12 @@ class LoadBalancerZoneMapping(dict):
             suggest = "allocation_id"
         elif key == "eniId":
             suggest = "eni_id"
+        elif key == "ipv4LocalAddresses":
+            suggest = "ipv4_local_addresses"
         elif key == "ipv6Address":
             suggest = "ipv6_address"
+        elif key == "ipv6LocalAddresses":
+            suggest = "ipv6_local_addresses"
         elif key == "privateIpv4Address":
             suggest = "private_ipv4_address"
         elif key == "publicIpv4Address":
@@ -205,20 +274,23 @@ class LoadBalancerZoneMapping(dict):
                  zone_id: str,
                  allocation_id: Optional[str] = None,
                  eni_id: Optional[str] = None,
+                 ipv4_local_addresses: Optional[Sequence[str]] = None,
                  ipv6_address: Optional[str] = None,
+                 ipv6_local_addresses: Optional[Sequence[str]] = None,
                  private_ipv4_address: Optional[str] = None,
                  public_ipv4_address: Optional[str] = None,
                  status: Optional[str] = None):
         """
         :param str vswitch_id: The vSwitch in the zone. You can specify only one vSwitch (subnet) in each zone of an NLB instance. You must add at least two zones. You can add a maximum of 10 zones.
         :param str zone_id: The ID of the zone of the NLB instance. You must add at least two zones. You can add a maximum of 10 zones.
-               
                You can call the [DescribeZones](https://www.alibabacloud.com/help/en/doc-detail/443890.html) operation to query the most recent zone list.
         :param str allocation_id: The ID of the elastic IP address (EIP) that is associated with the Internet-facing NLB instance. You can specify one EIP for each zone. You must add at least two zones. You can add a maximum of 10 zones.
         :param str eni_id: The ID of the elastic network interface (ENI).
+        :param Sequence[str] ipv4_local_addresses: IPv4 Local address list. The list of addresses that NLB interacts with backend services.
         :param str ipv6_address: The IPv6 address of the NLB instance.
+        :param Sequence[str] ipv6_local_addresses: IPv6 Local address list. The list of addresses that NLB interacts with backend services.
         :param str private_ipv4_address: The private IP address. You must add at least two zones. You can add a maximum of 10 zones.
-        :param str public_ipv4_address: Public IPv4 address of a network-based server load balancer instance.
+        :param str public_ipv4_address: The public IPv4 address of the NLB instance.
         :param str status: Zone Status
         """
         pulumi.set(__self__, "vswitch_id", vswitch_id)
@@ -227,8 +299,12 @@ class LoadBalancerZoneMapping(dict):
             pulumi.set(__self__, "allocation_id", allocation_id)
         if eni_id is not None:
             pulumi.set(__self__, "eni_id", eni_id)
+        if ipv4_local_addresses is not None:
+            pulumi.set(__self__, "ipv4_local_addresses", ipv4_local_addresses)
         if ipv6_address is not None:
             pulumi.set(__self__, "ipv6_address", ipv6_address)
+        if ipv6_local_addresses is not None:
+            pulumi.set(__self__, "ipv6_local_addresses", ipv6_local_addresses)
         if private_ipv4_address is not None:
             pulumi.set(__self__, "private_ipv4_address", private_ipv4_address)
         if public_ipv4_address is not None:
@@ -249,7 +325,6 @@ class LoadBalancerZoneMapping(dict):
     def zone_id(self) -> str:
         """
         The ID of the zone of the NLB instance. You must add at least two zones. You can add a maximum of 10 zones.
-
         You can call the [DescribeZones](https://www.alibabacloud.com/help/en/doc-detail/443890.html) operation to query the most recent zone list.
         """
         return pulumi.get(self, "zone_id")
@@ -270,6 +345,14 @@ class LoadBalancerZoneMapping(dict):
         """
         return pulumi.get(self, "eni_id")
 
+    @property
+    @pulumi.getter(name="ipv4LocalAddresses")
+    def ipv4_local_addresses(self) -> Optional[Sequence[str]]:
+        """
+        IPv4 Local address list. The list of addresses that NLB interacts with backend services.
+        """
+        return pulumi.get(self, "ipv4_local_addresses")
+
     @property
     @pulumi.getter(name="ipv6Address")
     def ipv6_address(self) -> Optional[str]:
@@ -278,6 +361,14 @@ class LoadBalancerZoneMapping(dict):
         """
         return pulumi.get(self, "ipv6_address")
 
+    @property
+    @pulumi.getter(name="ipv6LocalAddresses")
+    def ipv6_local_addresses(self) -> Optional[Sequence[str]]:
+        """
+        IPv6 Local address list. The list of addresses that NLB interacts with backend services.
+        """
+        return pulumi.get(self, "ipv6_local_addresses")
+
     @property
     @pulumi.getter(name="privateIpv4Address")
     def private_ipv4_address(self) -> Optional[str]:
@@ -290,7 +381,7 @@ class LoadBalancerZoneMapping(dict):
     @pulumi.getter(name="publicIpv4Address")
     def public_ipv4_address(self) -> Optional[str]:
         """
-        Public IPv4 address of a network-based server load balancer instance.
+        The public IPv4 address of the NLB instance.
         """
         return pulumi.get(self, "public_ipv4_address")
 
@@ -316,10 +407,14 @@ class ServerGroupHealthCheck(dict):
             suggest = "health_check_domain"
         elif key == "healthCheckEnabled":
             suggest = "health_check_enabled"
+        elif key == "healthCheckExp":
+            suggest = "health_check_exp"
         elif key == "healthCheckHttpCodes":
             suggest = "health_check_http_codes"
         elif key == "healthCheckInterval":
             suggest = "health_check_interval"
+        elif key == "healthCheckReq":
+            suggest = "health_check_req"
         elif key == "healthCheckType":
             suggest = "health_check_type"
         elif key == "healthCheckUrl":
@@ -347,8 +442,10 @@ class ServerGroupHealthCheck(dict):
                  health_check_connect_timeout: Optional[int] = None,
                  health_check_domain: Optional[str] = None,
                  health_check_enabled: Optional[bool] = None,
+                 health_check_exp: Optional[str] = None,
                  health_check_http_codes: Optional[Sequence[str]] = None,
                  health_check_interval: Optional[int] = None,
+                 health_check_req: Optional[str] = None,
                  health_check_type: Optional[str] = None,
                  health_check_url: Optional[str] = None,
                  healthy_threshold: Optional[int] = None,
@@ -356,22 +453,20 @@ class ServerGroupHealthCheck(dict):
                  unhealthy_threshold: Optional[int] = None):
         """
         :param 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 int health_check_connect_timeout: The maximum timeout period of a health check. Unit: seconds. Valid values: `1` to `300`. Default value: `5`.
         :param 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 bool health_check_enabled: Specifies whether to enable the health check feature. Valid values:
+        :param str health_check_exp: health check response character string. The value contains a maximum of 512 characters
         :param Sequence[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 int health_check_interval: The interval at which health checks are performed. Unit: seconds.
-               
                Valid values: `5` to `50`.
-               
                Default value: `10`.
+        :param str health_check_req: UDP healthy check request string, the value is a character string of 512 characters
         :param str health_check_type: The protocol that you want to use for health checks. Valid values: `TCP` (default) and `HTTP`.
         :param str health_check_url: The path to which health check requests are sent.
                
@@ -379,17 +474,13 @@ class ServerGroupHealthCheck(dict):
                
                > **NOTE:**  This parameter takes effect only when `HealthCheckType` is set to `HTTP`.
         :param 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 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 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:
@@ -400,10 +491,14 @@ class ServerGroupHealthCheck(dict):
             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:
@@ -420,9 +515,7 @@ class ServerGroupHealthCheck(dict):
     def health_check_connect_port(self) -> Optional[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")
@@ -452,6 +545,14 @@ class ServerGroupHealthCheck(dict):
         """
         return pulumi.get(self, "health_check_enabled")
 
+    @property
+    @pulumi.getter(name="healthCheckExp")
+    def health_check_exp(self) -> Optional[str]:
+        """
+        health check response character string. The value contains a maximum of 512 characters
+        """
+        return pulumi.get(self, "health_check_exp")
+
     @property
     @pulumi.getter(name="healthCheckHttpCodes")
     def health_check_http_codes(self) -> Optional[Sequence[str]]:
@@ -467,13 +568,19 @@ class ServerGroupHealthCheck(dict):
     def health_check_interval(self) -> Optional[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")
 
+    @property
+    @pulumi.getter(name="healthCheckReq")
+    def health_check_req(self) -> Optional[str]:
+        """
+        UDP healthy check request string, the value is a character string of 512 characters
+        """
+        return pulumi.get(self, "health_check_req")
+
     @property
     @pulumi.getter(name="healthCheckType")
     def health_check_type(self) -> Optional[str]:
@@ -499,9 +606,7 @@ class ServerGroupHealthCheck(dict):
     def healthy_threshold(self) -> Optional[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")
@@ -521,9 +626,7 @@ class ServerGroupHealthCheck(dict):
     def unhealthy_threshold(self) -> Optional[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/server_group.py

@@ -38,7 +38,6 @@ class ServerGroupArgs:
         """
         The set of arguments for constructing a ServerGroup resource.
         :param pulumi.Input[str] server_group_name: The new name of the server group.
-               
                The name must be 2 to 128 characters in length, and can contain letters, digits, periods (.), underscores (\\_), and hyphens (-). The name must start with a letter.
         :param pulumi.Input[str] vpc_id: The ID of the virtual private cloud (VPC) to which the server group belongs.
                
@@ -54,18 +53,20 @@ class ServerGroupArgs:
         :param pulumi.Input['ServerGroupHealthCheckArgs'] health_check: Health check configuration information. See `health_check` below.
         :param pulumi.Input[bool] preserve_client_ip_enabled: Specifies whether to enable client IP preservation. Valid values:
         :param pulumi.Input[str] protocol: The protocol used to forward requests to the backend servers. Valid values:
+               
                - `TCP` (default)
                - `UDP`
                - `TCPSSL`
         :param pulumi.Input[str] resource_group_id: The ID of the new resource group.
-               
                You can log on to the [Resource Management console](https://resourcemanager.console.aliyun.com/resource-groups) to view resource group IDs.
         :param pulumi.Input[str] scheduler: The scheduling algorithm. Valid values:
+               
                - **Wrr:** The weighted round-robin algorithm is used. Backend servers with higher weights receive more requests than backend servers with lower weights. This is the default value.
                - **rr:** The round-robin algorithm is used. Requests are forwarded to backend servers in sequence.
                - **sch:** Source IP hashing is used. Requests from the same source IP address are forwarded to the same backend server.
                - **tch:** Four-element hashing is used. It specifies consistent hashing that is based on four factors: source IP address, destination IP address, source port, and destination port. Requests that contain the same information based on the four factors are forwarded to the same backend server.
         :param pulumi.Input[str] server_group_type: The type of server group. Valid values:
+               
                - `Instance`: allows you to add servers of the `Ecs`, `Eni`, or `Eci` type. This is the default value.
                - `Ip`: allows you to add servers by specifying IP addresses.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Label.
@@ -105,7 +106,6 @@ class ServerGroupArgs:
     def server_group_name(self) -> pulumi.Input[str]:
         """
         The new name of the server group.
-
         The name must be 2 to 128 characters in length, and can contain letters, digits, periods (.), underscores (\\_), and hyphens (-). The name must start with a letter.
         """
         return pulumi.get(self, "server_group_name")
@@ -221,6 +221,7 @@ class ServerGroupArgs:
     def protocol(self) -> Optional[pulumi.Input[str]]:
         """
         The protocol used to forward requests to the backend servers. Valid values:
+
         - `TCP` (default)
         - `UDP`
         - `TCPSSL`
@@ -236,7 +237,6 @@ class ServerGroupArgs:
     def resource_group_id(self) -> Optional[pulumi.Input[str]]:
         """
         The ID of the new resource group.
-
         You can log on to the [Resource Management console](https://resourcemanager.console.aliyun.com/resource-groups) to view resource group IDs.
         """
         return pulumi.get(self, "resource_group_id")
@@ -250,6 +250,7 @@ class ServerGroupArgs:
     def scheduler(self) -> Optional[pulumi.Input[str]]:
         """
         The scheduling algorithm. Valid values:
+
         - **Wrr:** The weighted round-robin algorithm is used. Backend servers with higher weights receive more requests than backend servers with lower weights. This is the default value.
         - **rr:** The round-robin algorithm is used. Requests are forwarded to backend servers in sequence.
         - **sch:** Source IP hashing is used. Requests from the same source IP address are forwarded to the same backend server.
@@ -266,6 +267,7 @@ class ServerGroupArgs:
     def server_group_type(self) -> Optional[pulumi.Input[str]]:
         """
         The type of server group. Valid values:
+
         - `Instance`: allows you to add servers of the `Ecs`, `Eni`, or `Eci` type. This is the default value.
         - `Ip`: allows you to add servers by specifying IP addresses.
         """
@@ -299,6 +301,7 @@ class _ServerGroupState:
                  health_check: Optional[pulumi.Input['ServerGroupHealthCheckArgs']] = None,
                  preserve_client_ip_enabled: Optional[pulumi.Input[bool]] = None,
                  protocol: Optional[pulumi.Input[str]] = None,
+                 region_id: Optional[pulumi.Input[str]] = None,
                  resource_group_id: Optional[pulumi.Input[str]] = None,
                  scheduler: Optional[pulumi.Input[str]] = None,
                  server_group_name: Optional[pulumi.Input[str]] = None,
@@ -316,21 +319,23 @@ class _ServerGroupState:
         :param pulumi.Input['ServerGroupHealthCheckArgs'] health_check: Health check configuration information. See `health_check` below.
         :param pulumi.Input[bool] preserve_client_ip_enabled: Specifies whether to enable client IP preservation. Valid values:
         :param pulumi.Input[str] protocol: The protocol used to forward requests to the backend servers. Valid values:
+               
                - `TCP` (default)
                - `UDP`
                - `TCPSSL`
+        :param pulumi.Input[str] region_id: The ID of the region where the NLB instance is deployed.
         :param pulumi.Input[str] resource_group_id: The ID of the new resource group.
-               
                You can log on to the [Resource Management console](https://resourcemanager.console.aliyun.com/resource-groups) to view resource group IDs.
         :param pulumi.Input[str] scheduler: The scheduling algorithm. Valid values:
+               
                - **Wrr:** The weighted round-robin algorithm is used. Backend servers with higher weights receive more requests than backend servers with lower weights. This is the default value.
                - **rr:** The round-robin algorithm is used. Requests are forwarded to backend servers in sequence.
                - **sch:** Source IP hashing is used. Requests from the same source IP address are forwarded to the same backend server.
                - **tch:** Four-element hashing is used. It specifies consistent hashing that is based on four factors: source IP address, destination IP address, source port, and destination port. Requests that contain the same information based on the four factors are forwarded to the same backend server.
         :param pulumi.Input[str] server_group_name: The new name of the server group.
-               
                The name must be 2 to 128 characters in length, and can contain letters, digits, periods (.), underscores (\\_), and hyphens (-). The name must start with a letter.
         :param pulumi.Input[str] server_group_type: The type of server group. Valid values:
+               
                - `Instance`: allows you to add servers of the `Ecs`, `Eni`, or `Eci` type. This is the default value.
                - `Ip`: allows you to add servers by specifying IP addresses.
         :param pulumi.Input[str] status: Server group status. Value:
@@ -361,6 +366,8 @@ class _ServerGroupState:
             pulumi.set(__self__, "preserve_client_ip_enabled", preserve_client_ip_enabled)
         if protocol is not None:
             pulumi.set(__self__, "protocol", protocol)
+        if region_id is not None:
+            pulumi.set(__self__, "region_id", region_id)
         if resource_group_id is not None:
             pulumi.set(__self__, "resource_group_id", resource_group_id)
         if scheduler is not None:
@@ -466,6 +473,7 @@ class _ServerGroupState:
     def protocol(self) -> Optional[pulumi.Input[str]]:
         """
         The protocol used to forward requests to the backend servers. Valid values:
+
         - `TCP` (default)
         - `UDP`
         - `TCPSSL`
@@ -476,12 +484,23 @@ class _ServerGroupState:
     def protocol(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "protocol", value)
 
+    @property
+    @pulumi.getter(name="regionId")
+    def region_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ID of the region where the NLB instance is deployed.
+        """
+        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="resourceGroupId")
     def resource_group_id(self) -> Optional[pulumi.Input[str]]:
         """
         The ID of the new resource group.
-
         You can log on to the [Resource Management console](https://resourcemanager.console.aliyun.com/resource-groups) to view resource group IDs.
         """
         return pulumi.get(self, "resource_group_id")
@@ -495,6 +514,7 @@ class _ServerGroupState:
     def scheduler(self) -> Optional[pulumi.Input[str]]:
         """
         The scheduling algorithm. Valid values:
+
         - **Wrr:** The weighted round-robin algorithm is used. Backend servers with higher weights receive more requests than backend servers with lower weights. This is the default value.
         - **rr:** The round-robin algorithm is used. Requests are forwarded to backend servers in sequence.
         - **sch:** Source IP hashing is used. Requests from the same source IP address are forwarded to the same backend server.
@@ -511,7 +531,6 @@ class _ServerGroupState:
     def server_group_name(self) -> Optional[pulumi.Input[str]]:
         """
         The new name of the server group.
-
         The name must be 2 to 128 characters in length, and can contain letters, digits, periods (.), underscores (\\_), and hyphens (-). The name must start with a letter.
         """
         return pulumi.get(self, "server_group_name")
@@ -525,6 +544,7 @@ class _ServerGroupState:
     def server_group_type(self) -> Optional[pulumi.Input[str]]:
         """
         The type of server group. Valid values:
+
         - `Instance`: allows you to add servers of the `Ecs`, `Eni`, or `Eci` type. This is the default value.
         - `Ip`: allows you to add servers by specifying IP addresses.
         """
@@ -597,9 +617,9 @@ class ServerGroup(pulumi.CustomResource):
                  vpc_id: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         """
-        Provides a NLB Server Group resource.
+        Provides a Network Load Balancer (NLB) Server Group resource.
 
-        For information about NLB Server Group and how to use it, see [What is Server Group](https://www.alibabacloud.com/help/en/server-load-balancer/latest/createservergroup-nlb).
+        For information about Network Load Balancer (NLB) Server Group and how to use it, see [What is Server Group](https://www.alibabacloud.com/help/en/server-load-balancer/latest/createservergroup-nlb).
 
         > **NOTE:** Available since v1.186.0.
 
@@ -652,7 +672,7 @@ class ServerGroup(pulumi.CustomResource):
 
         ## Import
 
-        NLB Server Group can be imported using the id, e.g.
+        Network Load Balancer (NLB) Server Group can be imported using the id, e.g.
 
         ```sh
         $ pulumi import alicloud:nlb/serverGroup:ServerGroup example <id>
@@ -668,21 +688,22 @@ class ServerGroup(pulumi.CustomResource):
         :param pulumi.Input[Union['ServerGroupHealthCheckArgs', 'ServerGroupHealthCheckArgsDict']] health_check: Health check configuration information. See `health_check` below.
         :param pulumi.Input[bool] preserve_client_ip_enabled: Specifies whether to enable client IP preservation. Valid values:
         :param pulumi.Input[str] protocol: The protocol used to forward requests to the backend servers. Valid values:
+               
                - `TCP` (default)
                - `UDP`
                - `TCPSSL`
         :param pulumi.Input[str] resource_group_id: The ID of the new resource group.
-               
                You can log on to the [Resource Management console](https://resourcemanager.console.aliyun.com/resource-groups) to view resource group IDs.
         :param pulumi.Input[str] scheduler: The scheduling algorithm. Valid values:
+               
                - **Wrr:** The weighted round-robin algorithm is used. Backend servers with higher weights receive more requests than backend servers with lower weights. This is the default value.
                - **rr:** The round-robin algorithm is used. Requests are forwarded to backend servers in sequence.
                - **sch:** Source IP hashing is used. Requests from the same source IP address are forwarded to the same backend server.
                - **tch:** Four-element hashing is used. It specifies consistent hashing that is based on four factors: source IP address, destination IP address, source port, and destination port. Requests that contain the same information based on the four factors are forwarded to the same backend server.
         :param pulumi.Input[str] server_group_name: The new name of the server group.
-               
                The name must be 2 to 128 characters in length, and can contain letters, digits, periods (.), underscores (\\_), and hyphens (-). The name must start with a letter.
         :param pulumi.Input[str] server_group_type: The type of server group. Valid values:
+               
                - `Instance`: allows you to add servers of the `Ecs`, `Eni`, or `Eci` type. This is the default value.
                - `Ip`: allows you to add servers by specifying IP addresses.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Label.
@@ -700,9 +721,9 @@ class ServerGroup(pulumi.CustomResource):
                  args: ServerGroupArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        Provides a NLB Server Group resource.
+        Provides a Network Load Balancer (NLB) Server Group resource.
 
-        For information about NLB Server Group and how to use it, see [What is Server Group](https://www.alibabacloud.com/help/en/server-load-balancer/latest/createservergroup-nlb).
+        For information about Network Load Balancer (NLB) Server Group and how to use it, see [What is Server Group](https://www.alibabacloud.com/help/en/server-load-balancer/latest/createservergroup-nlb).
 
         > **NOTE:** Available since v1.186.0.
 
@@ -755,7 +776,7 @@ class ServerGroup(pulumi.CustomResource):
 
         ## Import
 
-        NLB Server Group can be imported using the id, e.g.
+        Network Load Balancer (NLB) Server Group can be imported using the id, e.g.
 
         ```sh
         $ pulumi import alicloud:nlb/serverGroup:ServerGroup example <id>
@@ -817,6 +838,7 @@ class ServerGroup(pulumi.CustomResource):
             if vpc_id is None and not opts.urn:
                 raise TypeError("Missing required property 'vpc_id'")
             __props__.__dict__["vpc_id"] = vpc_id
+            __props__.__dict__["region_id"] = None
             __props__.__dict__["status"] = None
         super(ServerGroup, __self__).__init__(
             'alicloud:nlb/serverGroup:ServerGroup',
@@ -836,6 +858,7 @@ class ServerGroup(pulumi.CustomResource):
             health_check: Optional[pulumi.Input[Union['ServerGroupHealthCheckArgs', 'ServerGroupHealthCheckArgsDict']]] = None,
             preserve_client_ip_enabled: Optional[pulumi.Input[bool]] = None,
             protocol: Optional[pulumi.Input[str]] = None,
+            region_id: Optional[pulumi.Input[str]] = None,
             resource_group_id: Optional[pulumi.Input[str]] = None,
             scheduler: Optional[pulumi.Input[str]] = None,
             server_group_name: Optional[pulumi.Input[str]] = None,
@@ -858,21 +881,23 @@ class ServerGroup(pulumi.CustomResource):
         :param pulumi.Input[Union['ServerGroupHealthCheckArgs', 'ServerGroupHealthCheckArgsDict']] health_check: Health check configuration information. See `health_check` below.
         :param pulumi.Input[bool] preserve_client_ip_enabled: Specifies whether to enable client IP preservation. Valid values:
         :param pulumi.Input[str] protocol: The protocol used to forward requests to the backend servers. Valid values:
+               
                - `TCP` (default)
                - `UDP`
                - `TCPSSL`
+        :param pulumi.Input[str] region_id: The ID of the region where the NLB instance is deployed.
         :param pulumi.Input[str] resource_group_id: The ID of the new resource group.
-               
                You can log on to the [Resource Management console](https://resourcemanager.console.aliyun.com/resource-groups) to view resource group IDs.
         :param pulumi.Input[str] scheduler: The scheduling algorithm. Valid values:
+               
                - **Wrr:** The weighted round-robin algorithm is used. Backend servers with higher weights receive more requests than backend servers with lower weights. This is the default value.
                - **rr:** The round-robin algorithm is used. Requests are forwarded to backend servers in sequence.
                - **sch:** Source IP hashing is used. Requests from the same source IP address are forwarded to the same backend server.
                - **tch:** Four-element hashing is used. It specifies consistent hashing that is based on four factors: source IP address, destination IP address, source port, and destination port. Requests that contain the same information based on the four factors are forwarded to the same backend server.
         :param pulumi.Input[str] server_group_name: The new name of the server group.
-               
                The name must be 2 to 128 characters in length, and can contain letters, digits, periods (.), underscores (\\_), and hyphens (-). The name must start with a letter.
         :param pulumi.Input[str] server_group_type: The type of server group. Valid values:
+               
                - `Instance`: allows you to add servers of the `Ecs`, `Eni`, or `Eci` type. This is the default value.
                - `Ip`: allows you to add servers by specifying IP addresses.
         :param pulumi.Input[str] status: Server group status. Value:
@@ -896,6 +921,7 @@ class ServerGroup(pulumi.CustomResource):
         __props__.__dict__["health_check"] = health_check
         __props__.__dict__["preserve_client_ip_enabled"] = preserve_client_ip_enabled
         __props__.__dict__["protocol"] = protocol
+        __props__.__dict__["region_id"] = region_id
         __props__.__dict__["resource_group_id"] = resource_group_id
         __props__.__dict__["scheduler"] = scheduler
         __props__.__dict__["server_group_name"] = server_group_name
@@ -967,18 +993,26 @@ class ServerGroup(pulumi.CustomResource):
     def protocol(self) -> pulumi.Output[str]:
         """
         The protocol used to forward requests to the backend servers. Valid values:
+
         - `TCP` (default)
         - `UDP`
         - `TCPSSL`
         """
         return pulumi.get(self, "protocol")
 
+    @property
+    @pulumi.getter(name="regionId")
+    def region_id(self) -> pulumi.Output[str]:
+        """
+        The ID of the region where the NLB instance is deployed.
+        """
+        return pulumi.get(self, "region_id")
+
     @property
     @pulumi.getter(name="resourceGroupId")
     def resource_group_id(self) -> pulumi.Output[str]:
         """
         The ID of the new resource group.
-
         You can log on to the [Resource Management console](https://resourcemanager.console.aliyun.com/resource-groups) to view resource group IDs.
         """
         return pulumi.get(self, "resource_group_id")
@@ -988,6 +1022,7 @@ class ServerGroup(pulumi.CustomResource):
     def scheduler(self) -> pulumi.Output[str]:
         """
         The scheduling algorithm. Valid values:
+
         - **Wrr:** The weighted round-robin algorithm is used. Backend servers with higher weights receive more requests than backend servers with lower weights. This is the default value.
         - **rr:** The round-robin algorithm is used. Requests are forwarded to backend servers in sequence.
         - **sch:** Source IP hashing is used. Requests from the same source IP address are forwarded to the same backend server.
@@ -1000,7 +1035,6 @@ class ServerGroup(pulumi.CustomResource):
     def server_group_name(self) -> pulumi.Output[str]:
         """
         The new name of the server group.
-
         The name must be 2 to 128 characters in length, and can contain letters, digits, periods (.), underscores (\\_), and hyphens (-). The name must start with a letter.
         """
         return pulumi.get(self, "server_group_name")
@@ -1010,6 +1044,7 @@ class ServerGroup(pulumi.CustomResource):
     def server_group_type(self) -> pulumi.Output[str]:
         """
         The type of server group. Valid values:
+
         - `Instance`: allows you to add servers of the `Ecs`, `Eni`, or `Eci` type. This is the default value.
         - `Ip`: allows you to add servers by specifying IP addresses.
         """