pulumi-oci 2.22.0a1737613119__py3-none-any.whl → 2.23.0a1737786272__py3-none-any.whl

pulumi_oci/networkloadbalancer/__init__.py

@@ -15,6 +15,7 @@ from .get_backends import *
 from .get_listener import *
 from .get_listeners import *
 from .get_network_load_balancer import *
+from .get_network_load_balancer_backend_set_backend_operational_status import *
 from .get_network_load_balancer_health import *
 from .get_network_load_balancers import *
 from .get_network_load_balancers_policies import *

pulumi_oci/networkloadbalancer/_inputs.py

@@ -81,7 +81,7 @@ if not MYPY:
         """
         weight: NotRequired[pulumi.Input[int]]
         """
-        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
+        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3`
         """
 elif False:
     BackendSetBackendArgsDict: TypeAlias = Mapping[str, Any]
@@ -105,7 +105,7 @@ class BackendSetBackendArgs:
         :param pulumi.Input[bool] is_offline: (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         :param pulumi.Input[str] name: (Updatable) A read-only field showing the IP address/OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
         :param pulumi.Input[str] target_id: (Updatable) The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
-        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
+        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3`
         """
         pulumi.set(__self__, "port", port)
         if ip_address is not None:
@@ -211,7 +211,7 @@ class BackendSetBackendArgs:
     @pulumi.getter
     def weight(self) -> Optional[pulumi.Input[int]]:
         """
-        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
+        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3`
         """
         return pulumi.get(self, "weight")
 
@@ -774,7 +774,7 @@ if not MYPY:
         """
         weight: NotRequired[pulumi.Input[int]]
         """
-        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
+        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3`
         """
 elif False:
     NetworkLoadBalancersBackendSetsUnifiedBackendArgsDict: TypeAlias = Mapping[str, Any]
@@ -798,7 +798,7 @@ class NetworkLoadBalancersBackendSetsUnifiedBackendArgs:
         :param pulumi.Input[bool] is_offline: (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         :param pulumi.Input[str] name: (Updatable) A read-only field showing the IP address/OCID and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`, or `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>:443` or `10.0.0.3:0`
         :param pulumi.Input[str] target_id: (Updatable) The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
-        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
+        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3`
         """
         pulumi.set(__self__, "port", port)
         if ip_address is not None:
@@ -904,7 +904,7 @@ class NetworkLoadBalancersBackendSetsUnifiedBackendArgs:
     @pulumi.getter
     def weight(self) -> Optional[pulumi.Input[int]]:
         """
-        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/Balance/Reference/lbpolicies.htm).  Example: `3`
+        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3`
         """
         return pulumi.get(self, "weight")
 

pulumi_oci/networkloadbalancer/backend.py

@@ -40,7 +40,7 @@ class BackendArgs:
         :param pulumi.Input[bool] is_offline: (Updatable) Whether the network load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         :param pulumi.Input[str] name: Optional unique name identifying the backend within the backend set. If not specified, then one will be generated. Example: `webServer1`
         :param pulumi.Input[str] target_id: The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
-        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3` 
+        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about network load balancer policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3` 
                
                
                ** IMPORTANT **
@@ -176,7 +176,7 @@ class BackendArgs:
     @pulumi.getter
     def weight(self) -> Optional[pulumi.Input[int]]:
         """
-        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3` 
+        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about network load balancer policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3` 
 
 
         ** IMPORTANT **
@@ -213,7 +213,7 @@ class _BackendState:
         :param pulumi.Input[str] network_load_balancer_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
         :param pulumi.Input[int] port: The communication port for the backend server.  Example: `8080`
         :param pulumi.Input[str] target_id: The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
-        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3` 
+        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about network load balancer policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3` 
                
                
                ** IMPORTANT **
@@ -352,7 +352,7 @@ class _BackendState:
     @pulumi.getter
     def weight(self) -> Optional[pulumi.Input[int]]:
         """
-        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3` 
+        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about network load balancer policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3` 
 
 
         ** IMPORTANT **
@@ -424,7 +424,7 @@ class Backend(pulumi.CustomResource):
         :param pulumi.Input[str] network_load_balancer_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
         :param pulumi.Input[int] port: The communication port for the backend server.  Example: `8080`
         :param pulumi.Input[str] target_id: The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
-        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3` 
+        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about network load balancer policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3` 
                
                
                ** IMPORTANT **
@@ -554,7 +554,7 @@ class Backend(pulumi.CustomResource):
         :param pulumi.Input[str] network_load_balancer_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
         :param pulumi.Input[int] port: The communication port for the backend server.  Example: `8080`
         :param pulumi.Input[str] target_id: The IP OCID/Instance OCID associated with the backend server. Example: `ocid1.privateip..oc1.<var>&lt;unique_ID&gt;</var>`
-        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3` 
+        :param pulumi.Input[int] weight: (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about network load balancer policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3` 
                
                
                ** IMPORTANT **
@@ -652,7 +652,7 @@ class Backend(pulumi.CustomResource):
     @pulumi.getter
     def weight(self) -> pulumi.Output[int]:
         """
-        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about load balancing policies, see [How Network Load Balancing Policies Work](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introducton.htm#Policies).  Example: `3` 
+        (Updatable) The network 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 three times the number of new connections as a server weighted '1'. For more information about network load balancer policies, see [Network Load Balancer Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/introduction.htm#Policies).  Example: `3` 
 
 
         ** IMPORTANT **

pulumi_oci/networkloadbalancer/backend_set.py

@@ -24,23 +24,27 @@ class BackendSetArgs:
                  health_checker: pulumi.Input['BackendSetHealthCheckerArgs'],
                  network_load_balancer_id: pulumi.Input[str],
                  policy: pulumi.Input[str],
+                 are_operationally_active_backends_preferred: Optional[pulumi.Input[bool]] = None,
                  ip_version: Optional[pulumi.Input[str]] = None,
                  is_fail_open: Optional[pulumi.Input[bool]] = None,
                  is_instant_failover_enabled: Optional[pulumi.Input[bool]] = None,
+                 is_instant_failover_tcp_reset_enabled: Optional[pulumi.Input[bool]] = None,
                  is_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None):
         """
         The set of arguments for constructing a BackendSet resource.
-        :param pulumi.Input['BackendSetHealthCheckerArgs'] health_checker: (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
+        :param pulumi.Input['BackendSetHealthCheckerArgs'] health_checker: (Updatable) The health check policy configuration. For more information, see [Editing Network Load Balancer Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/HealthCheckPolicies/update-health-check-policy.htm).
         :param pulumi.Input[str] network_load_balancer_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the network load balancer to update.
         :param pulumi.Input[str] policy: (Updatable) The network load balancer policy for the backend set.  Example: `FIVE_TUPLE`` 
                
                
                ** IMPORTANT **
                Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        :param pulumi.Input[bool] are_operationally_active_backends_preferred: (Updatable) If enabled, NLB supports active-standby backends. The standby backend takes over the traffic when the active node fails, and continues to serve the traffic even when the old active node is back healthy.
         :param pulumi.Input[str] ip_version: (Updatable) IP version associated with the backend set.
         :param pulumi.Input[bool] is_fail_open: (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
         :param pulumi.Input[bool] is_instant_failover_enabled: (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        :param pulumi.Input[bool] is_instant_failover_tcp_reset_enabled: (Updatable) If enabled along with instant failover, the network load balancer will send TCP RST to the clients for the existing connections instead of failing over to a healthy backend. This only applies when using the instant failover. By default, TCP RST is enabled.
         :param pulumi.Input[bool] is_preserve_source: (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
         :param pulumi.Input[str] name: A user-friendly name for the backend set that must be unique and cannot be changed.
                
@@ -51,12 +55,16 @@ class BackendSetArgs:
         pulumi.set(__self__, "health_checker", health_checker)
         pulumi.set(__self__, "network_load_balancer_id", network_load_balancer_id)
         pulumi.set(__self__, "policy", policy)
+        if are_operationally_active_backends_preferred is not None:
+            pulumi.set(__self__, "are_operationally_active_backends_preferred", are_operationally_active_backends_preferred)
         if ip_version is not None:
             pulumi.set(__self__, "ip_version", ip_version)
         if is_fail_open is not None:
             pulumi.set(__self__, "is_fail_open", is_fail_open)
         if is_instant_failover_enabled is not None:
             pulumi.set(__self__, "is_instant_failover_enabled", is_instant_failover_enabled)
+        if is_instant_failover_tcp_reset_enabled is not None:
+            pulumi.set(__self__, "is_instant_failover_tcp_reset_enabled", is_instant_failover_tcp_reset_enabled)
         if is_preserve_source is not None:
             pulumi.set(__self__, "is_preserve_source", is_preserve_source)
         if name is not None:
@@ -66,7 +74,7 @@ class BackendSetArgs:
     @pulumi.getter(name="healthChecker")
     def health_checker(self) -> pulumi.Input['BackendSetHealthCheckerArgs']:
         """
-        (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
+        (Updatable) The health check policy configuration. For more information, see [Editing Network Load Balancer Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/HealthCheckPolicies/update-health-check-policy.htm).
         """
         return pulumi.get(self, "health_checker")
 
@@ -102,6 +110,18 @@ class BackendSetArgs:
     def policy(self, value: pulumi.Input[str]):
         pulumi.set(self, "policy", value)
 
+    @property
+    @pulumi.getter(name="areOperationallyActiveBackendsPreferred")
+    def are_operationally_active_backends_preferred(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) If enabled, NLB supports active-standby backends. The standby backend takes over the traffic when the active node fails, and continues to serve the traffic even when the old active node is back healthy.
+        """
+        return pulumi.get(self, "are_operationally_active_backends_preferred")
+
+    @are_operationally_active_backends_preferred.setter
+    def are_operationally_active_backends_preferred(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "are_operationally_active_backends_preferred", value)
+
     @property
     @pulumi.getter(name="ipVersion")
     def ip_version(self) -> Optional[pulumi.Input[str]]:
@@ -138,6 +158,18 @@ class BackendSetArgs:
     def is_instant_failover_enabled(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_instant_failover_enabled", value)
 
+    @property
+    @pulumi.getter(name="isInstantFailoverTcpResetEnabled")
+    def is_instant_failover_tcp_reset_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) If enabled along with instant failover, the network load balancer will send TCP RST to the clients for the existing connections instead of failing over to a healthy backend. This only applies when using the instant failover. By default, TCP RST is enabled.
+        """
+        return pulumi.get(self, "is_instant_failover_tcp_reset_enabled")
+
+    @is_instant_failover_tcp_reset_enabled.setter
+    def is_instant_failover_tcp_reset_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_instant_failover_tcp_reset_enabled", value)
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> Optional[pulumi.Input[bool]]:
@@ -170,22 +202,26 @@ class BackendSetArgs:
 @pulumi.input_type
 class _BackendSetState:
     def __init__(__self__, *,
+                 are_operationally_active_backends_preferred: Optional[pulumi.Input[bool]] = None,
                  backends: Optional[pulumi.Input[Sequence[pulumi.Input['BackendSetBackendArgs']]]] = None,
                  health_checker: Optional[pulumi.Input['BackendSetHealthCheckerArgs']] = None,
                  ip_version: Optional[pulumi.Input[str]] = None,
                  is_fail_open: Optional[pulumi.Input[bool]] = None,
                  is_instant_failover_enabled: Optional[pulumi.Input[bool]] = None,
+                 is_instant_failover_tcp_reset_enabled: Optional[pulumi.Input[bool]] = None,
                  is_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network_load_balancer_id: Optional[pulumi.Input[str]] = None,
                  policy: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering BackendSet resources.
+        :param pulumi.Input[bool] are_operationally_active_backends_preferred: (Updatable) If enabled, NLB supports active-standby backends. The standby backend takes over the traffic when the active node fails, and continues to serve the traffic even when the old active node is back healthy.
         :param pulumi.Input[Sequence[pulumi.Input['BackendSetBackendArgs']]] backends: (Updatable) An array of backends to be associated with the backend set.
-        :param pulumi.Input['BackendSetHealthCheckerArgs'] health_checker: (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
+        :param pulumi.Input['BackendSetHealthCheckerArgs'] health_checker: (Updatable) The health check policy configuration. For more information, see [Editing Network Load Balancer Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/HealthCheckPolicies/update-health-check-policy.htm).
         :param pulumi.Input[str] ip_version: (Updatable) IP version associated with the backend set.
         :param pulumi.Input[bool] is_fail_open: (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
         :param pulumi.Input[bool] is_instant_failover_enabled: (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        :param pulumi.Input[bool] is_instant_failover_tcp_reset_enabled: (Updatable) If enabled along with instant failover, the network load balancer will send TCP RST to the clients for the existing connections instead of failing over to a healthy backend. This only applies when using the instant failover. By default, TCP RST is enabled.
         :param pulumi.Input[bool] is_preserve_source: (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
         :param pulumi.Input[str] name: A user-friendly name for the backend set that must be unique and cannot be changed.
                
@@ -199,6 +235,8 @@ class _BackendSetState:
                ** IMPORTANT **
                Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
         """
+        if are_operationally_active_backends_preferred is not None:
+            pulumi.set(__self__, "are_operationally_active_backends_preferred", are_operationally_active_backends_preferred)
         if backends is not None:
             pulumi.set(__self__, "backends", backends)
         if health_checker is not None:
@@ -209,6 +247,8 @@ class _BackendSetState:
             pulumi.set(__self__, "is_fail_open", is_fail_open)
         if is_instant_failover_enabled is not None:
             pulumi.set(__self__, "is_instant_failover_enabled", is_instant_failover_enabled)
+        if is_instant_failover_tcp_reset_enabled is not None:
+            pulumi.set(__self__, "is_instant_failover_tcp_reset_enabled", is_instant_failover_tcp_reset_enabled)
         if is_preserve_source is not None:
             pulumi.set(__self__, "is_preserve_source", is_preserve_source)
         if name is not None:
@@ -218,6 +258,18 @@ class _BackendSetState:
         if policy is not None:
             pulumi.set(__self__, "policy", policy)
 
+    @property
+    @pulumi.getter(name="areOperationallyActiveBackendsPreferred")
+    def are_operationally_active_backends_preferred(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) If enabled, NLB supports active-standby backends. The standby backend takes over the traffic when the active node fails, and continues to serve the traffic even when the old active node is back healthy.
+        """
+        return pulumi.get(self, "are_operationally_active_backends_preferred")
+
+    @are_operationally_active_backends_preferred.setter
+    def are_operationally_active_backends_preferred(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "are_operationally_active_backends_preferred", value)
+
     @property
     @pulumi.getter
     def backends(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendSetBackendArgs']]]]:
@@ -234,7 +286,7 @@ class _BackendSetState:
     @pulumi.getter(name="healthChecker")
     def health_checker(self) -> Optional[pulumi.Input['BackendSetHealthCheckerArgs']]:
         """
-        (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
+        (Updatable) The health check policy configuration. For more information, see [Editing Network Load Balancer Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/HealthCheckPolicies/update-health-check-policy.htm).
         """
         return pulumi.get(self, "health_checker")
 
@@ -278,6 +330,18 @@ class _BackendSetState:
     def is_instant_failover_enabled(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_instant_failover_enabled", value)
 
+    @property
+    @pulumi.getter(name="isInstantFailoverTcpResetEnabled")
+    def is_instant_failover_tcp_reset_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) If enabled along with instant failover, the network load balancer will send TCP RST to the clients for the existing connections instead of failing over to a healthy backend. This only applies when using the instant failover. By default, TCP RST is enabled.
+        """
+        return pulumi.get(self, "is_instant_failover_tcp_reset_enabled")
+
+    @is_instant_failover_tcp_reset_enabled.setter
+    def is_instant_failover_tcp_reset_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_instant_failover_tcp_reset_enabled", value)
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> Optional[pulumi.Input[bool]]:
@@ -340,10 +404,12 @@ class BackendSet(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 are_operationally_active_backends_preferred: Optional[pulumi.Input[bool]] = None,
                  health_checker: Optional[pulumi.Input[Union['BackendSetHealthCheckerArgs', 'BackendSetHealthCheckerArgsDict']]] = None,
                  ip_version: Optional[pulumi.Input[str]] = None,
                  is_fail_open: Optional[pulumi.Input[bool]] = None,
                  is_instant_failover_enabled: Optional[pulumi.Input[bool]] = None,
+                 is_instant_failover_tcp_reset_enabled: Optional[pulumi.Input[bool]] = None,
                  is_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -383,9 +449,11 @@ class BackendSet(pulumi.CustomResource):
             name=backend_set_name,
             network_load_balancer_id=test_network_load_balancer["id"],
             policy=backend_set_policy,
+            are_operationally_active_backends_preferred=backend_set_are_operationally_active_backends_preferred,
             ip_version=backend_set_ip_version,
             is_fail_open=backend_set_is_fail_open,
             is_instant_failover_enabled=backend_set_is_instant_failover_enabled,
+            is_instant_failover_tcp_reset_enabled=backend_set_is_instant_failover_tcp_reset_enabled,
             is_preserve_source=backend_set_is_preserve_source)
         ```
 
@@ -399,10 +467,12 @@ class BackendSet(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[Union['BackendSetHealthCheckerArgs', 'BackendSetHealthCheckerArgsDict']] health_checker: (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
+        :param pulumi.Input[bool] are_operationally_active_backends_preferred: (Updatable) If enabled, NLB supports active-standby backends. The standby backend takes over the traffic when the active node fails, and continues to serve the traffic even when the old active node is back healthy.
+        :param pulumi.Input[Union['BackendSetHealthCheckerArgs', 'BackendSetHealthCheckerArgsDict']] health_checker: (Updatable) The health check policy configuration. For more information, see [Editing Network Load Balancer Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/HealthCheckPolicies/update-health-check-policy.htm).
         :param pulumi.Input[str] ip_version: (Updatable) IP version associated with the backend set.
         :param pulumi.Input[bool] is_fail_open: (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
         :param pulumi.Input[bool] is_instant_failover_enabled: (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        :param pulumi.Input[bool] is_instant_failover_tcp_reset_enabled: (Updatable) If enabled along with instant failover, the network load balancer will send TCP RST to the clients for the existing connections instead of failing over to a healthy backend. This only applies when using the instant failover. By default, TCP RST is enabled.
         :param pulumi.Input[bool] is_preserve_source: (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
         :param pulumi.Input[str] name: A user-friendly name for the backend set that must be unique and cannot be changed.
                
@@ -456,9 +526,11 @@ class BackendSet(pulumi.CustomResource):
             name=backend_set_name,
             network_load_balancer_id=test_network_load_balancer["id"],
             policy=backend_set_policy,
+            are_operationally_active_backends_preferred=backend_set_are_operationally_active_backends_preferred,
             ip_version=backend_set_ip_version,
             is_fail_open=backend_set_is_fail_open,
             is_instant_failover_enabled=backend_set_is_instant_failover_enabled,
+            is_instant_failover_tcp_reset_enabled=backend_set_is_instant_failover_tcp_reset_enabled,
             is_preserve_source=backend_set_is_preserve_source)
         ```
 
@@ -485,10 +557,12 @@ class BackendSet(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 are_operationally_active_backends_preferred: Optional[pulumi.Input[bool]] = None,
                  health_checker: Optional[pulumi.Input[Union['BackendSetHealthCheckerArgs', 'BackendSetHealthCheckerArgsDict']]] = None,
                  ip_version: Optional[pulumi.Input[str]] = None,
                  is_fail_open: Optional[pulumi.Input[bool]] = None,
                  is_instant_failover_enabled: Optional[pulumi.Input[bool]] = None,
+                 is_instant_failover_tcp_reset_enabled: Optional[pulumi.Input[bool]] = None,
                  is_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -502,12 +576,14 @@ class BackendSet(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = BackendSetArgs.__new__(BackendSetArgs)
 
+            __props__.__dict__["are_operationally_active_backends_preferred"] = are_operationally_active_backends_preferred
             if health_checker is None and not opts.urn:
                 raise TypeError("Missing required property 'health_checker'")
             __props__.__dict__["health_checker"] = health_checker
             __props__.__dict__["ip_version"] = ip_version
             __props__.__dict__["is_fail_open"] = is_fail_open
             __props__.__dict__["is_instant_failover_enabled"] = is_instant_failover_enabled
+            __props__.__dict__["is_instant_failover_tcp_reset_enabled"] = is_instant_failover_tcp_reset_enabled
             __props__.__dict__["is_preserve_source"] = is_preserve_source
             __props__.__dict__["name"] = name
             if network_load_balancer_id is None and not opts.urn:
@@ -527,11 +603,13 @@ class BackendSet(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
+            are_operationally_active_backends_preferred: Optional[pulumi.Input[bool]] = None,
             backends: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendSetBackendArgs', 'BackendSetBackendArgsDict']]]]] = None,
             health_checker: Optional[pulumi.Input[Union['BackendSetHealthCheckerArgs', 'BackendSetHealthCheckerArgsDict']]] = None,
             ip_version: Optional[pulumi.Input[str]] = None,
             is_fail_open: Optional[pulumi.Input[bool]] = None,
             is_instant_failover_enabled: Optional[pulumi.Input[bool]] = None,
+            is_instant_failover_tcp_reset_enabled: Optional[pulumi.Input[bool]] = None,
             is_preserve_source: Optional[pulumi.Input[bool]] = None,
             name: Optional[pulumi.Input[str]] = None,
             network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -543,11 +621,13 @@ class BackendSet(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[bool] are_operationally_active_backends_preferred: (Updatable) If enabled, NLB supports active-standby backends. The standby backend takes over the traffic when the active node fails, and continues to serve the traffic even when the old active node is back healthy.
         :param pulumi.Input[Sequence[pulumi.Input[Union['BackendSetBackendArgs', 'BackendSetBackendArgsDict']]]] backends: (Updatable) An array of backends to be associated with the backend set.
-        :param pulumi.Input[Union['BackendSetHealthCheckerArgs', 'BackendSetHealthCheckerArgsDict']] health_checker: (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
+        :param pulumi.Input[Union['BackendSetHealthCheckerArgs', 'BackendSetHealthCheckerArgsDict']] health_checker: (Updatable) The health check policy configuration. For more information, see [Editing Network Load Balancer Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/HealthCheckPolicies/update-health-check-policy.htm).
         :param pulumi.Input[str] ip_version: (Updatable) IP version associated with the backend set.
         :param pulumi.Input[bool] is_fail_open: (Updatable) If enabled, the network load balancer will continue to distribute traffic in the configured distribution in the event all backends are unhealthy. The value is false by default.
         :param pulumi.Input[bool] is_instant_failover_enabled: (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        :param pulumi.Input[bool] is_instant_failover_tcp_reset_enabled: (Updatable) If enabled along with instant failover, the network load balancer will send TCP RST to the clients for the existing connections instead of failing over to a healthy backend. This only applies when using the instant failover. By default, TCP RST is enabled.
         :param pulumi.Input[bool] is_preserve_source: (Updatable) If this parameter is enabled, then the network load balancer preserves the source IP of the packet when it is forwarded to backends. Backends see the original source IP. If the isPreserveSourceDestination parameter is enabled for the network load balancer resource, then this parameter cannot be disabled. The value is true by default.
         :param pulumi.Input[str] name: A user-friendly name for the backend set that must be unique and cannot be changed.
                
@@ -565,17 +645,27 @@ class BackendSet(pulumi.CustomResource):
 
         __props__ = _BackendSetState.__new__(_BackendSetState)
 
+        __props__.__dict__["are_operationally_active_backends_preferred"] = are_operationally_active_backends_preferred
         __props__.__dict__["backends"] = backends
         __props__.__dict__["health_checker"] = health_checker
         __props__.__dict__["ip_version"] = ip_version
         __props__.__dict__["is_fail_open"] = is_fail_open
         __props__.__dict__["is_instant_failover_enabled"] = is_instant_failover_enabled
+        __props__.__dict__["is_instant_failover_tcp_reset_enabled"] = is_instant_failover_tcp_reset_enabled
         __props__.__dict__["is_preserve_source"] = is_preserve_source
         __props__.__dict__["name"] = name
         __props__.__dict__["network_load_balancer_id"] = network_load_balancer_id
         __props__.__dict__["policy"] = policy
         return BackendSet(resource_name, opts=opts, __props__=__props__)
 
+    @property
+    @pulumi.getter(name="areOperationallyActiveBackendsPreferred")
+    def are_operationally_active_backends_preferred(self) -> pulumi.Output[bool]:
+        """
+        (Updatable) If enabled, NLB supports active-standby backends. The standby backend takes over the traffic when the active node fails, and continues to serve the traffic even when the old active node is back healthy.
+        """
+        return pulumi.get(self, "are_operationally_active_backends_preferred")
+
     @property
     @pulumi.getter
     def backends(self) -> pulumi.Output[Sequence['outputs.BackendSetBackend']]:
@@ -588,7 +678,7 @@ class BackendSet(pulumi.CustomResource):
     @pulumi.getter(name="healthChecker")
     def health_checker(self) -> pulumi.Output['outputs.BackendSetHealthChecker']:
         """
-        (Updatable) The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
+        (Updatable) The health check policy configuration. For more information, see [Editing Network Load Balancer Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/HealthCheckPolicies/update-health-check-policy.htm).
         """
         return pulumi.get(self, "health_checker")
 
@@ -616,6 +706,14 @@ class BackendSet(pulumi.CustomResource):
         """
         return pulumi.get(self, "is_instant_failover_enabled")
 
+    @property
+    @pulumi.getter(name="isInstantFailoverTcpResetEnabled")
+    def is_instant_failover_tcp_reset_enabled(self) -> pulumi.Output[bool]:
+        """
+        (Updatable) If enabled along with instant failover, the network load balancer will send TCP RST to the clients for the existing connections instead of failing over to a healthy backend. This only applies when using the instant failover. By default, TCP RST is enabled.
+        """
+        return pulumi.get(self, "is_instant_failover_tcp_reset_enabled")
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> pulumi.Output[bool]:

pulumi_oci/networkloadbalancer/get_backend_set.py

@@ -27,7 +27,10 @@ class GetBackendSetResult:
     """
     A collection of values returned by getBackendSet.
     """
-    def __init__(__self__, backend_set_name=None, backends=None, health_checkers=None, id=None, ip_version=None, is_fail_open=None, is_instant_failover_enabled=None, is_preserve_source=None, name=None, network_load_balancer_id=None, policy=None):
+    def __init__(__self__, are_operationally_active_backends_preferred=None, backend_set_name=None, backends=None, health_checkers=None, id=None, ip_version=None, is_fail_open=None, is_instant_failover_enabled=None, is_instant_failover_tcp_reset_enabled=None, is_preserve_source=None, name=None, network_load_balancer_id=None, policy=None):
+        if are_operationally_active_backends_preferred and not isinstance(are_operationally_active_backends_preferred, bool):
+            raise TypeError("Expected argument 'are_operationally_active_backends_preferred' to be a bool")
+        pulumi.set(__self__, "are_operationally_active_backends_preferred", are_operationally_active_backends_preferred)
         if backend_set_name and not isinstance(backend_set_name, str):
             raise TypeError("Expected argument 'backend_set_name' to be a str")
         pulumi.set(__self__, "backend_set_name", backend_set_name)
@@ -49,6 +52,9 @@ class GetBackendSetResult:
         if is_instant_failover_enabled and not isinstance(is_instant_failover_enabled, bool):
             raise TypeError("Expected argument 'is_instant_failover_enabled' to be a bool")
         pulumi.set(__self__, "is_instant_failover_enabled", is_instant_failover_enabled)
+        if is_instant_failover_tcp_reset_enabled and not isinstance(is_instant_failover_tcp_reset_enabled, bool):
+            raise TypeError("Expected argument 'is_instant_failover_tcp_reset_enabled' to be a bool")
+        pulumi.set(__self__, "is_instant_failover_tcp_reset_enabled", is_instant_failover_tcp_reset_enabled)
         if is_preserve_source and not isinstance(is_preserve_source, bool):
             raise TypeError("Expected argument 'is_preserve_source' to be a bool")
         pulumi.set(__self__, "is_preserve_source", is_preserve_source)
@@ -62,6 +68,14 @@ class GetBackendSetResult:
             raise TypeError("Expected argument 'policy' to be a str")
         pulumi.set(__self__, "policy", policy)
 
+    @property
+    @pulumi.getter(name="areOperationallyActiveBackendsPreferred")
+    def are_operationally_active_backends_preferred(self) -> bool:
+        """
+        If enabled, NLB supports active-standby backends. The standby backend takes over the traffic when the active node fails, and continues to serve the traffic even when the old active node is back healthy.
+        """
+        return pulumi.get(self, "are_operationally_active_backends_preferred")
+
     @property
     @pulumi.getter(name="backendSetName")
     def backend_set_name(self) -> str:
@@ -79,7 +93,7 @@ class GetBackendSetResult:
     @pulumi.getter(name="healthCheckers")
     def health_checkers(self) -> Sequence['outputs.GetBackendSetHealthCheckerResult']:
         """
-        The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
+        The health check policy configuration. For more information, see [Editing Network Load Balancer Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/NetworkLoadBalancer/HealthCheckPolicies/update-health-check-management.htm).
         """
         return pulumi.get(self, "health_checkers")
 
@@ -112,6 +126,14 @@ class GetBackendSetResult:
         """
         return pulumi.get(self, "is_instant_failover_enabled")
 
+    @property
+    @pulumi.getter(name="isInstantFailoverTcpResetEnabled")
+    def is_instant_failover_tcp_reset_enabled(self) -> bool:
+        """
+        If enabled along with instant failover, the network load balancer will send TCP RST to the clients for the existing connections instead of failing over to a healthy backend. This only applies when using the instant failover. By default, TCP RST is enabled.
+        """
+        return pulumi.get(self, "is_instant_failover_tcp_reset_enabled")
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> bool:
@@ -148,6 +170,7 @@ class AwaitableGetBackendSetResult(GetBackendSetResult):
         if False:
             yield self
         return GetBackendSetResult(
+            are_operationally_active_backends_preferred=self.are_operationally_active_backends_preferred,
             backend_set_name=self.backend_set_name,
             backends=self.backends,
             health_checkers=self.health_checkers,
@@ -155,6 +178,7 @@ class AwaitableGetBackendSetResult(GetBackendSetResult):
             ip_version=self.ip_version,
             is_fail_open=self.is_fail_open,
             is_instant_failover_enabled=self.is_instant_failover_enabled,
+            is_instant_failover_tcp_reset_enabled=self.is_instant_failover_tcp_reset_enabled,
             is_preserve_source=self.is_preserve_source,
             name=self.name,
             network_load_balancer_id=self.network_load_balancer_id,
@@ -180,6 +204,7 @@ def get_backend_set(backend_set_name: Optional[str] = None,
     __ret__ = pulumi.runtime.invoke('oci:NetworkLoadBalancer/getBackendSet:getBackendSet', __args__, opts=opts, typ=GetBackendSetResult).value
 
     return AwaitableGetBackendSetResult(
+        are_operationally_active_backends_preferred=pulumi.get(__ret__, 'are_operationally_active_backends_preferred'),
         backend_set_name=pulumi.get(__ret__, 'backend_set_name'),
         backends=pulumi.get(__ret__, 'backends'),
         health_checkers=pulumi.get(__ret__, 'health_checkers'),
@@ -187,6 +212,7 @@ def get_backend_set(backend_set_name: Optional[str] = None,
         ip_version=pulumi.get(__ret__, 'ip_version'),
         is_fail_open=pulumi.get(__ret__, 'is_fail_open'),
         is_instant_failover_enabled=pulumi.get(__ret__, 'is_instant_failover_enabled'),
+        is_instant_failover_tcp_reset_enabled=pulumi.get(__ret__, 'is_instant_failover_tcp_reset_enabled'),
         is_preserve_source=pulumi.get(__ret__, 'is_preserve_source'),
         name=pulumi.get(__ret__, 'name'),
         network_load_balancer_id=pulumi.get(__ret__, 'network_load_balancer_id'),
@@ -209,6 +235,7 @@ def get_backend_set_output(backend_set_name: Optional[pulumi.Input[str]] = None,
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('oci:NetworkLoadBalancer/getBackendSet:getBackendSet', __args__, opts=opts, typ=GetBackendSetResult)
     return __ret__.apply(lambda __response__: GetBackendSetResult(
+        are_operationally_active_backends_preferred=pulumi.get(__response__, 'are_operationally_active_backends_preferred'),
         backend_set_name=pulumi.get(__response__, 'backend_set_name'),
         backends=pulumi.get(__response__, 'backends'),
         health_checkers=pulumi.get(__response__, 'health_checkers'),
@@ -216,6 +243,7 @@ def get_backend_set_output(backend_set_name: Optional[pulumi.Input[str]] = None,
         ip_version=pulumi.get(__response__, 'ip_version'),
         is_fail_open=pulumi.get(__response__, 'is_fail_open'),
         is_instant_failover_enabled=pulumi.get(__response__, 'is_instant_failover_enabled'),
+        is_instant_failover_tcp_reset_enabled=pulumi.get(__response__, 'is_instant_failover_tcp_reset_enabled'),
         is_preserve_source=pulumi.get(__response__, 'is_preserve_source'),
         name=pulumi.get(__response__, 'name'),
         network_load_balancer_id=pulumi.get(__response__, 'network_load_balancer_id'),