pulumi-spotinst 3.121.0a1750482125__py3-none-any.whl → 3.121.0a1751945899__py3-none-any.whl

pulumi_spotinst/__init__.py

@@ -12,6 +12,7 @@ from .credentials_gcp import *
 from .data_integration import *
 from .elastigroup_azure_v3 import *
 from .health_check import *
+from .notification_center import *
 from .ocean_right_sizing_rule import *
 from .provider import *
 from .stateful_node_azure import *
@@ -253,6 +254,14 @@ _utilities.register(
    "spotinst:index/healthCheck:HealthCheck": "HealthCheck"
   }
  },
+ {
+  "pkg": "spotinst",
+  "mod": "index/notificationCenter",
+  "fqn": "pulumi_spotinst",
+  "classes": {
+   "spotinst:index/notificationCenter:NotificationCenter": "NotificationCenter"
+  }
+ },
  {
   "pkg": "spotinst",
   "mod": "index/oceanRightSizingRule",

pulumi_spotinst/_inputs.py

@@ -94,6 +94,18 @@ __all__ = [
     'ElastigroupAzureV3VmSizesSpotSizeAttributesArgsDict',
     'HealthCheckCheckArgs',
     'HealthCheckCheckArgsDict',
+    'NotificationCenterComputePolicyConfigArgs',
+    'NotificationCenterComputePolicyConfigArgsDict',
+    'NotificationCenterComputePolicyConfigDynamicRuleArgs',
+    'NotificationCenterComputePolicyConfigDynamicRuleArgsDict',
+    'NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs',
+    'NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgsDict',
+    'NotificationCenterComputePolicyConfigEventArgs',
+    'NotificationCenterComputePolicyConfigEventArgsDict',
+    'NotificationCenterRegisteredUserArgs',
+    'NotificationCenterRegisteredUserArgsDict',
+    'NotificationCenterSubscriptionArgs',
+    'NotificationCenterSubscriptionArgsDict',
     'OceanRightSizingRuleAttachWorkloadArgs',
     'OceanRightSizingRuleAttachWorkloadArgsDict',
     'OceanRightSizingRuleAttachWorkloadNamespaceArgs',
@@ -2688,6 +2700,247 @@ class HealthCheckCheckArgs:
         pulumi.set(self, "timeout", value)
 
 
+if not MYPY:
+    class NotificationCenterComputePolicyConfigArgsDict(TypedDict):
+        events: pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigEventArgsDict']]]
+        dynamic_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleArgsDict']]]]
+        resource_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
+        should_include_all_resources: NotRequired[pulumi.Input[builtins.bool]]
+elif False:
+    NotificationCenterComputePolicyConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterComputePolicyConfigArgs:
+    def __init__(__self__, *,
+                 events: pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigEventArgs']]],
+                 dynamic_rules: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleArgs']]]] = None,
+                 resource_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
+                 should_include_all_resources: Optional[pulumi.Input[builtins.bool]] = None):
+        pulumi.set(__self__, "events", events)
+        if dynamic_rules is not None:
+            pulumi.set(__self__, "dynamic_rules", dynamic_rules)
+        if resource_ids is not None:
+            pulumi.set(__self__, "resource_ids", resource_ids)
+        if should_include_all_resources is not None:
+            pulumi.set(__self__, "should_include_all_resources", should_include_all_resources)
+
+    @property
+    @pulumi.getter
+    def events(self) -> pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigEventArgs']]]:
+        return pulumi.get(self, "events")
+
+    @events.setter
+    def events(self, value: pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigEventArgs']]]):
+        pulumi.set(self, "events", value)
+
+    @property
+    @pulumi.getter(name="dynamicRules")
+    def dynamic_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleArgs']]]]:
+        return pulumi.get(self, "dynamic_rules")
+
+    @dynamic_rules.setter
+    def dynamic_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleArgs']]]]):
+        pulumi.set(self, "dynamic_rules", value)
+
+    @property
+    @pulumi.getter(name="resourceIds")
+    def resource_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
+        return pulumi.get(self, "resource_ids")
+
+    @resource_ids.setter
+    def resource_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "resource_ids", value)
+
+    @property
+    @pulumi.getter(name="shouldIncludeAllResources")
+    def should_include_all_resources(self) -> Optional[pulumi.Input[builtins.bool]]:
+        return pulumi.get(self, "should_include_all_resources")
+
+    @should_include_all_resources.setter
+    def should_include_all_resources(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "should_include_all_resources", value)
+
+
+if not MYPY:
+    class NotificationCenterComputePolicyConfigDynamicRuleArgsDict(TypedDict):
+        filter_conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgsDict']]]]
+elif False:
+    NotificationCenterComputePolicyConfigDynamicRuleArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterComputePolicyConfigDynamicRuleArgs:
+    def __init__(__self__, *,
+                 filter_conditions: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs']]]] = None):
+        if filter_conditions is not None:
+            pulumi.set(__self__, "filter_conditions", filter_conditions)
+
+    @property
+    @pulumi.getter(name="filterConditions")
+    def filter_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs']]]]:
+        return pulumi.get(self, "filter_conditions")
+
+    @filter_conditions.setter
+    def filter_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs']]]]):
+        pulumi.set(self, "filter_conditions", value)
+
+
+if not MYPY:
+    class NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgsDict(TypedDict):
+        expression: NotRequired[pulumi.Input[builtins.str]]
+        identifier: NotRequired[pulumi.Input[builtins.str]]
+        operator: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterComputePolicyConfigDynamicRuleFilterConditionArgs:
+    def __init__(__self__, *,
+                 expression: Optional[pulumi.Input[builtins.str]] = None,
+                 identifier: Optional[pulumi.Input[builtins.str]] = None,
+                 operator: Optional[pulumi.Input[builtins.str]] = None):
+        if expression is not None:
+            pulumi.set(__self__, "expression", expression)
+        if identifier is not None:
+            pulumi.set(__self__, "identifier", identifier)
+        if operator is not None:
+            pulumi.set(__self__, "operator", operator)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def identifier(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "identifier")
+
+    @identifier.setter
+    def identifier(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "identifier", value)
+
+    @property
+    @pulumi.getter
+    def operator(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "operator")
+
+    @operator.setter
+    def operator(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "operator", value)
+
+
+if not MYPY:
+    class NotificationCenterComputePolicyConfigEventArgsDict(TypedDict):
+        event: NotRequired[pulumi.Input[builtins.str]]
+        event_type: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    NotificationCenterComputePolicyConfigEventArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterComputePolicyConfigEventArgs:
+    def __init__(__self__, *,
+                 event: Optional[pulumi.Input[builtins.str]] = None,
+                 event_type: Optional[pulumi.Input[builtins.str]] = None):
+        if event is not None:
+            pulumi.set(__self__, "event", event)
+        if event_type is not None:
+            pulumi.set(__self__, "event_type", event_type)
+
+    @property
+    @pulumi.getter
+    def event(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "event")
+
+    @event.setter
+    def event(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "event", value)
+
+    @property
+    @pulumi.getter(name="eventType")
+    def event_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "event_type")
+
+    @event_type.setter
+    def event_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "event_type", value)
+
+
+if not MYPY:
+    class NotificationCenterRegisteredUserArgsDict(TypedDict):
+        subscription_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
+        user_email: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    NotificationCenterRegisteredUserArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterRegisteredUserArgs:
+    def __init__(__self__, *,
+                 subscription_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
+                 user_email: Optional[pulumi.Input[builtins.str]] = None):
+        if subscription_types is not None:
+            pulumi.set(__self__, "subscription_types", subscription_types)
+        if user_email is not None:
+            pulumi.set(__self__, "user_email", user_email)
+
+    @property
+    @pulumi.getter(name="subscriptionTypes")
+    def subscription_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
+        return pulumi.get(self, "subscription_types")
+
+    @subscription_types.setter
+    def subscription_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "subscription_types", value)
+
+    @property
+    @pulumi.getter(name="userEmail")
+    def user_email(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "user_email")
+
+    @user_email.setter
+    def user_email(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "user_email", value)
+
+
+if not MYPY:
+    class NotificationCenterSubscriptionArgsDict(TypedDict):
+        endpoint: NotRequired[pulumi.Input[builtins.str]]
+        subscription_type: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    NotificationCenterSubscriptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NotificationCenterSubscriptionArgs:
+    def __init__(__self__, *,
+                 endpoint: Optional[pulumi.Input[builtins.str]] = None,
+                 subscription_type: Optional[pulumi.Input[builtins.str]] = None):
+        if endpoint is not None:
+            pulumi.set(__self__, "endpoint", endpoint)
+        if subscription_type is not None:
+            pulumi.set(__self__, "subscription_type", subscription_type)
+
+    @property
+    @pulumi.getter
+    def endpoint(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "endpoint")
+
+    @endpoint.setter
+    def endpoint(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "endpoint", value)
+
+    @property
+    @pulumi.getter(name="subscriptionType")
+    def subscription_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "subscription_type")
+
+    @subscription_type.setter
+    def subscription_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "subscription_type", value)
+
+
 if not MYPY:
     class OceanRightSizingRuleAttachWorkloadArgsDict(TypedDict):
         namespaces: pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAttachWorkloadNamespaceArgsDict']]]
@@ -4863,7 +5116,7 @@ class StatefulNodeAzureSecretVaultCertificateArgs:
 
 if not MYPY:
     class StatefulNodeAzureSecurityArgsDict(TypedDict):
-        confidential_os_disk_encryption: NotRequired[pulumi.Input[builtins.bool]]
+        confidential_os_disk_encryption: NotRequired[pulumi.Input[builtins.str]]
         encryption_at_host: NotRequired[pulumi.Input[builtins.bool]]
         secure_boot_enabled: NotRequired[pulumi.Input[builtins.bool]]
         security_type: NotRequired[pulumi.Input[builtins.str]]
@@ -4874,7 +5127,7 @@ elif False:
 @pulumi.input_type
 class StatefulNodeAzureSecurityArgs:
     def __init__(__self__, *,
-                 confidential_os_disk_encryption: Optional[pulumi.Input[builtins.bool]] = None,
+                 confidential_os_disk_encryption: Optional[pulumi.Input[builtins.str]] = None,
                  encryption_at_host: Optional[pulumi.Input[builtins.bool]] = None,
                  secure_boot_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                  security_type: Optional[pulumi.Input[builtins.str]] = None,
@@ -4892,11 +5145,11 @@ class StatefulNodeAzureSecurityArgs:
 
     @property
     @pulumi.getter(name="confidentialOsDiskEncryption")
-    def confidential_os_disk_encryption(self) -> Optional[pulumi.Input[builtins.bool]]:
+    def confidential_os_disk_encryption(self) -> Optional[pulumi.Input[builtins.str]]:
         return pulumi.get(self, "confidential_os_disk_encryption")
 
     @confidential_os_disk_encryption.setter
-    def confidential_os_disk_encryption(self, value: Optional[pulumi.Input[builtins.bool]]):
+    def confidential_os_disk_encryption(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "confidential_os_disk_encryption", value)
 
     @property

pulumi_spotinst/gcp/_inputs.py

@@ -18,6 +18,8 @@ from .. import _utilities
 __all__ = [
     'ElastigroupBackendServiceArgs',
     'ElastigroupBackendServiceArgsDict',
+    'ElastigroupBackendServiceBackendBalancingArgs',
+    'ElastigroupBackendServiceBackendBalancingArgsDict',
     'ElastigroupBackendServiceNamedPortArgs',
     'ElastigroupBackendServiceNamedPortArgsDict',
     'ElastigroupDiskArgs',
@@ -74,6 +76,10 @@ if not MYPY:
         """
         The name of the backend service.
         """
+        backend_balancing: NotRequired[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgsDict']]
+        """
+        Configure how traffic is distributed across instance groups.
+        """
         location_type: NotRequired[pulumi.Input[builtins.str]]
         """
         Sets which location the backend services will be active. Valid values: `regional`, `global`.
@@ -93,16 +99,20 @@ elif False:
 class ElastigroupBackendServiceArgs:
     def __init__(__self__, *,
                  service_name: pulumi.Input[builtins.str],
+                 backend_balancing: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']] = None,
                  location_type: Optional[pulumi.Input[builtins.str]] = None,
                  named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]] = None,
                  scheme: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] service_name: The name of the backend service.
+        :param pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs'] backend_balancing: Configure how traffic is distributed across instance groups.
         :param pulumi.Input[builtins.str] location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
         :param pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]] named_ports: Describes a named port and a list of ports.
         :param pulumi.Input[builtins.str] scheme: Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
         """
         pulumi.set(__self__, "service_name", service_name)
+        if backend_balancing is not None:
+            pulumi.set(__self__, "backend_balancing", backend_balancing)
         if location_type is not None:
             pulumi.set(__self__, "location_type", location_type)
         if named_ports is not None:
@@ -122,6 +132,18 @@ class ElastigroupBackendServiceArgs:
     def service_name(self, value: pulumi.Input[builtins.str]):
         pulumi.set(self, "service_name", value)
 
+    @property
+    @pulumi.getter(name="backendBalancing")
+    def backend_balancing(self) -> Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]:
+        """
+        Configure how traffic is distributed across instance groups.
+        """
+        return pulumi.get(self, "backend_balancing")
+
+    @backend_balancing.setter
+    def backend_balancing(self, value: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]):
+        pulumi.set(self, "backend_balancing", value)
+
     @property
     @pulumi.getter(name="locationType")
     def location_type(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -159,6 +181,64 @@ class ElastigroupBackendServiceArgs:
         pulumi.set(self, "scheme", value)
 
 
+if not MYPY:
+    class ElastigroupBackendServiceBackendBalancingArgsDict(TypedDict):
+        backend_balancing_mode: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        """
+        max_rate_per_instance: NotRequired[pulumi.Input[builtins.int]]
+        """
+        If the backendBalancingMode is set to RATE, this field is required.
+
+        Usage:
+        """
+elif False:
+    ElastigroupBackendServiceBackendBalancingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ElastigroupBackendServiceBackendBalancingArgs:
+    def __init__(__self__, *,
+                 backend_balancing_mode: Optional[pulumi.Input[builtins.str]] = None,
+                 max_rate_per_instance: Optional[pulumi.Input[builtins.int]] = None):
+        """
+        :param pulumi.Input[builtins.str] backend_balancing_mode: The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        :param pulumi.Input[builtins.int] max_rate_per_instance: If the backendBalancingMode is set to RATE, this field is required.
+               
+               Usage:
+        """
+        if backend_balancing_mode is not None:
+            pulumi.set(__self__, "backend_balancing_mode", backend_balancing_mode)
+        if max_rate_per_instance is not None:
+            pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
+
+    @property
+    @pulumi.getter(name="backendBalancingMode")
+    def backend_balancing_mode(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        """
+        return pulumi.get(self, "backend_balancing_mode")
+
+    @backend_balancing_mode.setter
+    def backend_balancing_mode(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "backend_balancing_mode", value)
+
+    @property
+    @pulumi.getter(name="maxRatePerInstance")
+    def max_rate_per_instance(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        If the backendBalancingMode is set to RATE, this field is required.
+
+        Usage:
+        """
+        return pulumi.get(self, "max_rate_per_instance")
+
+    @max_rate_per_instance.setter
+    def max_rate_per_instance(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "max_rate_per_instance", value)
+
+
 if not MYPY:
     class ElastigroupBackendServiceNamedPortArgsDict(TypedDict):
         name: pulumi.Input[builtins.str]
@@ -168,8 +248,6 @@ if not MYPY:
         ports: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
         """
         A list of ports.
-
-        Usage:
         """
 elif False:
     ElastigroupBackendServiceNamedPortArgsDict: TypeAlias = Mapping[str, Any]
@@ -182,8 +260,6 @@ class ElastigroupBackendServiceNamedPortArgs:
         """
         :param pulumi.Input[builtins.str] name: The name of the port.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ports: A list of ports.
-               
-               Usage:
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "ports", ports)
@@ -205,8 +281,6 @@ class ElastigroupBackendServiceNamedPortArgs:
     def ports(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
         """
         A list of ports.
-
-        Usage:
         """
         return pulumi.get(self, "ports")
 

pulumi_spotinst/gcp/elastigroup.py

@@ -1379,6 +1379,10 @@ class Elastigroup(pulumi.CustomResource):
                         "6000",
                     ],
                 }],
+                "backend_balancing": {
+                    "backend_balancing_mode": "RATE",
+                    "max_rate_per_instance": 500,
+                },
             }],
             disks=[{
                 "device_name": "device",
@@ -1525,6 +1529,10 @@ class Elastigroup(pulumi.CustomResource):
                         "6000",
                     ],
                 }],
+                "backend_balancing": {
+                    "backend_balancing_mode": "RATE",
+                    "max_rate_per_instance": 500,
+                },
             }],
             disks=[{
                 "device_name": "device",

pulumi_spotinst/gcp/outputs.py

@@ -18,6 +18,7 @@ from . import outputs
 
 __all__ = [
     'ElastigroupBackendService',
+    'ElastigroupBackendServiceBackendBalancing',
     'ElastigroupBackendServiceNamedPort',
     'ElastigroupDisk',
     'ElastigroupDiskInitializeParam',
@@ -50,6 +51,8 @@ class ElastigroupBackendService(dict):
         suggest = None
         if key == "serviceName":
             suggest = "service_name"
+        elif key == "backendBalancing":
+            suggest = "backend_balancing"
         elif key == "locationType":
             suggest = "location_type"
         elif key == "namedPorts":
@@ -68,16 +71,20 @@ class ElastigroupBackendService(dict):
 
     def __init__(__self__, *,
                  service_name: builtins.str,
+                 backend_balancing: Optional['outputs.ElastigroupBackendServiceBackendBalancing'] = None,
                  location_type: Optional[builtins.str] = None,
                  named_ports: Optional[Sequence['outputs.ElastigroupBackendServiceNamedPort']] = None,
                  scheme: Optional[builtins.str] = None):
         """
         :param builtins.str service_name: The name of the backend service.
+        :param 'ElastigroupBackendServiceBackendBalancingArgs' backend_balancing: Configure how traffic is distributed across instance groups.
         :param builtins.str location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
         :param Sequence['ElastigroupBackendServiceNamedPortArgs'] named_ports: Describes a named port and a list of ports.
         :param builtins.str scheme: Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
         """
         pulumi.set(__self__, "service_name", service_name)
+        if backend_balancing is not None:
+            pulumi.set(__self__, "backend_balancing", backend_balancing)
         if location_type is not None:
             pulumi.set(__self__, "location_type", location_type)
         if named_ports is not None:
@@ -93,6 +100,14 @@ class ElastigroupBackendService(dict):
         """
         return pulumi.get(self, "service_name")
 
+    @property
+    @pulumi.getter(name="backendBalancing")
+    def backend_balancing(self) -> Optional['outputs.ElastigroupBackendServiceBackendBalancing']:
+        """
+        Configure how traffic is distributed across instance groups.
+        """
+        return pulumi.get(self, "backend_balancing")
+
     @property
     @pulumi.getter(name="locationType")
     def location_type(self) -> Optional[builtins.str]:
@@ -118,6 +133,60 @@ class ElastigroupBackendService(dict):
         return pulumi.get(self, "scheme")
 
 
+@pulumi.output_type
+class ElastigroupBackendServiceBackendBalancing(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "backendBalancingMode":
+            suggest = "backend_balancing_mode"
+        elif key == "maxRatePerInstance":
+            suggest = "max_rate_per_instance"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ElastigroupBackendServiceBackendBalancing. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ElastigroupBackendServiceBackendBalancing.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ElastigroupBackendServiceBackendBalancing.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 backend_balancing_mode: Optional[builtins.str] = None,
+                 max_rate_per_instance: Optional[builtins.int] = None):
+        """
+        :param builtins.str backend_balancing_mode: The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        :param builtins.int max_rate_per_instance: If the backendBalancingMode is set to RATE, this field is required.
+               
+               Usage:
+        """
+        if backend_balancing_mode is not None:
+            pulumi.set(__self__, "backend_balancing_mode", backend_balancing_mode)
+        if max_rate_per_instance is not None:
+            pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
+
+    @property
+    @pulumi.getter(name="backendBalancingMode")
+    def backend_balancing_mode(self) -> Optional[builtins.str]:
+        """
+        The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        """
+        return pulumi.get(self, "backend_balancing_mode")
+
+    @property
+    @pulumi.getter(name="maxRatePerInstance")
+    def max_rate_per_instance(self) -> Optional[builtins.int]:
+        """
+        If the backendBalancingMode is set to RATE, this field is required.
+
+        Usage:
+        """
+        return pulumi.get(self, "max_rate_per_instance")
+
+
 @pulumi.output_type
 class ElastigroupBackendServiceNamedPort(dict):
     def __init__(__self__, *,
@@ -126,8 +195,6 @@ class ElastigroupBackendServiceNamedPort(dict):
         """
         :param builtins.str name: The name of the port.
         :param Sequence[builtins.str] ports: A list of ports.
-               
-               Usage:
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "ports", ports)
@@ -145,8 +212,6 @@ class ElastigroupBackendServiceNamedPort(dict):
     def ports(self) -> Sequence[builtins.str]:
         """
         A list of ports.
-
-        Usage:
         """
         return pulumi.get(self, "ports")