pulumi-spotinst 3.126.0a1761894726__py3-none-any.whl → 3.128.0__py3-none-any.whl

pulumi_spotinst/aws/outputs.py

@@ -150,6 +150,7 @@ __all__ = [
     'OceanLaunchSpecAutoscaleHeadroomsAutomatic',
     'OceanLaunchSpecBlockDeviceMapping',
     'OceanLaunchSpecBlockDeviceMappingEbs',
+    'OceanLaunchSpecBlockDeviceMappingEbsDynamicIops',
     'OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize',
     'OceanLaunchSpecCreateOptions',
     'OceanLaunchSpecDeleteOptions',
@@ -161,6 +162,7 @@ __all__ = [
     'OceanLaunchSpecInstanceStorePolicy',
     'OceanLaunchSpecInstanceTypesFilters',
     'OceanLaunchSpecLabel',
+    'OceanLaunchSpecLoadBalancer',
     'OceanLaunchSpecResourceLimit',
     'OceanLaunchSpecSchedulingShutdownHours',
     'OceanLaunchSpecSchedulingTask',
@@ -9024,7 +9026,9 @@ class OceanLaunchSpecAutoscaleDown(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "maxScaleDownPercentage":
+        if key == "isAggressiveScaleDownEnabled":
+            suggest = "is_aggressive_scale_down_enabled"
+        elif key == "maxScaleDownPercentage":
             suggest = "max_scale_down_percentage"
 
         if suggest:
@@ -9039,13 +9043,25 @@ class OceanLaunchSpecAutoscaleDown(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 is_aggressive_scale_down_enabled: Optional[_builtins.bool] = None,
                  max_scale_down_percentage: Optional[_builtins.float] = None):
         """
+        :param _builtins.bool is_aggressive_scale_down_enabled: When set to 'true', the Aggressive Scale Down feature is enabled.
         :param _builtins.float max_scale_down_percentage: The maximum percentage allowed to scale down in a single scaling action on the nodes running in a specific VNG. Allowed only if maxScaleDownPercentage is set to null at the cluster level. Number between [0.1-100].
         """
+        if is_aggressive_scale_down_enabled is not None:
+            pulumi.set(__self__, "is_aggressive_scale_down_enabled", is_aggressive_scale_down_enabled)
         if max_scale_down_percentage is not None:
             pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
 
+    @_builtins.property
+    @pulumi.getter(name="isAggressiveScaleDownEnabled")
+    def is_aggressive_scale_down_enabled(self) -> Optional[_builtins.bool]:
+        """
+        When set to 'true', the Aggressive Scale Down feature is enabled.
+        """
+        return pulumi.get(self, "is_aggressive_scale_down_enabled")
+
     @_builtins.property
     @pulumi.getter(name="maxScaleDownPercentage")
     def max_scale_down_percentage(self) -> Optional[_builtins.float]:
@@ -9243,6 +9259,8 @@ class OceanLaunchSpecBlockDeviceMappingEbs(dict):
         suggest = None
         if key == "deleteOnTermination":
             suggest = "delete_on_termination"
+        elif key == "dynamicIops":
+            suggest = "dynamic_iops"
         elif key == "dynamicVolumeSize":
             suggest = "dynamic_volume_size"
         elif key == "kmsKeyId":
@@ -9267,6 +9285,7 @@ class OceanLaunchSpecBlockDeviceMappingEbs(dict):
 
     def __init__(__self__, *,
                  delete_on_termination: Optional[_builtins.bool] = None,
+                 dynamic_iops: Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbsDynamicIops'] = None,
                  dynamic_volume_size: Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize'] = None,
                  encrypted: Optional[_builtins.bool] = None,
                  iops: Optional[_builtins.int] = None,
@@ -9277,6 +9296,7 @@ class OceanLaunchSpecBlockDeviceMappingEbs(dict):
                  volume_type: Optional[_builtins.str] = None):
         """
         :param _builtins.bool delete_on_termination: Boolean. Flag to delete the EBS on instance termination.
+        :param 'OceanLaunchSpecBlockDeviceMappingEbsDynamicIopsArgs' dynamic_iops: Set dynamic IOPS properties. When using this object, you cannot use the `iops` attribute. You must use one or the other.
         :param 'OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs' dynamic_volume_size: Object. Set dynamic volume size properties. When using this object, you cannot use volumeSize. You must use one or the other.
         :param _builtins.bool encrypted: Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
         :param _builtins.int iops: Int. The number of I/O operations per second (IOPS) that the volume supports.
@@ -9288,6 +9308,8 @@ class OceanLaunchSpecBlockDeviceMappingEbs(dict):
         """
         if delete_on_termination is not None:
             pulumi.set(__self__, "delete_on_termination", delete_on_termination)
+        if dynamic_iops is not None:
+            pulumi.set(__self__, "dynamic_iops", dynamic_iops)
         if dynamic_volume_size is not None:
             pulumi.set(__self__, "dynamic_volume_size", dynamic_volume_size)
         if encrypted is not None:
@@ -9313,6 +9335,14 @@ class OceanLaunchSpecBlockDeviceMappingEbs(dict):
         """
         return pulumi.get(self, "delete_on_termination")
 
+    @_builtins.property
+    @pulumi.getter(name="dynamicIops")
+    def dynamic_iops(self) -> Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbsDynamicIops']:
+        """
+        Set dynamic IOPS properties. When using this object, you cannot use the `iops` attribute. You must use one or the other.
+        """
+        return pulumi.get(self, "dynamic_iops")
+
     @_builtins.property
     @pulumi.getter(name="dynamicVolumeSize")
     def dynamic_volume_size(self) -> Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize']:
@@ -9378,6 +9408,61 @@ class OceanLaunchSpecBlockDeviceMappingEbs(dict):
         return pulumi.get(self, "volume_type")
 
 
+@pulumi.output_type
+class OceanLaunchSpecBlockDeviceMappingEbsDynamicIops(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "baseSize":
+            suggest = "base_size"
+        elif key == "sizePerResourceUnit":
+            suggest = "size_per_resource_unit"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OceanLaunchSpecBlockDeviceMappingEbsDynamicIops. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OceanLaunchSpecBlockDeviceMappingEbsDynamicIops.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OceanLaunchSpecBlockDeviceMappingEbsDynamicIops.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 base_size: _builtins.int,
+                 resource: _builtins.str,
+                 size_per_resource_unit: _builtins.int):
+        """
+        :param _builtins.int base_size: Initial size for IOPS.
+        :param _builtins.int size_per_resource_unit: Additional size per resource unit (in IOPS). (Example: `baseSize=50`, `sizePerResourceUnit=20`, and an instance with 2 CPU is launched; its IOPS size will be: 90).
+        """
+        pulumi.set(__self__, "base_size", base_size)
+        pulumi.set(__self__, "resource", resource)
+        pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
+
+    @_builtins.property
+    @pulumi.getter(name="baseSize")
+    def base_size(self) -> _builtins.int:
+        """
+        Initial size for IOPS.
+        """
+        return pulumi.get(self, "base_size")
+
+    @_builtins.property
+    @pulumi.getter
+    def resource(self) -> _builtins.str:
+        return pulumi.get(self, "resource")
+
+    @_builtins.property
+    @pulumi.getter(name="sizePerResourceUnit")
+    def size_per_resource_unit(self) -> _builtins.int:
+        """
+        Additional size per resource unit (in IOPS). (Example: `baseSize=50`, `sizePerResourceUnit=20`, and an instance with 2 CPU is launched; its IOPS size will be: 90).
+        """
+        return pulumi.get(self, "size_per_resource_unit")
+
+
 @pulumi.output_type
 class OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize(dict):
     @staticmethod
@@ -10063,6 +10148,48 @@ class OceanLaunchSpecLabel(dict):
         return pulumi.get(self, "value")
 
 
+@pulumi.output_type
+class OceanLaunchSpecLoadBalancer(dict):
+    def __init__(__self__, *,
+                 type: _builtins.str,
+                 arn: Optional[_builtins.str] = None,
+                 name: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str type: Can be set to `CLASSIC` or `TARGET_GROUP`
+        :param _builtins.str arn: Required if type is set to `TARGET_GROUP`
+        :param _builtins.str name: Required if type is set to `CLASSIC`
+        """
+        pulumi.set(__self__, "type", type)
+        if arn is not None:
+            pulumi.set(__self__, "arn", arn)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> _builtins.str:
+        """
+        Can be set to `CLASSIC` or `TARGET_GROUP`
+        """
+        return pulumi.get(self, "type")
+
+    @_builtins.property
+    @pulumi.getter
+    def arn(self) -> Optional[_builtins.str]:
+        """
+        Required if type is set to `TARGET_GROUP`
+        """
+        return pulumi.get(self, "arn")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        """
+        Required if type is set to `CLASSIC`
+        """
+        return pulumi.get(self, "name")
+
+
 @pulumi.output_type
 class OceanLaunchSpecResourceLimit(dict):
     @staticmethod

pulumi_spotinst/ecs/ocean.py

@@ -1098,6 +1098,110 @@ class Ocean(pulumi.CustomResource):
 
         ## Example Usage
 
+        ```python
+        import pulumi
+        import pulumi_spotinst as spotinst
+
+        example = spotinst.ecs.Ocean("example",
+            region="us-west-2",
+            name="sample-ecs-cluster",
+            cluster_name="sample-ecs-cluster",
+            min_size=0,
+            max_size=1,
+            desired_capacity=0,
+            subnet_ids=["subnet-12345"],
+            instance_types=[{
+                "filters": [{
+                    "architectures": [
+                        "x86_64",
+                        "i386",
+                    ],
+                    "categories": [
+                        "Accelerated_computing",
+                        "Compute_optimized",
+                    ],
+                    "diskTypes": [
+                        "EBS",
+                        "SSD",
+                    ],
+                    "excludeFamilies": ["m*"],
+                    "excludeMetal": False,
+                    "hypervisor": ["xen"],
+                    "includeFamilies": [
+                        "c*",
+                        "t*",
+                    ],
+                    "isEnaSupported": False,
+                    "maxGpu": 4,
+                    "minGpu": 0,
+                    "maxMemoryGib": 16,
+                    "maxNetworkPerformance": 20,
+                    "maxVcpu": 16,
+                    "minEnis": 2,
+                    "minMemoryGib": 8,
+                    "minNetworkPerformance": 2,
+                    "minVcpu": 2,
+                    "rootDeviceTypes": ["ebs"],
+                    "virtualizationTypes": ["hvm"],
+                }],
+            }],
+            security_group_ids=["sg-12345"],
+            image_id="ami-12345",
+            iam_instance_profile="iam-profile",
+            key_pair="KeyPair",
+            user_data="echo hello world",
+            associate_public_ip_address=False,
+            utilize_reserved_instances=False,
+            draining_timeout=120,
+            monitoring=True,
+            ebs_optimized=True,
+            use_as_template_only=True,
+            spot_percentage=100,
+            utilize_commitments=False,
+            fallback_to_ondemand=True,
+            cluster_orientations=[{
+                "availability_vs_cost": "balanced",
+            }],
+            instance_metadata_options={
+                "http_tokens": "required",
+                "http_put_response_hop_limit": 10,
+            },
+            block_device_mappings=[{
+                "device_name": "/dev/xvda1",
+                "ebs": {
+                    "delete_on_termination": True,
+                    "encrypted": False,
+                    "volume_type": "gp2",
+                    "volume_size": 50,
+                    "throughput": 500,
+                    "dynamic_volume_size": {
+                        "base_size": 50,
+                        "resource": "CPU",
+                        "size_per_resource_unit": 20,
+                    },
+                },
+            }],
+            optimize_images={
+                "perform_at": "timeWindow",
+                "time_windows": [
+                    "Sun:02:00-Sun:12:00",
+                    "Sun:05:00-Sun:16:00",
+                ],
+                "should_optimize_ecs_ami": True,
+            },
+            tags=[{
+                "key": "fakeKey",
+                "value": "fakeValue",
+            }],
+            logging={
+                "export": {
+                    "s3s": [{
+                        "id": "di-abcd123",
+                    }],
+                },
+            })
+        ```
+
         ## Import
 
         Clusters can be imported using the Ocean `id`, e.g.,
@@ -1151,6 +1255,110 @@ class Ocean(pulumi.CustomResource):
 
         ## Example Usage
 
+        ```python
+        import pulumi
+        import pulumi_spotinst as spotinst
+
+        example = spotinst.ecs.Ocean("example",
+            region="us-west-2",
+            name="sample-ecs-cluster",
+            cluster_name="sample-ecs-cluster",
+            min_size=0,
+            max_size=1,
+            desired_capacity=0,
+            subnet_ids=["subnet-12345"],
+            instance_types=[{
+                "filters": [{
+                    "architectures": [
+                        "x86_64",
+                        "i386",
+                    ],
+                    "categories": [
+                        "Accelerated_computing",
+                        "Compute_optimized",
+                    ],
+                    "diskTypes": [
+                        "EBS",
+                        "SSD",
+                    ],
+                    "excludeFamilies": ["m*"],
+                    "excludeMetal": False,
+                    "hypervisor": ["xen"],
+                    "includeFamilies": [
+                        "c*",
+                        "t*",
+                    ],
+                    "isEnaSupported": False,
+                    "maxGpu": 4,
+                    "minGpu": 0,
+                    "maxMemoryGib": 16,
+                    "maxNetworkPerformance": 20,
+                    "maxVcpu": 16,
+                    "minEnis": 2,
+                    "minMemoryGib": 8,
+                    "minNetworkPerformance": 2,
+                    "minVcpu": 2,
+                    "rootDeviceTypes": ["ebs"],
+                    "virtualizationTypes": ["hvm"],
+                }],
+            }],
+            security_group_ids=["sg-12345"],
+            image_id="ami-12345",
+            iam_instance_profile="iam-profile",
+            key_pair="KeyPair",
+            user_data="echo hello world",
+            associate_public_ip_address=False,
+            utilize_reserved_instances=False,
+            draining_timeout=120,
+            monitoring=True,
+            ebs_optimized=True,
+            use_as_template_only=True,
+            spot_percentage=100,
+            utilize_commitments=False,
+            fallback_to_ondemand=True,
+            cluster_orientations=[{
+                "availability_vs_cost": "balanced",
+            }],
+            instance_metadata_options={
+                "http_tokens": "required",
+                "http_put_response_hop_limit": 10,
+            },
+            block_device_mappings=[{
+                "device_name": "/dev/xvda1",
+                "ebs": {
+                    "delete_on_termination": True,
+                    "encrypted": False,
+                    "volume_type": "gp2",
+                    "volume_size": 50,
+                    "throughput": 500,
+                    "dynamic_volume_size": {
+                        "base_size": 50,
+                        "resource": "CPU",
+                        "size_per_resource_unit": 20,
+                    },
+                },
+            }],
+            optimize_images={
+                "perform_at": "timeWindow",
+                "time_windows": [
+                    "Sun:02:00-Sun:12:00",
+                    "Sun:05:00-Sun:16:00",
+                ],
+                "should_optimize_ecs_ami": True,
+            },
+            tags=[{
+                "key": "fakeKey",
+                "value": "fakeValue",
+            }],
+            logging={
+                "export": {
+                    "s3s": [{
+                        "id": "di-abcd123",
+                    }],
+                },
+            })
+        ```
+
         ## Import
 
         Clusters can be imported using the Ocean `id`, e.g.,

pulumi_spotinst/gke/ocean_launch_spec.py

@@ -60,7 +60,7 @@ class OceanLaunchSpecArgs:
         :param pulumi.Input['OceanLaunchSpecResourceLimitsArgs'] resource_limits: The Ocean virtual node group resource limits object.
         :param pulumi.Input[_builtins.bool] restrict_scale_down: Boolean. When set to `true`, VNG nodes will be treated as if all pods running have the restrict-scale-down label. Therefore, Ocean will not scale nodes down unless empty.
         :param pulumi.Input[_builtins.int] root_volume_size: Root volume size (in GB).
-        :param pulumi.Input[_builtins.str] root_volume_type: Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`.
+        :param pulumi.Input[_builtins.str] root_volume_type: Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`, `"pd-balanced"`.
         :param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskArgs']]] scheduling_tasks: Used to define scheduled tasks such as a manual headroom update.
         :param pulumi.Input[_builtins.str] service_account: The account used by applications running on the VM to call GCP APIs.
         :param pulumi.Input['OceanLaunchSpecShieldedInstanceConfigArgs'] shielded_instance_config: The Ocean shielded instance configuration object.
@@ -287,7 +287,7 @@ class OceanLaunchSpecArgs:
     @pulumi.getter(name="rootVolumeType")
     def root_volume_type(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`.
+        Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`, `"pd-balanced"`.
         """
         return pulumi.get(self, "root_volume_type")
 
@@ -443,7 +443,7 @@ class _OceanLaunchSpecState:
         :param pulumi.Input['OceanLaunchSpecResourceLimitsArgs'] resource_limits: The Ocean virtual node group resource limits object.
         :param pulumi.Input[_builtins.bool] restrict_scale_down: Boolean. When set to `true`, VNG nodes will be treated as if all pods running have the restrict-scale-down label. Therefore, Ocean will not scale nodes down unless empty.
         :param pulumi.Input[_builtins.int] root_volume_size: Root volume size (in GB).
-        :param pulumi.Input[_builtins.str] root_volume_type: Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`.
+        :param pulumi.Input[_builtins.str] root_volume_type: Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`, `"pd-balanced"`.
         :param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskArgs']]] scheduling_tasks: Used to define scheduled tasks such as a manual headroom update.
         :param pulumi.Input[_builtins.str] service_account: The account used by applications running on the VM to call GCP APIs.
         :param pulumi.Input['OceanLaunchSpecShieldedInstanceConfigArgs'] shielded_instance_config: The Ocean shielded instance configuration object.
@@ -671,7 +671,7 @@ class _OceanLaunchSpecState:
     @pulumi.getter(name="rootVolumeType")
     def root_volume_type(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`.
+        Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`, `"pd-balanced"`.
         """
         return pulumi.get(self, "root_volume_type")
 
@@ -932,7 +932,7 @@ class OceanLaunchSpec(pulumi.CustomResource):
         :param pulumi.Input[Union['OceanLaunchSpecResourceLimitsArgs', 'OceanLaunchSpecResourceLimitsArgsDict']] resource_limits: The Ocean virtual node group resource limits object.
         :param pulumi.Input[_builtins.bool] restrict_scale_down: Boolean. When set to `true`, VNG nodes will be treated as if all pods running have the restrict-scale-down label. Therefore, Ocean will not scale nodes down unless empty.
         :param pulumi.Input[_builtins.int] root_volume_size: Root volume size (in GB).
-        :param pulumi.Input[_builtins.str] root_volume_type: Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`.
+        :param pulumi.Input[_builtins.str] root_volume_type: Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`, `"pd-balanced"`.
         :param pulumi.Input[Sequence[pulumi.Input[Union['OceanLaunchSpecSchedulingTaskArgs', 'OceanLaunchSpecSchedulingTaskArgsDict']]]] scheduling_tasks: Used to define scheduled tasks such as a manual headroom update.
         :param pulumi.Input[_builtins.str] service_account: The account used by applications running on the VM to call GCP APIs.
         :param pulumi.Input[Union['OceanLaunchSpecShieldedInstanceConfigArgs', 'OceanLaunchSpecShieldedInstanceConfigArgsDict']] shielded_instance_config: The Ocean shielded instance configuration object.
@@ -1177,7 +1177,7 @@ class OceanLaunchSpec(pulumi.CustomResource):
         :param pulumi.Input[Union['OceanLaunchSpecResourceLimitsArgs', 'OceanLaunchSpecResourceLimitsArgsDict']] resource_limits: The Ocean virtual node group resource limits object.
         :param pulumi.Input[_builtins.bool] restrict_scale_down: Boolean. When set to `true`, VNG nodes will be treated as if all pods running have the restrict-scale-down label. Therefore, Ocean will not scale nodes down unless empty.
         :param pulumi.Input[_builtins.int] root_volume_size: Root volume size (in GB).
-        :param pulumi.Input[_builtins.str] root_volume_type: Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`.
+        :param pulumi.Input[_builtins.str] root_volume_type: Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`, `"pd-balanced"`.
         :param pulumi.Input[Sequence[pulumi.Input[Union['OceanLaunchSpecSchedulingTaskArgs', 'OceanLaunchSpecSchedulingTaskArgsDict']]]] scheduling_tasks: Used to define scheduled tasks such as a manual headroom update.
         :param pulumi.Input[_builtins.str] service_account: The account used by applications running on the VM to call GCP APIs.
         :param pulumi.Input[Union['OceanLaunchSpecShieldedInstanceConfigArgs', 'OceanLaunchSpecShieldedInstanceConfigArgsDict']] shielded_instance_config: The Ocean shielded instance configuration object.
@@ -1330,7 +1330,7 @@ class OceanLaunchSpec(pulumi.CustomResource):
     @pulumi.getter(name="rootVolumeType")
     def root_volume_type(self) -> pulumi.Output[_builtins.str]:
         """
-        Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`.
+        Root volume disk type. Valid values: `"pd-standard"`, `"pd-ssd"`, `"pd-balanced"`.
         """
         return pulumi.get(self, "root_volume_type")