pulumi-oci 1.35.0a1715306721__py3-none-any.whl → 1.36.0__py3-none-any.whl

pulumi_oci/loadbalancer/_inputs.py

@@ -27,6 +27,7 @@ __all__ = [
     'PathRouteSetPathRoutePathMatchTypeArgs',
     'RuleSetItemArgs',
     'RuleSetItemConditionArgs',
+    'RuleSetItemIpMaxConnectionArgs',
     'RuleSetItemRedirectUriArgs',
     'GetBackendSetsFilterArgs',
     'GetBackendsFilterArgs',
@@ -50,21 +51,27 @@ class BackendSetBackendArgs:
                  port: pulumi.Input[int],
                  backup: Optional[pulumi.Input[bool]] = None,
                  drain: Optional[pulumi.Input[bool]] = None,
+                 max_connections: Optional[pulumi.Input[int]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  offline: Optional[pulumi.Input[bool]] = None,
                  weight: Optional[pulumi.Input[int]] = None):
         """
-        :param pulumi.Input[str] ip_address: The IP address of the backend server.  Example: `10.0.0.3`
+        :param pulumi.Input[str] ip_address: (Updatable) The IP address of the backend server.  Example: `10.0.0.3`
         :param pulumi.Input[int] port: (Updatable) The backend server port against which to run the health check. If the port is not specified, the load balancer uses the port information from the `Backend` object.  Example: `8080`
-        :param pulumi.Input[bool] backup: Whether the load balancer should treat this server as a backup unit. If `true`, the load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "backup" fail the health check policy.
-        :param pulumi.Input[bool] drain: Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
+        :param pulumi.Input[bool] backup: (Updatable) Whether the load balancer should treat this server as a backup unit. If `true`, the load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "backup" fail the health check policy.
+               
+               **Note:** You cannot add a backend server marked as `backup` to a backend set that uses the IP Hash policy.
+               
+               Example: `false`
+        :param pulumi.Input[bool] drain: (Updatable) Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
+        :param pulumi.Input[int] max_connections: (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
         :param pulumi.Input[str] name: A friendly name for the backend set. It must be unique and it cannot be changed.
                
                Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.
                
                Example: `example_backend_set`
-        :param pulumi.Input[bool] offline: Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
-        :param pulumi.Input[int] weight: The load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives 3 times the number of new connections as a server weighted '1'. For more information on load balancing policies, see [How Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
+        :param pulumi.Input[bool] offline: (Updatable) Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
+        :param pulumi.Input[int] weight: (Updatable) The load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives 3 times the number of new connections as a server weighted '1'. For more information on load balancing policies, see [How Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
         """
         pulumi.set(__self__, "ip_address", ip_address)
         pulumi.set(__self__, "port", port)
@@ -72,6 +79,8 @@ class BackendSetBackendArgs:
             pulumi.set(__self__, "backup", backup)
         if drain is not None:
             pulumi.set(__self__, "drain", drain)
+        if max_connections is not None:
+            pulumi.set(__self__, "max_connections", max_connections)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if offline is not None:
@@ -83,7 +92,7 @@ class BackendSetBackendArgs:
     @pulumi.getter(name="ipAddress")
     def ip_address(self) -> pulumi.Input[str]:
         """
-        The IP address of the backend server.  Example: `10.0.0.3`
+        (Updatable) The IP address of the backend server.  Example: `10.0.0.3`
         """
         return pulumi.get(self, "ip_address")
 
@@ -107,7 +116,11 @@ class BackendSetBackendArgs:
     @pulumi.getter
     def backup(self) -> Optional[pulumi.Input[bool]]:
         """
-        Whether the load balancer should treat this server as a backup unit. If `true`, the load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "backup" fail the health check policy.
+        (Updatable) Whether the load balancer should treat this server as a backup unit. If `true`, the load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "backup" fail the health check policy.
+
+        **Note:** You cannot add a backend server marked as `backup` to a backend set that uses the IP Hash policy.
+
+        Example: `false`
         """
         return pulumi.get(self, "backup")
 
@@ -119,7 +132,7 @@ class BackendSetBackendArgs:
     @pulumi.getter
     def drain(self) -> Optional[pulumi.Input[bool]]:
         """
-        Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
+        (Updatable) Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
         """
         return pulumi.get(self, "drain")
 
@@ -127,6 +140,18 @@ class BackendSetBackendArgs:
     def drain(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "drain", value)
 
+    @property
+    @pulumi.getter(name="maxConnections")
+    def max_connections(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        """
+        return pulumi.get(self, "max_connections")
+
+    @max_connections.setter
+    def max_connections(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_connections", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
@@ -147,7 +172,7 @@ class BackendSetBackendArgs:
     @pulumi.getter
     def offline(self) -> Optional[pulumi.Input[bool]]:
         """
-        Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
+        (Updatable) Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         """
         return pulumi.get(self, "offline")
 
@@ -159,7 +184,7 @@ class BackendSetBackendArgs:
     @pulumi.getter
     def weight(self) -> Optional[pulumi.Input[int]]:
         """
-        The load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives 3 times the number of new connections as a server weighted '1'. For more information on load balancing policies, see [How Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
+        (Updatable) The load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives 3 times the number of new connections as a server weighted '1'. For more information on load balancing policies, see [How Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
         """
         return pulumi.get(self, "weight")
 
@@ -794,6 +819,7 @@ class ListenerSslConfigurationArgs:
                  certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  certificate_name: Optional[pulumi.Input[str]] = None,
                  cipher_suite_name: Optional[pulumi.Input[str]] = None,
+                 has_session_resumption: Optional[pulumi.Input[bool]] = None,
                  protocols: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  server_order_preference: Optional[pulumi.Input[str]] = None,
                  trusted_certificate_authority_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -816,6 +842,7 @@ class ListenerSslConfigurationArgs:
                *  The `oci-customized-ssl-cipher-suite` Oracle reserved cipher suite name is not accepted as valid input for this field.
                
                example: `example_cipher_suite`
+        :param pulumi.Input[bool] has_session_resumption: (Updatable) Whether the load balancer listener should resume an encrypted session by reusing the cryptographic parameters of a previous TLS session, without having to perform a full handshake again. If "true", the service resumes the previous TLS encrypted session. If "false", the service starts a new TLS encrypted session. Enabling session resumption improves performance but provides a lower level of security. Disabling session resumption improves security but reduces performance.  Example: `true`
         :param pulumi.Input[Sequence[pulumi.Input[str]]] protocols: (Updatable) A list of SSL protocols the load balancer must support for HTTPS or SSL connections.
                
                The load balancer uses SSL protocols to establish a secure connection between a client and a server. A secure connection ensures that all data passed between the client and the server is private.
@@ -852,6 +879,8 @@ class ListenerSslConfigurationArgs:
             pulumi.set(__self__, "certificate_name", certificate_name)
         if cipher_suite_name is not None:
             pulumi.set(__self__, "cipher_suite_name", cipher_suite_name)
+        if has_session_resumption is not None:
+            pulumi.set(__self__, "has_session_resumption", has_session_resumption)
         if protocols is not None:
             pulumi.set(__self__, "protocols", protocols)
         if server_order_preference is not None:
@@ -912,6 +941,18 @@ class ListenerSslConfigurationArgs:
     def cipher_suite_name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "cipher_suite_name", value)
 
+    @property
+    @pulumi.getter(name="hasSessionResumption")
+    def has_session_resumption(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) Whether the load balancer listener should resume an encrypted session by reusing the cryptographic parameters of a previous TLS session, without having to perform a full handshake again. If "true", the service resumes the previous TLS encrypted session. If "false", the service starts a new TLS encrypted session. Enabling session resumption improves performance but provides a lower level of security. Disabling session resumption improves security but reduces performance.  Example: `true`
+        """
+        return pulumi.get(self, "has_session_resumption")
+
+    @has_session_resumption.setter
+    def has_session_resumption(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "has_session_resumption", value)
+
     @property
     @pulumi.getter
     def protocols(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
@@ -1006,7 +1047,6 @@ class LoadBalancerIpAddressDetailArgs:
         """
         :param pulumi.Input[str] ip_address: An IP address.  Example: `192.168.0.3`
         :param pulumi.Input[bool] is_public: Whether the IP address is public or private.
-        :param pulumi.Input[Sequence[pulumi.Input['LoadBalancerIpAddressDetailReservedIpArgs']]] reserved_ips: Pre-created public IP that will be used as the IP of this load balancer. This reserved IP will not be deleted when load balancer is deleted. This ip should not be already mapped to any other resource.
         """
         if ip_address is not None:
             pulumi.set(__self__, "ip_address", ip_address)
@@ -1042,9 +1082,6 @@ class LoadBalancerIpAddressDetailArgs:
     @property
     @pulumi.getter(name="reservedIps")
     def reserved_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerIpAddressDetailReservedIpArgs']]]]:
-        """
-        Pre-created public IP that will be used as the IP of this load balancer. This reserved IP will not be deleted when load balancer is deleted. This ip should not be already mapped to any other resource.
-        """
         return pulumi.get(self, "reserved_ips")
 
     @reserved_ips.setter
@@ -1057,7 +1094,15 @@ class LoadBalancerIpAddressDetailReservedIpArgs:
     def __init__(__self__, *,
                  id: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] id: Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
+        :param pulumi.Input[str] id: Ocid of the Reserved IP/Public Ip created with VCN.
+               
+               Reserved IPs are IPs which already registered using VCN API.
+               
+               Create a reserved Public IP and then while creating the load balancer pass the ocid of the reserved IP in this field reservedIp to attach the Ip to Load balancer. Load balancer will be configured to listen to traffic on this IP.
+               
+               Reserved IPs will not be deleted when the Load balancer is deleted. They will be unattached from the Load balancer.
+               
+               Example: "ocid1.publicip.oc1.phx.unique_ID" Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
         """
         if id is not None:
             pulumi.set(__self__, "id", id)
@@ -1066,7 +1111,15 @@ class LoadBalancerIpAddressDetailReservedIpArgs:
     @pulumi.getter
     def id(self) -> Optional[pulumi.Input[str]]:
         """
-        Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
+        Ocid of the Reserved IP/Public Ip created with VCN.
+
+        Reserved IPs are IPs which already registered using VCN API.
+
+        Create a reserved Public IP and then while creating the load balancer pass the ocid of the reserved IP in this field reservedIp to attach the Ip to Load balancer. Load balancer will be configured to listen to traffic on this IP.
+
+        Reserved IPs will not be deleted when the Load balancer is deleted. They will be unattached from the Load balancer.
+
+        Example: "ocid1.publicip.oc1.phx.unique_ID" Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
         """
         return pulumi.get(self, "id")
 
@@ -1080,7 +1133,15 @@ class LoadBalancerReservedIpArgs:
     def __init__(__self__, *,
                  id: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] id: Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
+        :param pulumi.Input[str] id: Ocid of the Reserved IP/Public Ip created with VCN.
+               
+               Reserved IPs are IPs which already registered using VCN API.
+               
+               Create a reserved Public IP and then while creating the load balancer pass the ocid of the reserved IP in this field reservedIp to attach the Ip to Load balancer. Load balancer will be configured to listen to traffic on this IP.
+               
+               Reserved IPs will not be deleted when the Load balancer is deleted. They will be unattached from the Load balancer.
+               
+               Example: "ocid1.publicip.oc1.phx.unique_ID" Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
         """
         if id is not None:
             pulumi.set(__self__, "id", id)
@@ -1089,7 +1150,15 @@ class LoadBalancerReservedIpArgs:
     @pulumi.getter
     def id(self) -> Optional[pulumi.Input[str]]:
         """
-        Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
+        Ocid of the Reserved IP/Public Ip created with VCN.
+
+        Reserved IPs are IPs which already registered using VCN API.
+
+        Create a reserved Public IP and then while creating the load balancer pass the ocid of the reserved IP in this field reservedIp to attach the Ip to Load balancer. Load balancer will be configured to listen to traffic on this IP.
+
+        Reserved IPs will not be deleted when the Load balancer is deleted. They will be unattached from the Load balancer.
+
+        Example: "ocid1.publicip.oc1.phx.unique_ID" Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
         """
         return pulumi.get(self, "id")
 
@@ -1359,9 +1428,11 @@ class RuleSetItemArgs:
                  allowed_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  are_invalid_characters_allowed: Optional[pulumi.Input[bool]] = None,
                  conditions: Optional[pulumi.Input[Sequence[pulumi.Input['RuleSetItemConditionArgs']]]] = None,
+                 default_max_connections: Optional[pulumi.Input[int]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  header: Optional[pulumi.Input[str]] = None,
                  http_large_header_size_in_kb: Optional[pulumi.Input[int]] = None,
+                 ip_max_connections: Optional[pulumi.Input[Sequence[pulumi.Input['RuleSetItemIpMaxConnectionArgs']]]] = None,
                  prefix: Optional[pulumi.Input[str]] = None,
                  redirect_uri: Optional[pulumi.Input['RuleSetItemRedirectUriArgs']] = None,
                  response_code: Optional[pulumi.Input[int]] = None,
@@ -1369,7 +1440,7 @@ class RuleSetItemArgs:
                  suffix: Optional[pulumi.Input[str]] = None,
                  value: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] action: (Updatable) The action can be one of these values: `ADD_HTTP_REQUEST_HEADER`, `ADD_HTTP_RESPONSE_HEADER`, `ALLOW`, `CONTROL_ACCESS_USING_HTTP_METHODS`, `EXTEND_HTTP_REQUEST_HEADER_VALUE`, `EXTEND_HTTP_RESPONSE_HEADER_VALUE`, `HTTP_HEADER`, `REDIRECT`, `REMOVE_HTTP_REQUEST_HEADER`, `REMOVE_HTTP_RESPONSE_HEADER`
+        :param pulumi.Input[str] action: (Updatable) The action can be one of these values: `ADD_HTTP_REQUEST_HEADER`, `ADD_HTTP_RESPONSE_HEADER`, `ALLOW`, `CONTROL_ACCESS_USING_HTTP_METHODS`, `EXTEND_HTTP_REQUEST_HEADER_VALUE`, `EXTEND_HTTP_RESPONSE_HEADER_VALUE`, `HTTP_HEADER`, `IP_BASED_MAX_CONNECTIONS`, `REDIRECT`, `REMOVE_HTTP_REQUEST_HEADER`, `REMOVE_HTTP_RESPONSE_HEADER`
         :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_methods: (Updatable) The list of HTTP methods allowed for this listener.
                
                By default, you can specify only the standard HTTP methods defined in the [HTTP Method Registry](http://www.iana.org/assignments/http-methods/http-methods.xhtml). You can also see a list of supported standard HTTP methods in the Load Balancing service documentation at [Managing Rule Sets](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/managingrulesets.htm).
@@ -1381,11 +1452,13 @@ class RuleSetItemArgs:
                Example: ["GET", "PUT", "POST", "PROPFIND"]
         :param pulumi.Input[bool] are_invalid_characters_allowed: (Updatable) Indicates whether or not invalid characters in client header fields will be allowed. Valid names are composed of English letters, digits, hyphens and underscores. If "true", invalid characters are allowed in the HTTP header. If "false", invalid characters are not allowed in the HTTP header
         :param pulumi.Input[Sequence[pulumi.Input['RuleSetItemConditionArgs']]] conditions: (Updatable)
+        :param pulumi.Input[int] default_max_connections: (Updatable) The maximum number of connections that the any IP can make to a listener unless the IP is mentioned in maxConnections. If no defaultMaxConnections is specified the default is unlimited.
         :param pulumi.Input[str] description: (Updatable) A brief description of the access control rule. Avoid entering confidential information.
                
                example: `192.168.0.0/16 and 2001:db8::/32 are trusted clients. Whitelist them.`
         :param pulumi.Input[str] header: (Updatable) A header name that conforms to RFC 7230.  Example: `example_header_name`
         :param pulumi.Input[int] http_large_header_size_in_kb: (Updatable) The maximum size of each buffer used for reading http client request header. This value indicates the maximum size allowed for each buffer. The allowed values for buffer size are 8, 16, 32 and 64.
+        :param pulumi.Input[Sequence[pulumi.Input['RuleSetItemIpMaxConnectionArgs']]] ip_max_connections: (Updatable) An array of IPs that have a maxConnection setting different than the default and what that maxConnection setting is
         :param pulumi.Input[str] prefix: (Updatable) A string to prepend to the header value. The resulting header value must still conform to RFC 7230. With the following exceptions:
                *  value cannot contain `$`
                *  value cannot contain patterns like `{variable_name}`. They are reserved for future extensions. Currently, such values are invalid.
@@ -1446,12 +1519,16 @@ class RuleSetItemArgs:
             pulumi.set(__self__, "are_invalid_characters_allowed", are_invalid_characters_allowed)
         if conditions is not None:
             pulumi.set(__self__, "conditions", conditions)
+        if default_max_connections is not None:
+            pulumi.set(__self__, "default_max_connections", default_max_connections)
         if description is not None:
             pulumi.set(__self__, "description", description)
         if header is not None:
             pulumi.set(__self__, "header", header)
         if http_large_header_size_in_kb is not None:
             pulumi.set(__self__, "http_large_header_size_in_kb", http_large_header_size_in_kb)
+        if ip_max_connections is not None:
+            pulumi.set(__self__, "ip_max_connections", ip_max_connections)
         if prefix is not None:
             pulumi.set(__self__, "prefix", prefix)
         if redirect_uri is not None:
@@ -1469,7 +1546,7 @@ class RuleSetItemArgs:
     @pulumi.getter
     def action(self) -> pulumi.Input[str]:
         """
-        (Updatable) The action can be one of these values: `ADD_HTTP_REQUEST_HEADER`, `ADD_HTTP_RESPONSE_HEADER`, `ALLOW`, `CONTROL_ACCESS_USING_HTTP_METHODS`, `EXTEND_HTTP_REQUEST_HEADER_VALUE`, `EXTEND_HTTP_RESPONSE_HEADER_VALUE`, `HTTP_HEADER`, `REDIRECT`, `REMOVE_HTTP_REQUEST_HEADER`, `REMOVE_HTTP_RESPONSE_HEADER`
+        (Updatable) The action can be one of these values: `ADD_HTTP_REQUEST_HEADER`, `ADD_HTTP_RESPONSE_HEADER`, `ALLOW`, `CONTROL_ACCESS_USING_HTTP_METHODS`, `EXTEND_HTTP_REQUEST_HEADER_VALUE`, `EXTEND_HTTP_RESPONSE_HEADER_VALUE`, `HTTP_HEADER`, `IP_BASED_MAX_CONNECTIONS`, `REDIRECT`, `REMOVE_HTTP_REQUEST_HEADER`, `REMOVE_HTTP_RESPONSE_HEADER`
         """
         return pulumi.get(self, "action")
 
@@ -1521,6 +1598,18 @@ class RuleSetItemArgs:
     def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleSetItemConditionArgs']]]]):
         pulumi.set(self, "conditions", value)
 
+    @property
+    @pulumi.getter(name="defaultMaxConnections")
+    def default_max_connections(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) The maximum number of connections that the any IP can make to a listener unless the IP is mentioned in maxConnections. If no defaultMaxConnections is specified the default is unlimited.
+        """
+        return pulumi.get(self, "default_max_connections")
+
+    @default_max_connections.setter
+    def default_max_connections(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "default_max_connections", value)
+
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[str]]:
@@ -1559,6 +1648,18 @@ class RuleSetItemArgs:
     def http_large_header_size_in_kb(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "http_large_header_size_in_kb", value)
 
+    @property
+    @pulumi.getter(name="ipMaxConnections")
+    def ip_max_connections(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleSetItemIpMaxConnectionArgs']]]]:
+        """
+        (Updatable) An array of IPs that have a maxConnection setting different than the default and what that maxConnection setting is
+        """
+        return pulumi.get(self, "ip_max_connections")
+
+    @ip_max_connections.setter
+    def ip_max_connections(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleSetItemIpMaxConnectionArgs']]]]):
+        pulumi.set(self, "ip_max_connections", value)
+
     @property
     @pulumi.getter
     def prefix(self) -> Optional[pulumi.Input[str]]:
@@ -1745,6 +1846,45 @@ class RuleSetItemConditionArgs:
         pulumi.set(self, "operator", value)
 
 
+@pulumi.input_type
+class RuleSetItemIpMaxConnectionArgs:
+    def __init__(__self__, *,
+                 ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 max_connections: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_addresses: (Updatable) Each element in the list should be valid IPv4 or IPv6 CIDR Block address. Example: '["129.213.176.0/24", "150.136.187.0/24", "2002::1234:abcd:ffff:c0a8:101/64"]'
+        :param pulumi.Input[int] max_connections: (Updatable) The maximum number of simultaneous connections that the specified IPs can make to the Listener. IPs without a maxConnections setting can make either defaultMaxConnections simultaneous connections to a listener or, if no defaultMaxConnections is specified, an unlimited number of simultaneous connections to a listener.
+        """
+        if ip_addresses is not None:
+            pulumi.set(__self__, "ip_addresses", ip_addresses)
+        if max_connections is not None:
+            pulumi.set(__self__, "max_connections", max_connections)
+
+    @property
+    @pulumi.getter(name="ipAddresses")
+    def ip_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        (Updatable) Each element in the list should be valid IPv4 or IPv6 CIDR Block address. Example: '["129.213.176.0/24", "150.136.187.0/24", "2002::1234:abcd:ffff:c0a8:101/64"]'
+        """
+        return pulumi.get(self, "ip_addresses")
+
+    @ip_addresses.setter
+    def ip_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "ip_addresses", value)
+
+    @property
+    @pulumi.getter(name="maxConnections")
+    def max_connections(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) The maximum number of simultaneous connections that the specified IPs can make to the Listener. IPs without a maxConnections setting can make either defaultMaxConnections simultaneous connections to a listener or, if no defaultMaxConnections is specified, an unlimited number of simultaneous connections to a listener.
+        """
+        return pulumi.get(self, "max_connections")
+
+    @max_connections.setter
+    def max_connections(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_connections", value)
+
+
 @pulumi.input_type
 class RuleSetItemRedirectUriArgs:
     def __init__(__self__, *,

pulumi_oci/loadbalancer/backend.py

@@ -20,6 +20,7 @@ class BackendArgs:
                  port: pulumi.Input[int],
                  backup: Optional[pulumi.Input[bool]] = None,
                  drain: Optional[pulumi.Input[bool]] = None,
+                 max_connections: Optional[pulumi.Input[int]] = None,
                  offline: Optional[pulumi.Input[bool]] = None,
                  weight: Optional[pulumi.Input[int]] = None):
         """
@@ -34,6 +35,7 @@ class BackendArgs:
                
                Example: `false`
         :param pulumi.Input[bool] drain: (Updatable) Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
+        :param pulumi.Input[int] max_connections: (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
         :param pulumi.Input[bool] offline: (Updatable) Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         :param pulumi.Input[int] weight: (Updatable) The load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives 3 times the number of new connections as a server weighted '1'. For more information on load balancing policies, see [How Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3` 
                
@@ -49,6 +51,8 @@ class BackendArgs:
             pulumi.set(__self__, "backup", backup)
         if drain is not None:
             pulumi.set(__self__, "drain", drain)
+        if max_connections is not None:
+            pulumi.set(__self__, "max_connections", max_connections)
         if offline is not None:
             pulumi.set(__self__, "offline", offline)
         if weight is not None:
@@ -130,6 +134,18 @@ class BackendArgs:
     def drain(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "drain", value)
 
+    @property
+    @pulumi.getter(name="maxConnections")
+    def max_connections(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        """
+        return pulumi.get(self, "max_connections")
+
+    @max_connections.setter
+    def max_connections(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_connections", value)
+
     @property
     @pulumi.getter
     def offline(self) -> Optional[pulumi.Input[bool]]:
@@ -167,6 +183,7 @@ class _BackendState:
                  drain: Optional[pulumi.Input[bool]] = None,
                  ip_address: Optional[pulumi.Input[str]] = None,
                  load_balancer_id: Optional[pulumi.Input[str]] = None,
+                 max_connections: Optional[pulumi.Input[int]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  offline: Optional[pulumi.Input[bool]] = None,
                  port: Optional[pulumi.Input[int]] = None,
@@ -183,6 +200,7 @@ class _BackendState:
         :param pulumi.Input[bool] drain: (Updatable) Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
         :param pulumi.Input[str] ip_address: The IP address of the backend server.  Example: `10.0.0.3`
         :param pulumi.Input[str] load_balancer_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set and servers.
+        :param pulumi.Input[int] max_connections: (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
         :param pulumi.Input[str] name: A read-only field showing the IP address and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`
         :param pulumi.Input[bool] offline: (Updatable) Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         :param pulumi.Input[int] port: The communication port for the backend server.  Example: `8080`
@@ -202,6 +220,8 @@ class _BackendState:
             pulumi.set(__self__, "ip_address", ip_address)
         if load_balancer_id is not None:
             pulumi.set(__self__, "load_balancer_id", load_balancer_id)
+        if max_connections is not None:
+            pulumi.set(__self__, "max_connections", max_connections)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if offline is not None:
@@ -277,6 +297,18 @@ class _BackendState:
     def load_balancer_id(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "load_balancer_id", value)
 
+    @property
+    @pulumi.getter(name="maxConnections")
+    def max_connections(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        """
+        return pulumi.get(self, "max_connections")
+
+    @max_connections.setter
+    def max_connections(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_connections", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
@@ -349,6 +381,7 @@ class Backend(pulumi.CustomResource):
                  drain: Optional[pulumi.Input[bool]] = None,
                  ip_address: Optional[pulumi.Input[str]] = None,
                  load_balancer_id: Optional[pulumi.Input[str]] = None,
+                 max_connections: Optional[pulumi.Input[int]] = None,
                  offline: Optional[pulumi.Input[bool]] = None,
                  port: Optional[pulumi.Input[int]] = None,
                  weight: Optional[pulumi.Input[int]] = None,
@@ -371,6 +404,7 @@ class Backend(pulumi.CustomResource):
             port=backend_port,
             backup=backend_backup,
             drain=backend_drain,
+            max_connections=backend_max_connections,
             offline=backend_offline,
             weight=backend_weight)
         ```
@@ -394,6 +428,7 @@ class Backend(pulumi.CustomResource):
         :param pulumi.Input[bool] drain: (Updatable) Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
         :param pulumi.Input[str] ip_address: The IP address of the backend server.  Example: `10.0.0.3`
         :param pulumi.Input[str] load_balancer_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set and servers.
+        :param pulumi.Input[int] max_connections: (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
         :param pulumi.Input[bool] offline: (Updatable) Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         :param pulumi.Input[int] port: The communication port for the backend server.  Example: `8080`
         :param pulumi.Input[int] weight: (Updatable) The load balancing policy weight assigned to the server. Backend servers with a higher weight receive a larger proportion of incoming traffic. For example, a server weighted '3' receives 3 times the number of new connections as a server weighted '1'. For more information on load balancing policies, see [How Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3` 
@@ -426,6 +461,7 @@ class Backend(pulumi.CustomResource):
             port=backend_port,
             backup=backend_backup,
             drain=backend_drain,
+            max_connections=backend_max_connections,
             offline=backend_offline,
             weight=backend_weight)
         ```
@@ -458,6 +494,7 @@ class Backend(pulumi.CustomResource):
                  drain: Optional[pulumi.Input[bool]] = None,
                  ip_address: Optional[pulumi.Input[str]] = None,
                  load_balancer_id: Optional[pulumi.Input[str]] = None,
+                 max_connections: Optional[pulumi.Input[int]] = None,
                  offline: Optional[pulumi.Input[bool]] = None,
                  port: Optional[pulumi.Input[int]] = None,
                  weight: Optional[pulumi.Input[int]] = None,
@@ -481,6 +518,7 @@ class Backend(pulumi.CustomResource):
             if load_balancer_id is None and not opts.urn:
                 raise TypeError("Missing required property 'load_balancer_id'")
             __props__.__dict__["load_balancer_id"] = load_balancer_id
+            __props__.__dict__["max_connections"] = max_connections
             __props__.__dict__["offline"] = offline
             if port is None and not opts.urn:
                 raise TypeError("Missing required property 'port'")
@@ -503,6 +541,7 @@ class Backend(pulumi.CustomResource):
             drain: Optional[pulumi.Input[bool]] = None,
             ip_address: Optional[pulumi.Input[str]] = None,
             load_balancer_id: Optional[pulumi.Input[str]] = None,
+            max_connections: Optional[pulumi.Input[int]] = None,
             name: Optional[pulumi.Input[str]] = None,
             offline: Optional[pulumi.Input[bool]] = None,
             port: Optional[pulumi.Input[int]] = None,
@@ -524,6 +563,7 @@ class Backend(pulumi.CustomResource):
         :param pulumi.Input[bool] drain: (Updatable) Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
         :param pulumi.Input[str] ip_address: The IP address of the backend server.  Example: `10.0.0.3`
         :param pulumi.Input[str] load_balancer_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set and servers.
+        :param pulumi.Input[int] max_connections: (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
         :param pulumi.Input[str] name: A read-only field showing the IP address and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`
         :param pulumi.Input[bool] offline: (Updatable) Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         :param pulumi.Input[int] port: The communication port for the backend server.  Example: `8080`
@@ -542,6 +582,7 @@ class Backend(pulumi.CustomResource):
         __props__.__dict__["drain"] = drain
         __props__.__dict__["ip_address"] = ip_address
         __props__.__dict__["load_balancer_id"] = load_balancer_id
+        __props__.__dict__["max_connections"] = max_connections
         __props__.__dict__["name"] = name
         __props__.__dict__["offline"] = offline
         __props__.__dict__["port"] = port
@@ -593,6 +634,14 @@ class Backend(pulumi.CustomResource):
         """
         return pulumi.get(self, "load_balancer_id")
 
+    @property
+    @pulumi.getter(name="maxConnections")
+    def max_connections(self) -> pulumi.Output[int]:
+        """
+        (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        """
+        return pulumi.get(self, "max_connections")
+
     @property
     @pulumi.getter
     def name(self) -> pulumi.Output[str]: