pulumi-oci 1.33.0a1713903118__py3-none-any.whl → 1.34.0__py3-none-any.whl

pulumi_oci/networkloadbalancer/backend_set.py

@@ -21,6 +21,7 @@ class BackendSetArgs:
                  policy: pulumi.Input[str],
                  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_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None):
         """
@@ -34,6 +35,7 @@ class BackendSetArgs:
                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[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_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.
                
@@ -48,6 +50,8 @@ class BackendSetArgs:
             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_preserve_source is not None:
             pulumi.set(__self__, "is_preserve_source", is_preserve_source)
         if name is not None:
@@ -117,6 +121,18 @@ class BackendSetArgs:
     def is_fail_open(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_fail_open", value)
 
+    @property
+    @pulumi.getter(name="isInstantFailoverEnabled")
+    def is_instant_failover_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        """
+        return pulumi.get(self, "is_instant_failover_enabled")
+
+    @is_instant_failover_enabled.setter
+    def is_instant_failover_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_instant_failover_enabled", value)
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> Optional[pulumi.Input[bool]]:
@@ -153,6 +169,7 @@ class _BackendSetState:
                  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_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -163,6 +180,7 @@ class _BackendSetState:
         :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[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_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.
                
@@ -184,6 +202,8 @@ class _BackendSetState:
             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_preserve_source is not None:
             pulumi.set(__self__, "is_preserve_source", is_preserve_source)
         if name is not None:
@@ -241,6 +261,18 @@ class _BackendSetState:
     def is_fail_open(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_fail_open", value)
 
+    @property
+    @pulumi.getter(name="isInstantFailoverEnabled")
+    def is_instant_failover_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        """
+        return pulumi.get(self, "is_instant_failover_enabled")
+
+    @is_instant_failover_enabled.setter
+    def is_instant_failover_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_instant_failover_enabled", value)
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> Optional[pulumi.Input[bool]]:
@@ -306,6 +338,7 @@ class BackendSet(pulumi.CustomResource):
                  health_checker: Optional[pulumi.Input[pulumi.InputType['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_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -346,6 +379,7 @@ class BackendSet(pulumi.CustomResource):
             network_load_balancer_id=test_network_load_balancer["id"],
             policy=backend_set_policy,
             ip_version=backend_set_ip_version,
+            is_instant_failover_enabled=backend_set_is_instant_failover_enabled,
             is_fail_open=backend_set_is_fail_open,
             is_preserve_source=backend_set_is_preserve_source)
         ```
@@ -363,6 +397,7 @@ class BackendSet(pulumi.CustomResource):
         :param pulumi.Input[pulumi.InputType['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[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_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.
                
@@ -417,6 +452,7 @@ class BackendSet(pulumi.CustomResource):
             network_load_balancer_id=test_network_load_balancer["id"],
             policy=backend_set_policy,
             ip_version=backend_set_ip_version,
+            is_instant_failover_enabled=backend_set_is_instant_failover_enabled,
             is_fail_open=backend_set_is_fail_open,
             is_preserve_source=backend_set_is_preserve_source)
         ```
@@ -447,6 +483,7 @@ class BackendSet(pulumi.CustomResource):
                  health_checker: Optional[pulumi.Input[pulumi.InputType['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_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -465,6 +502,7 @@ class BackendSet(pulumi.CustomResource):
             __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_preserve_source"] = is_preserve_source
             __props__.__dict__["name"] = name
             if network_load_balancer_id is None and not opts.urn:
@@ -488,6 +526,7 @@ class BackendSet(pulumi.CustomResource):
             health_checker: Optional[pulumi.Input[pulumi.InputType['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_preserve_source: Optional[pulumi.Input[bool]] = None,
             name: Optional[pulumi.Input[str]] = None,
             network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -503,6 +542,7 @@ class BackendSet(pulumi.CustomResource):
         :param pulumi.Input[pulumi.InputType['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[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_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.
                
@@ -524,6 +564,7 @@ class BackendSet(pulumi.CustomResource):
         __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_preserve_source"] = is_preserve_source
         __props__.__dict__["name"] = name
         __props__.__dict__["network_load_balancer_id"] = network_load_balancer_id
@@ -562,6 +603,14 @@ class BackendSet(pulumi.CustomResource):
         """
         return pulumi.get(self, "is_fail_open")
 
+    @property
+    @pulumi.getter(name="isInstantFailoverEnabled")
+    def is_instant_failover_enabled(self) -> pulumi.Output[bool]:
+        """
+        (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        """
+        return pulumi.get(self, "is_instant_failover_enabled")
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> pulumi.Output[bool]:

pulumi_oci/networkloadbalancer/get_backend_set.py

@@ -22,7 +22,7 @@ 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_preserve_source=None, name=None, network_load_balancer_id=None, policy=None):
+    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):
         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)
@@ -41,6 +41,9 @@ class GetBackendSetResult:
         if is_fail_open and not isinstance(is_fail_open, bool):
             raise TypeError("Expected argument 'is_fail_open' to be a bool")
         pulumi.set(__self__, "is_fail_open", is_fail_open)
+        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_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)
@@ -96,6 +99,14 @@ class GetBackendSetResult:
         """
         return pulumi.get(self, "is_fail_open")
 
+    @property
+    @pulumi.getter(name="isInstantFailoverEnabled")
+    def is_instant_failover_enabled(self) -> bool:
+        """
+        If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        """
+        return pulumi.get(self, "is_instant_failover_enabled")
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> bool:
@@ -138,6 +149,7 @@ class AwaitableGetBackendSetResult(GetBackendSetResult):
             id=self.id,
             ip_version=self.ip_version,
             is_fail_open=self.is_fail_open,
+            is_instant_failover_enabled=self.is_instant_failover_enabled,
             is_preserve_source=self.is_preserve_source,
             name=self.name,
             network_load_balancer_id=self.network_load_balancer_id,
@@ -169,6 +181,7 @@ def get_backend_set(backend_set_name: Optional[str] = None,
         id=pulumi.get(__ret__, 'id'),
         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_preserve_source=pulumi.get(__ret__, 'is_preserve_source'),
         name=pulumi.get(__ret__, 'name'),
         network_load_balancer_id=pulumi.get(__ret__, 'network_load_balancer_id'),

pulumi_oci/networkloadbalancer/network_load_balancers_backend_sets_unified.py

@@ -22,6 +22,7 @@ class NetworkLoadBalancersBackendSetsUnifiedArgs:
                  backends: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkLoadBalancersBackendSetsUnifiedBackendArgs']]]] = 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_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None):
         """
@@ -36,6 +37,7 @@ class NetworkLoadBalancersBackendSetsUnifiedArgs:
         :param pulumi.Input[Sequence[pulumi.Input['NetworkLoadBalancersBackendSetsUnifiedBackendArgs']]] backends: (Updatable) An array of backends to be associated with the backend set.
         :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_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.
                
@@ -52,6 +54,8 @@ class NetworkLoadBalancersBackendSetsUnifiedArgs:
             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_preserve_source is not None:
             pulumi.set(__self__, "is_preserve_source", is_preserve_source)
         if name is not None:
@@ -133,6 +137,18 @@ class NetworkLoadBalancersBackendSetsUnifiedArgs:
     def is_fail_open(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_fail_open", value)
 
+    @property
+    @pulumi.getter(name="isInstantFailoverEnabled")
+    def is_instant_failover_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        """
+        return pulumi.get(self, "is_instant_failover_enabled")
+
+    @is_instant_failover_enabled.setter
+    def is_instant_failover_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_instant_failover_enabled", value)
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> Optional[pulumi.Input[bool]]:
@@ -169,6 +185,7 @@ class _NetworkLoadBalancersBackendSetsUnifiedState:
                  health_checker: Optional[pulumi.Input['NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs']] = 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_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -179,6 +196,7 @@ class _NetworkLoadBalancersBackendSetsUnifiedState:
         :param pulumi.Input['NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs'] 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[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_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.
                
@@ -200,6 +218,8 @@ class _NetworkLoadBalancersBackendSetsUnifiedState:
             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_preserve_source is not None:
             pulumi.set(__self__, "is_preserve_source", is_preserve_source)
         if name is not None:
@@ -257,6 +277,18 @@ class _NetworkLoadBalancersBackendSetsUnifiedState:
     def is_fail_open(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_fail_open", value)
 
+    @property
+    @pulumi.getter(name="isInstantFailoverEnabled")
+    def is_instant_failover_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        """
+        return pulumi.get(self, "is_instant_failover_enabled")
+
+    @is_instant_failover_enabled.setter
+    def is_instant_failover_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "is_instant_failover_enabled", value)
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> Optional[pulumi.Input[bool]]:
@@ -323,6 +355,7 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
                  health_checker: Optional[pulumi.Input[pulumi.InputType['NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs']]] = 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_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -373,6 +406,7 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
                 weight=network_load_balancers_backend_sets_unified_backends_weight,
             )],
             ip_version=network_load_balancers_backend_sets_unified_ip_version,
+            is_instant_failover_enabled=network_load_balancers_backend_sets_unified_is_instant_failover_enabled,
             is_fail_open=network_load_balancers_backend_sets_unified_is_fail_open,
             is_preserve_source=network_load_balancers_backend_sets_unified_is_preserve_source)
         ```
@@ -391,6 +425,7 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
         :param pulumi.Input[pulumi.InputType['NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs']] 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[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_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.
                
@@ -455,6 +490,7 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
                 weight=network_load_balancers_backend_sets_unified_backends_weight,
             )],
             ip_version=network_load_balancers_backend_sets_unified_ip_version,
+            is_instant_failover_enabled=network_load_balancers_backend_sets_unified_is_instant_failover_enabled,
             is_fail_open=network_load_balancers_backend_sets_unified_is_fail_open,
             is_preserve_source=network_load_balancers_backend_sets_unified_is_preserve_source)
         ```
@@ -486,6 +522,7 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
                  health_checker: Optional[pulumi.Input[pulumi.InputType['NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs']]] = 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_preserve_source: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -505,6 +542,7 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
             __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_preserve_source"] = is_preserve_source
             __props__.__dict__["name"] = name
             if network_load_balancer_id is None and not opts.urn:
@@ -527,6 +565,7 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
             health_checker: Optional[pulumi.Input[pulumi.InputType['NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs']]] = 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_preserve_source: Optional[pulumi.Input[bool]] = None,
             name: Optional[pulumi.Input[str]] = None,
             network_load_balancer_id: Optional[pulumi.Input[str]] = None,
@@ -542,6 +581,7 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
         :param pulumi.Input[pulumi.InputType['NetworkLoadBalancersBackendSetsUnifiedHealthCheckerArgs']] 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[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_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.
                
@@ -563,6 +603,7 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
         __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_preserve_source"] = is_preserve_source
         __props__.__dict__["name"] = name
         __props__.__dict__["network_load_balancer_id"] = network_load_balancer_id
@@ -601,6 +642,14 @@ class NetworkLoadBalancersBackendSetsUnified(pulumi.CustomResource):
         """
         return pulumi.get(self, "is_fail_open")
 
+    @property
+    @pulumi.getter(name="isInstantFailoverEnabled")
+    def is_instant_failover_enabled(self) -> pulumi.Output[bool]:
+        """
+        (Updatable) If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        """
+        return pulumi.get(self, "is_instant_failover_enabled")
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> pulumi.Output[bool]:

pulumi_oci/networkloadbalancer/outputs.py

@@ -1299,6 +1299,7 @@ class GetBackendSetsBackendSetCollectionItemResult(dict):
                  id: str,
                  ip_version: str,
                  is_fail_open: bool,
+                 is_instant_failover_enabled: bool,
                  is_preserve_source: bool,
                  name: str,
                  network_load_balancer_id: str,
@@ -1308,6 +1309,7 @@ class GetBackendSetsBackendSetCollectionItemResult(dict):
         :param Sequence['GetBackendSetsBackendSetCollectionItemHealthCheckerArgs'] health_checkers: 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 str ip_version: IP version associated with the backend set.
         :param bool is_fail_open: 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 bool is_instant_failover_enabled: If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
         :param bool is_preserve_source: 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 str name: A user-friendly name for the backend set that must be unique and cannot be changed.
         :param 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.
@@ -1318,6 +1320,7 @@ class GetBackendSetsBackendSetCollectionItemResult(dict):
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "ip_version", ip_version)
         pulumi.set(__self__, "is_fail_open", is_fail_open)
+        pulumi.set(__self__, "is_instant_failover_enabled", is_instant_failover_enabled)
         pulumi.set(__self__, "is_preserve_source", is_preserve_source)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "network_load_balancer_id", network_load_balancer_id)
@@ -1360,6 +1363,14 @@ class GetBackendSetsBackendSetCollectionItemResult(dict):
         """
         return pulumi.get(self, "is_fail_open")
 
+    @property
+    @pulumi.getter(name="isInstantFailoverEnabled")
+    def is_instant_failover_enabled(self) -> bool:
+        """
+        If enabled existing connections will be forwarded to an alternative healthy backend as soon as current backend becomes unhealthy.
+        """
+        return pulumi.get(self, "is_instant_failover_enabled")
+
     @property
     @pulumi.getter(name="isPreserveSource")
     def is_preserve_source(self) -> bool:

pulumi_oci/provider.py

@@ -29,8 +29,8 @@ class ProviderArgs:
                  user_ocid: Optional[pulumi.Input[str]] = None):
         """
         The set of arguments for constructing a Provider resource.
-        :param pulumi.Input[str] auth: (Optional) The type of auth to use. Options are 'ApiKey', 'SecurityToken' and 'InstancePrincipal' and
-               'ResourcePrincipal'. By default, 'ApiKey' will be used.
+        :param pulumi.Input[str] auth: (Optional) The type of auth to use. Options are 'ApiKey', 'SecurityToken', 'InstancePrincipal', 'ResourcePrincipal' and
+               'OKEWorkloadIdentity'. By default, 'ApiKey' will be used.
         :param pulumi.Input[str] config_file_profile: (Optional) The profile name to be used from config file, if not set it will be DEFAULT.
         :param pulumi.Input[bool] disable_auto_retries: (Optional) Disable automatic retries for retriable errors. Automatic retries were introduced to solve some eventual
                consistency problems but it also introduced performance issues on destroy operations.
@@ -84,8 +84,8 @@ class ProviderArgs:
     @pulumi.getter
     def auth(self) -> Optional[pulumi.Input[str]]:
         """
-        (Optional) The type of auth to use. Options are 'ApiKey', 'SecurityToken' and 'InstancePrincipal' and
-        'ResourcePrincipal'. By default, 'ApiKey' will be used.
+        (Optional) The type of auth to use. Options are 'ApiKey', 'SecurityToken', 'InstancePrincipal', 'ResourcePrincipal' and
+        'OKEWorkloadIdentity'. By default, 'ApiKey' will be used.
         """
         return pulumi.get(self, "auth")
 
@@ -274,8 +274,8 @@ class Provider(pulumi.ProviderResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[str] auth: (Optional) The type of auth to use. Options are 'ApiKey', 'SecurityToken' and 'InstancePrincipal' and
-               'ResourcePrincipal'. By default, 'ApiKey' will be used.
+        :param pulumi.Input[str] auth: (Optional) The type of auth to use. Options are 'ApiKey', 'SecurityToken', 'InstancePrincipal', 'ResourcePrincipal' and
+               'OKEWorkloadIdentity'. By default, 'ApiKey' will be used.
         :param pulumi.Input[str] config_file_profile: (Optional) The profile name to be used from config file, if not set it will be DEFAULT.
         :param pulumi.Input[bool] disable_auto_retries: (Optional) Disable automatic retries for retriable errors. Automatic retries were introduced to solve some eventual
                consistency problems but it also introduced performance issues on destroy operations.
@@ -372,8 +372,8 @@ class Provider(pulumi.ProviderResource):
     @pulumi.getter
     def auth(self) -> pulumi.Output[Optional[str]]:
         """
-        (Optional) The type of auth to use. Options are 'ApiKey', 'SecurityToken' and 'InstancePrincipal' and
-        'ResourcePrincipal'. By default, 'ApiKey' will be used.
+        (Optional) The type of auth to use. Options are 'ApiKey', 'SecurityToken', 'InstancePrincipal', 'ResourcePrincipal' and
+        'OKEWorkloadIdentity'. By default, 'ApiKey' will be used.
         """
         return pulumi.get(self, "auth")
 

pulumi_oci/recoverymod/_inputs.py

@@ -25,6 +25,7 @@ class ProtectedDatabaseMetricArgs:
                  current_retention_period_in_seconds: Optional[pulumi.Input[float]] = None,
                  db_size_in_gbs: Optional[pulumi.Input[float]] = None,
                  is_redo_logs_enabled: Optional[pulumi.Input[bool]] = None,
+                 minimum_recovery_needed_in_days: Optional[pulumi.Input[float]] = None,
                  retention_period_in_days: Optional[pulumi.Input[float]] = None,
                  unprotected_window_in_seconds: Optional[pulumi.Input[float]] = None):
         """
@@ -33,6 +34,7 @@ class ProtectedDatabaseMetricArgs:
         :param pulumi.Input[float] current_retention_period_in_seconds: Number of seconds backups are currently retained for this database.
         :param pulumi.Input[float] db_size_in_gbs: The estimated space, in gigabytes, consumed by the protected database. The database size is based on the size of the data files in the catalog, and does not include archive logs.
         :param pulumi.Input[bool] is_redo_logs_enabled: The value TRUE indicates that the protected database is configured to use Real-time data protection, and redo-data is sent from the protected database to Recovery Service. Real-time data protection substantially reduces the window of potential data loss that exists between successive archived redo log backups.
+        :param pulumi.Input[float] minimum_recovery_needed_in_days: Number of days of redo/archive to be applied to recover database.
         :param pulumi.Input[float] retention_period_in_days: The maximum number of days to retain backups for a protected database.
         :param pulumi.Input[float] unprotected_window_in_seconds: This is the time window when there is data loss exposure. The point after which recovery is impossible unless additional redo is available.  This is the time we received the last backup or last redo-log shipped.
         """
@@ -46,6 +48,8 @@ class ProtectedDatabaseMetricArgs:
             pulumi.set(__self__, "db_size_in_gbs", db_size_in_gbs)
         if is_redo_logs_enabled is not None:
             pulumi.set(__self__, "is_redo_logs_enabled", is_redo_logs_enabled)
+        if minimum_recovery_needed_in_days is not None:
+            pulumi.set(__self__, "minimum_recovery_needed_in_days", minimum_recovery_needed_in_days)
         if retention_period_in_days is not None:
             pulumi.set(__self__, "retention_period_in_days", retention_period_in_days)
         if unprotected_window_in_seconds is not None:
@@ -111,6 +115,18 @@ class ProtectedDatabaseMetricArgs:
     def is_redo_logs_enabled(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_redo_logs_enabled", value)
 
+    @property
+    @pulumi.getter(name="minimumRecoveryNeededInDays")
+    def minimum_recovery_needed_in_days(self) -> Optional[pulumi.Input[float]]:
+        """
+        Number of days of redo/archive to be applied to recover database.
+        """
+        return pulumi.get(self, "minimum_recovery_needed_in_days")
+
+    @minimum_recovery_needed_in_days.setter
+    def minimum_recovery_needed_in_days(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "minimum_recovery_needed_in_days", value)
+
     @property
     @pulumi.getter(name="retentionPeriodInDays")
     def retention_period_in_days(self) -> Optional[pulumi.Input[float]]:

pulumi_oci/recoverymod/get_protected_database.py

@@ -22,7 +22,7 @@ class GetProtectedDatabaseResult:
     """
     A collection of values returned by getProtectedDatabase.
     """
-    def __init__(__self__, compartment_id=None, database_id=None, database_size=None, db_unique_name=None, defined_tags=None, display_name=None, freeform_tags=None, health=None, health_details=None, id=None, is_read_only_resource=None, is_redo_logs_shipped=None, lifecycle_details=None, metrics=None, password=None, protected_database_id=None, protection_policy_id=None, recovery_service_subnets=None, state=None, system_tags=None, time_created=None, time_updated=None, vpc_user_name=None):
+    def __init__(__self__, compartment_id=None, database_id=None, database_size=None, db_unique_name=None, defined_tags=None, deletion_schedule=None, display_name=None, freeform_tags=None, health=None, health_details=None, id=None, is_read_only_resource=None, is_redo_logs_shipped=None, lifecycle_details=None, metrics=None, password=None, policy_locked_date_time=None, protected_database_id=None, protection_policy_id=None, recovery_service_subnets=None, state=None, system_tags=None, time_created=None, time_updated=None, vpc_user_name=None):
         if compartment_id and not isinstance(compartment_id, str):
             raise TypeError("Expected argument 'compartment_id' to be a str")
         pulumi.set(__self__, "compartment_id", compartment_id)
@@ -38,6 +38,9 @@ class GetProtectedDatabaseResult:
         if defined_tags and not isinstance(defined_tags, dict):
             raise TypeError("Expected argument 'defined_tags' to be a dict")
         pulumi.set(__self__, "defined_tags", defined_tags)
+        if deletion_schedule and not isinstance(deletion_schedule, str):
+            raise TypeError("Expected argument 'deletion_schedule' to be a str")
+        pulumi.set(__self__, "deletion_schedule", deletion_schedule)
         if display_name and not isinstance(display_name, str):
             raise TypeError("Expected argument 'display_name' to be a str")
         pulumi.set(__self__, "display_name", display_name)
@@ -68,6 +71,9 @@ class GetProtectedDatabaseResult:
         if password and not isinstance(password, str):
             raise TypeError("Expected argument 'password' to be a str")
         pulumi.set(__self__, "password", password)
+        if policy_locked_date_time and not isinstance(policy_locked_date_time, str):
+            raise TypeError("Expected argument 'policy_locked_date_time' to be a str")
+        pulumi.set(__self__, "policy_locked_date_time", policy_locked_date_time)
         if protected_database_id and not isinstance(protected_database_id, str):
             raise TypeError("Expected argument 'protected_database_id' to be a str")
         pulumi.set(__self__, "protected_database_id", protected_database_id)
@@ -133,6 +139,11 @@ class GetProtectedDatabaseResult:
         """
         return pulumi.get(self, "defined_tags")
 
+    @property
+    @pulumi.getter(name="deletionSchedule")
+    def deletion_schedule(self) -> str:
+        return pulumi.get(self, "deletion_schedule")
+
     @property
     @pulumi.getter(name="displayName")
     def display_name(self) -> str:
@@ -153,10 +164,7 @@ class GetProtectedDatabaseResult:
     @pulumi.getter
     def health(self) -> str:
         """
-        Indicates the protection status of the database. Allowed values are:
-        * HEALTHY
-        * WARNING
-        * ALERT
+        Indicates the protection status of the database.
         """
         return pulumi.get(self, "health")
 
@@ -213,6 +221,14 @@ class GetProtectedDatabaseResult:
     def password(self) -> str:
         return pulumi.get(self, "password")
 
+    @property
+    @pulumi.getter(name="policyLockedDateTime")
+    def policy_locked_date_time(self) -> str:
+        """
+        An RFC3339 formatted datetime string that specifies the exact date and time for the retention lock to take effect and permanently lock the retention period defined in the policy.
+        """
+        return pulumi.get(self, "policy_locked_date_time")
+
     @property
     @pulumi.getter(name="protectedDatabaseId")
     def protected_database_id(self) -> str:
@@ -286,6 +302,7 @@ class AwaitableGetProtectedDatabaseResult(GetProtectedDatabaseResult):
             database_size=self.database_size,
             db_unique_name=self.db_unique_name,
             defined_tags=self.defined_tags,
+            deletion_schedule=self.deletion_schedule,
             display_name=self.display_name,
             freeform_tags=self.freeform_tags,
             health=self.health,
@@ -296,6 +313,7 @@ class AwaitableGetProtectedDatabaseResult(GetProtectedDatabaseResult):
             lifecycle_details=self.lifecycle_details,
             metrics=self.metrics,
             password=self.password,
+            policy_locked_date_time=self.policy_locked_date_time,
             protected_database_id=self.protected_database_id,
             protection_policy_id=self.protection_policy_id,
             recovery_service_subnets=self.recovery_service_subnets,
@@ -336,6 +354,7 @@ def get_protected_database(protected_database_id: Optional[str] = None,
         database_size=pulumi.get(__ret__, 'database_size'),
         db_unique_name=pulumi.get(__ret__, 'db_unique_name'),
         defined_tags=pulumi.get(__ret__, 'defined_tags'),
+        deletion_schedule=pulumi.get(__ret__, 'deletion_schedule'),
         display_name=pulumi.get(__ret__, 'display_name'),
         freeform_tags=pulumi.get(__ret__, 'freeform_tags'),
         health=pulumi.get(__ret__, 'health'),
@@ -346,6 +365,7 @@ def get_protected_database(protected_database_id: Optional[str] = None,
         lifecycle_details=pulumi.get(__ret__, 'lifecycle_details'),
         metrics=pulumi.get(__ret__, 'metrics'),
         password=pulumi.get(__ret__, 'password'),
+        policy_locked_date_time=pulumi.get(__ret__, 'policy_locked_date_time'),
         protected_database_id=pulumi.get(__ret__, 'protected_database_id'),
         protection_policy_id=pulumi.get(__ret__, 'protection_policy_id'),
         recovery_service_subnets=pulumi.get(__ret__, 'recovery_service_subnets'),

pulumi_oci/recoverymod/get_protection_policies.py

@@ -100,13 +100,7 @@ class GetProtectionPoliciesResult:
     @pulumi.getter
     def state(self) -> Optional[str]:
         """
-        The current state of the protection policy. Allowed values are:
-        * CREATING
-        * UPDATING
-        * ACTIVE
-        * DELETING
-        * DELETED
-        * FAILED
+        The current state of the protection policy.
         """
         return pulumi.get(self, "state")