pulumi-spotinst 3.83.0a1720524486__py3-none-any.whl → 3.128.0a1767140134__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_spotinst/__init__.py +38 -1
- pulumi_spotinst/_inputs.py +4082 -846
- pulumi_spotinst/_utilities.py +15 -10
- pulumi_spotinst/account.py +171 -0
- pulumi_spotinst/aws/__init__.py +2 -1
- pulumi_spotinst/aws/_inputs.py +7292 -2871
- pulumi_spotinst/aws/account.py +25 -19
- pulumi_spotinst/aws/beanstalk.py +272 -190
- pulumi_spotinst/aws/credentials.py +42 -36
- pulumi_spotinst/aws/elastigroup.py +1321 -1176
- pulumi_spotinst/aws/managed_instance.py +633 -526
- pulumi_spotinst/aws/mr_scalar.py +827 -983
- pulumi_spotinst/aws/ocean.py +764 -570
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +42 -36
- pulumi_spotinst/aws/ocean_launch_spec.py +580 -366
- pulumi_spotinst/aws/outputs.py +3421 -2205
- pulumi_spotinst/aws/suspension.py +51 -45
- pulumi_spotinst/azure/__init__.py +2 -1
- pulumi_spotinst/azure/_inputs.py +1492 -434
- pulumi_spotinst/azure/ocean_np.py +518 -464
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +479 -408
- pulumi_spotinst/azure/outputs.py +840 -345
- pulumi_spotinst/config/__init__.py +2 -1
- pulumi_spotinst/config/__init__.pyi +7 -2
- pulumi_spotinst/config/vars.py +11 -6
- pulumi_spotinst/credentials_azure.py +423 -0
- pulumi_spotinst/credentials_gcp.py +632 -0
- pulumi_spotinst/data_integration.py +58 -52
- pulumi_spotinst/ecs/__init__.py +2 -1
- pulumi_spotinst/ecs/_inputs.py +1164 -469
- pulumi_spotinst/ecs/ocean.py +711 -446
- pulumi_spotinst/ecs/ocean_launch_spec.py +367 -341
- pulumi_spotinst/ecs/outputs.py +463 -374
- pulumi_spotinst/elastigroup_azure_v3.py +985 -197
- pulumi_spotinst/gcp/__init__.py +2 -1
- pulumi_spotinst/gcp/_inputs.py +1061 -381
- pulumi_spotinst/gcp/elastigroup.py +885 -567
- pulumi_spotinst/gcp/outputs.py +542 -301
- pulumi_spotinst/gke/__init__.py +2 -1
- pulumi_spotinst/gke/_inputs.py +2071 -715
- pulumi_spotinst/gke/elastigroup.py +558 -382
- pulumi_spotinst/gke/ocean_import.py +379 -255
- pulumi_spotinst/gke/ocean_launch_spec.py +501 -384
- pulumi_spotinst/gke/ocean_launch_spec_import.py +42 -36
- pulumi_spotinst/gke/outputs.py +1063 -528
- pulumi_spotinst/health_check.py +116 -70
- pulumi_spotinst/notification_center.py +344 -0
- pulumi_spotinst/ocean_right_sizing_rule.py +515 -95
- pulumi_spotinst/oceancd/__init__.py +2 -1
- pulumi_spotinst/oceancd/_inputs.py +1709 -651
- pulumi_spotinst/oceancd/outputs.py +537 -526
- pulumi_spotinst/oceancd/rollout_spec.py +65 -59
- pulumi_spotinst/oceancd/strategy.py +37 -31
- pulumi_spotinst/oceancd/verification_provider.py +128 -122
- pulumi_spotinst/oceancd/verification_template.py +265 -259
- pulumi_spotinst/organization/__init__.py +2 -1
- pulumi_spotinst/organization/_inputs.py +151 -57
- pulumi_spotinst/organization/outputs.py +51 -46
- pulumi_spotinst/organization/policy.py +76 -70
- pulumi_spotinst/organization/programmatic_user.py +83 -77
- pulumi_spotinst/organization/user.py +126 -120
- pulumi_spotinst/organization/user_group.py +75 -69
- pulumi_spotinst/outputs.py +3005 -832
- pulumi_spotinst/provider.py +66 -40
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +2 -1
- pulumi_spotinst/spark/_inputs.py +290 -81
- pulumi_spotinst/spark/ocean.py +169 -115
- pulumi_spotinst/spark/ocean_virtual_node_group.py +34 -28
- pulumi_spotinst/spark/outputs.py +136 -66
- pulumi_spotinst/stateful_node_azure.py +820 -784
- pulumi_spotinst/subscription.py +93 -87
- {pulumi_spotinst-3.83.0a1720524486.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/METADATA +7 -6
- pulumi_spotinst-3.128.0a1767140134.dist-info/RECORD +77 -0
- {pulumi_spotinst-3.83.0a1720524486.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/WHEEL +1 -1
- pulumi_spotinst-3.83.0a1720524486.dist-info/RECORD +0 -73
- {pulumi_spotinst-3.83.0a1720524486.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/top_level.txt +0 -0
pulumi_spotinst/ecs/ocean.py
CHANGED
|
@@ -1,12 +1,17 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from .. import _utilities
|
|
11
16
|
from . import outputs
|
|
12
17
|
from ._inputs import *
|
|
@@ -16,68 +21,70 @@ __all__ = ['OceanArgs', 'Ocean']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class OceanArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
cluster_name: pulumi.Input[str],
|
|
20
|
-
image_id: pulumi.Input[str],
|
|
21
|
-
region: pulumi.Input[str],
|
|
22
|
-
security_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
23
|
-
subnet_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
24
|
-
associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
|
|
24
|
+
cluster_name: pulumi.Input[_builtins.str],
|
|
25
|
+
image_id: pulumi.Input[_builtins.str],
|
|
26
|
+
region: pulumi.Input[_builtins.str],
|
|
27
|
+
security_group_ids: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
28
|
+
subnet_ids: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
29
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
25
30
|
autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
|
|
26
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
31
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
27
32
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
|
|
28
33
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
|
|
29
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
30
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
31
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
34
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
35
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
36
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
37
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
32
38
|
filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
|
|
33
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
39
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
40
|
instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
|
|
35
|
-
key_pair: Optional[pulumi.Input[str]] = None,
|
|
41
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
42
|
logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
|
|
37
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
38
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
39
|
-
monitoring: Optional[pulumi.Input[bool]] = None,
|
|
40
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
43
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
44
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
45
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
46
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
41
47
|
optimize_images: Optional[pulumi.Input['OceanOptimizeImagesArgs']] = None,
|
|
42
48
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
|
|
43
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
49
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
44
50
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
|
|
45
51
|
update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
|
|
46
|
-
use_as_template_only: Optional[pulumi.Input[bool]] = None,
|
|
47
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
48
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
49
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
50
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
52
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
53
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
54
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
55
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
56
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
51
57
|
"""
|
|
52
58
|
The set of arguments for constructing a Ocean resource.
|
|
53
|
-
:param pulumi.Input[str] cluster_name: The name of the ECS cluster.
|
|
54
|
-
:param pulumi.Input[str] image_id: ID of the image used to launch the instances.
|
|
55
|
-
:param pulumi.Input[str] region: The region the cluster will run in.
|
|
56
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: One or more security group ids.
|
|
57
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
58
|
-
:param pulumi.Input[bool] associate_public_ip_address: Configure public IP address allocation.
|
|
59
|
+
:param pulumi.Input[_builtins.str] cluster_name: The name of the ECS cluster.
|
|
60
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
61
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
62
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_group_ids: One or more security group ids.
|
|
63
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnet_ids: A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
64
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
59
65
|
:param pulumi.Input['OceanAutoscalerArgs'] autoscaler: Describes the Ocean ECS autoscaler.
|
|
60
66
|
:param pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]] block_device_mappings: Object. List of block devices that are exposed to the instance, specify either virtual devices and EBS volumes.
|
|
61
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
62
|
-
:param pulumi.Input[int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
63
|
-
:param pulumi.Input[bool] ebs_optimized: Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
64
|
-
:param pulumi.Input[
|
|
67
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
68
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
69
|
+
:param pulumi.Input[_builtins.bool] ebs_optimized: Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
70
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
71
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
65
72
|
:param pulumi.Input['OceanInstanceMetadataOptionsArgs'] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
66
|
-
:param pulumi.Input[str] key_pair: The key pair to attach the instances.
|
|
73
|
+
:param pulumi.Input[_builtins.str] key_pair: The key pair to attach the instances.
|
|
67
74
|
:param pulumi.Input['OceanLoggingArgs'] logging: Logging configuration.
|
|
68
|
-
:param pulumi.Input[int] max_size: The upper limit of instances the cluster can scale up to.
|
|
69
|
-
:param pulumi.Input[int] min_size: The lower limit of instances the cluster can scale down to.
|
|
70
|
-
:param pulumi.Input[bool] monitoring: Enable detailed monitoring for cluster. Flag will enable Cloud Watch detailed monitoring (one minute increments). Note: there are additional hourly costs for this service based on the region used.
|
|
71
|
-
:param pulumi.Input[str] name: The Ocean cluster name.
|
|
75
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
76
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
77
|
+
:param pulumi.Input[_builtins.bool] monitoring: Enable detailed monitoring for cluster. Flag will enable Cloud Watch detailed monitoring (one minute increments). Note: there are additional hourly costs for this service based on the region used.
|
|
78
|
+
:param pulumi.Input[_builtins.str] name: The Ocean cluster name.
|
|
72
79
|
:param pulumi.Input['OceanOptimizeImagesArgs'] optimize_images: Object. Set auto image update settings.
|
|
73
80
|
:param pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]] scheduled_tasks: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
74
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
81
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
75
82
|
:param pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
76
83
|
:param pulumi.Input['OceanUpdatePolicyArgs'] update_policy: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
77
|
-
:param pulumi.Input[bool] use_as_template_only: launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
78
|
-
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
79
|
-
:param pulumi.Input[bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
80
|
-
:param pulumi.Input[bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
84
|
+
:param pulumi.Input[_builtins.bool] use_as_template_only: launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
85
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
86
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
87
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
81
88
|
"""
|
|
82
89
|
pulumi.set(__self__, "cluster_name", cluster_name)
|
|
83
90
|
pulumi.set(__self__, "image_id", image_id)
|
|
@@ -100,6 +107,8 @@ class OceanArgs:
|
|
|
100
107
|
pulumi.set(__self__, "draining_timeout", draining_timeout)
|
|
101
108
|
if ebs_optimized is not None:
|
|
102
109
|
pulumi.set(__self__, "ebs_optimized", ebs_optimized)
|
|
110
|
+
if fallback_to_ondemand is not None:
|
|
111
|
+
pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
|
|
103
112
|
if filters is not None:
|
|
104
113
|
pulumi.set(__self__, "filters", filters)
|
|
105
114
|
if iam_instance_profile is not None:
|
|
@@ -139,79 +148,79 @@ class OceanArgs:
|
|
|
139
148
|
if whitelists is not None:
|
|
140
149
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
141
150
|
|
|
142
|
-
@property
|
|
151
|
+
@_builtins.property
|
|
143
152
|
@pulumi.getter(name="clusterName")
|
|
144
|
-
def cluster_name(self) -> pulumi.Input[str]:
|
|
153
|
+
def cluster_name(self) -> pulumi.Input[_builtins.str]:
|
|
145
154
|
"""
|
|
146
155
|
The name of the ECS cluster.
|
|
147
156
|
"""
|
|
148
157
|
return pulumi.get(self, "cluster_name")
|
|
149
158
|
|
|
150
159
|
@cluster_name.setter
|
|
151
|
-
def cluster_name(self, value: pulumi.Input[str]):
|
|
160
|
+
def cluster_name(self, value: pulumi.Input[_builtins.str]):
|
|
152
161
|
pulumi.set(self, "cluster_name", value)
|
|
153
162
|
|
|
154
|
-
@property
|
|
163
|
+
@_builtins.property
|
|
155
164
|
@pulumi.getter(name="imageId")
|
|
156
|
-
def image_id(self) -> pulumi.Input[str]:
|
|
165
|
+
def image_id(self) -> pulumi.Input[_builtins.str]:
|
|
157
166
|
"""
|
|
158
167
|
ID of the image used to launch the instances.
|
|
159
168
|
"""
|
|
160
169
|
return pulumi.get(self, "image_id")
|
|
161
170
|
|
|
162
171
|
@image_id.setter
|
|
163
|
-
def image_id(self, value: pulumi.Input[str]):
|
|
172
|
+
def image_id(self, value: pulumi.Input[_builtins.str]):
|
|
164
173
|
pulumi.set(self, "image_id", value)
|
|
165
174
|
|
|
166
|
-
@property
|
|
175
|
+
@_builtins.property
|
|
167
176
|
@pulumi.getter
|
|
168
|
-
def region(self) -> pulumi.Input[str]:
|
|
177
|
+
def region(self) -> pulumi.Input[_builtins.str]:
|
|
169
178
|
"""
|
|
170
179
|
The region the cluster will run in.
|
|
171
180
|
"""
|
|
172
181
|
return pulumi.get(self, "region")
|
|
173
182
|
|
|
174
183
|
@region.setter
|
|
175
|
-
def region(self, value: pulumi.Input[str]):
|
|
184
|
+
def region(self, value: pulumi.Input[_builtins.str]):
|
|
176
185
|
pulumi.set(self, "region", value)
|
|
177
186
|
|
|
178
|
-
@property
|
|
187
|
+
@_builtins.property
|
|
179
188
|
@pulumi.getter(name="securityGroupIds")
|
|
180
|
-
def security_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
189
|
+
def security_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
181
190
|
"""
|
|
182
191
|
One or more security group ids.
|
|
183
192
|
"""
|
|
184
193
|
return pulumi.get(self, "security_group_ids")
|
|
185
194
|
|
|
186
195
|
@security_group_ids.setter
|
|
187
|
-
def security_group_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
196
|
+
def security_group_ids(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
188
197
|
pulumi.set(self, "security_group_ids", value)
|
|
189
198
|
|
|
190
|
-
@property
|
|
199
|
+
@_builtins.property
|
|
191
200
|
@pulumi.getter(name="subnetIds")
|
|
192
|
-
def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
201
|
+
def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
193
202
|
"""
|
|
194
203
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
195
204
|
"""
|
|
196
205
|
return pulumi.get(self, "subnet_ids")
|
|
197
206
|
|
|
198
207
|
@subnet_ids.setter
|
|
199
|
-
def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
208
|
+
def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
200
209
|
pulumi.set(self, "subnet_ids", value)
|
|
201
210
|
|
|
202
|
-
@property
|
|
211
|
+
@_builtins.property
|
|
203
212
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
204
|
-
def associate_public_ip_address(self) -> Optional[pulumi.Input[bool]]:
|
|
213
|
+
def associate_public_ip_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
205
214
|
"""
|
|
206
215
|
Configure public IP address allocation.
|
|
207
216
|
"""
|
|
208
217
|
return pulumi.get(self, "associate_public_ip_address")
|
|
209
218
|
|
|
210
219
|
@associate_public_ip_address.setter
|
|
211
|
-
def associate_public_ip_address(self, value: Optional[pulumi.Input[bool]]):
|
|
220
|
+
def associate_public_ip_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
212
221
|
pulumi.set(self, "associate_public_ip_address", value)
|
|
213
222
|
|
|
214
|
-
@property
|
|
223
|
+
@_builtins.property
|
|
215
224
|
@pulumi.getter
|
|
216
225
|
def autoscaler(self) -> Optional[pulumi.Input['OceanAutoscalerArgs']]:
|
|
217
226
|
"""
|
|
@@ -223,16 +232,16 @@ class OceanArgs:
|
|
|
223
232
|
def autoscaler(self, value: Optional[pulumi.Input['OceanAutoscalerArgs']]):
|
|
224
233
|
pulumi.set(self, "autoscaler", value)
|
|
225
234
|
|
|
226
|
-
@property
|
|
235
|
+
@_builtins.property
|
|
227
236
|
@pulumi.getter
|
|
228
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
237
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
229
238
|
return pulumi.get(self, "blacklists")
|
|
230
239
|
|
|
231
240
|
@blacklists.setter
|
|
232
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
241
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
233
242
|
pulumi.set(self, "blacklists", value)
|
|
234
243
|
|
|
235
|
-
@property
|
|
244
|
+
@_builtins.property
|
|
236
245
|
@pulumi.getter(name="blockDeviceMappings")
|
|
237
246
|
def block_device_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]:
|
|
238
247
|
"""
|
|
@@ -244,7 +253,7 @@ class OceanArgs:
|
|
|
244
253
|
def block_device_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]):
|
|
245
254
|
pulumi.set(self, "block_device_mappings", value)
|
|
246
255
|
|
|
247
|
-
@property
|
|
256
|
+
@_builtins.property
|
|
248
257
|
@pulumi.getter(name="clusterOrientations")
|
|
249
258
|
def cluster_orientations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]:
|
|
250
259
|
return pulumi.get(self, "cluster_orientations")
|
|
@@ -253,43 +262,55 @@ class OceanArgs:
|
|
|
253
262
|
def cluster_orientations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]):
|
|
254
263
|
pulumi.set(self, "cluster_orientations", value)
|
|
255
264
|
|
|
256
|
-
@property
|
|
265
|
+
@_builtins.property
|
|
257
266
|
@pulumi.getter(name="desiredCapacity")
|
|
258
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
267
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
259
268
|
"""
|
|
260
269
|
The number of instances to launch and maintain in the cluster.
|
|
261
270
|
"""
|
|
262
271
|
return pulumi.get(self, "desired_capacity")
|
|
263
272
|
|
|
264
273
|
@desired_capacity.setter
|
|
265
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
274
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
266
275
|
pulumi.set(self, "desired_capacity", value)
|
|
267
276
|
|
|
268
|
-
@property
|
|
277
|
+
@_builtins.property
|
|
269
278
|
@pulumi.getter(name="drainingTimeout")
|
|
270
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
279
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
271
280
|
"""
|
|
272
281
|
The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
273
282
|
"""
|
|
274
283
|
return pulumi.get(self, "draining_timeout")
|
|
275
284
|
|
|
276
285
|
@draining_timeout.setter
|
|
277
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
286
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
278
287
|
pulumi.set(self, "draining_timeout", value)
|
|
279
288
|
|
|
280
|
-
@property
|
|
289
|
+
@_builtins.property
|
|
281
290
|
@pulumi.getter(name="ebsOptimized")
|
|
282
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[bool]]:
|
|
291
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
283
292
|
"""
|
|
284
293
|
Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
285
294
|
"""
|
|
286
295
|
return pulumi.get(self, "ebs_optimized")
|
|
287
296
|
|
|
288
297
|
@ebs_optimized.setter
|
|
289
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[bool]]):
|
|
298
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
290
299
|
pulumi.set(self, "ebs_optimized", value)
|
|
291
300
|
|
|
292
|
-
@property
|
|
301
|
+
@_builtins.property
|
|
302
|
+
@pulumi.getter(name="fallbackToOndemand")
|
|
303
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
304
|
+
"""
|
|
305
|
+
If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
306
|
+
"""
|
|
307
|
+
return pulumi.get(self, "fallback_to_ondemand")
|
|
308
|
+
|
|
309
|
+
@fallback_to_ondemand.setter
|
|
310
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
311
|
+
pulumi.set(self, "fallback_to_ondemand", value)
|
|
312
|
+
|
|
313
|
+
@_builtins.property
|
|
293
314
|
@pulumi.getter
|
|
294
315
|
def filters(self) -> Optional[pulumi.Input['OceanFiltersArgs']]:
|
|
295
316
|
return pulumi.get(self, "filters")
|
|
@@ -298,19 +319,19 @@ class OceanArgs:
|
|
|
298
319
|
def filters(self, value: Optional[pulumi.Input['OceanFiltersArgs']]):
|
|
299
320
|
pulumi.set(self, "filters", value)
|
|
300
321
|
|
|
301
|
-
@property
|
|
322
|
+
@_builtins.property
|
|
302
323
|
@pulumi.getter(name="iamInstanceProfile")
|
|
303
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
|
|
324
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
304
325
|
"""
|
|
305
326
|
The instance profile iam role.
|
|
306
327
|
"""
|
|
307
328
|
return pulumi.get(self, "iam_instance_profile")
|
|
308
329
|
|
|
309
330
|
@iam_instance_profile.setter
|
|
310
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[str]]):
|
|
331
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
311
332
|
pulumi.set(self, "iam_instance_profile", value)
|
|
312
333
|
|
|
313
|
-
@property
|
|
334
|
+
@_builtins.property
|
|
314
335
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
315
336
|
def instance_metadata_options(self) -> Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]:
|
|
316
337
|
"""
|
|
@@ -322,19 +343,19 @@ class OceanArgs:
|
|
|
322
343
|
def instance_metadata_options(self, value: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]):
|
|
323
344
|
pulumi.set(self, "instance_metadata_options", value)
|
|
324
345
|
|
|
325
|
-
@property
|
|
346
|
+
@_builtins.property
|
|
326
347
|
@pulumi.getter(name="keyPair")
|
|
327
|
-
def key_pair(self) -> Optional[pulumi.Input[str]]:
|
|
348
|
+
def key_pair(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
328
349
|
"""
|
|
329
350
|
The key pair to attach the instances.
|
|
330
351
|
"""
|
|
331
352
|
return pulumi.get(self, "key_pair")
|
|
332
353
|
|
|
333
354
|
@key_pair.setter
|
|
334
|
-
def key_pair(self, value: Optional[pulumi.Input[str]]):
|
|
355
|
+
def key_pair(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
335
356
|
pulumi.set(self, "key_pair", value)
|
|
336
357
|
|
|
337
|
-
@property
|
|
358
|
+
@_builtins.property
|
|
338
359
|
@pulumi.getter
|
|
339
360
|
def logging(self) -> Optional[pulumi.Input['OceanLoggingArgs']]:
|
|
340
361
|
"""
|
|
@@ -346,55 +367,55 @@ class OceanArgs:
|
|
|
346
367
|
def logging(self, value: Optional[pulumi.Input['OceanLoggingArgs']]):
|
|
347
368
|
pulumi.set(self, "logging", value)
|
|
348
369
|
|
|
349
|
-
@property
|
|
370
|
+
@_builtins.property
|
|
350
371
|
@pulumi.getter(name="maxSize")
|
|
351
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
372
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
352
373
|
"""
|
|
353
374
|
The upper limit of instances the cluster can scale up to.
|
|
354
375
|
"""
|
|
355
376
|
return pulumi.get(self, "max_size")
|
|
356
377
|
|
|
357
378
|
@max_size.setter
|
|
358
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
379
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
359
380
|
pulumi.set(self, "max_size", value)
|
|
360
381
|
|
|
361
|
-
@property
|
|
382
|
+
@_builtins.property
|
|
362
383
|
@pulumi.getter(name="minSize")
|
|
363
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
384
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
364
385
|
"""
|
|
365
386
|
The lower limit of instances the cluster can scale down to.
|
|
366
387
|
"""
|
|
367
388
|
return pulumi.get(self, "min_size")
|
|
368
389
|
|
|
369
390
|
@min_size.setter
|
|
370
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
391
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
371
392
|
pulumi.set(self, "min_size", value)
|
|
372
393
|
|
|
373
|
-
@property
|
|
394
|
+
@_builtins.property
|
|
374
395
|
@pulumi.getter
|
|
375
|
-
def monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
396
|
+
def monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
376
397
|
"""
|
|
377
398
|
Enable detailed monitoring for cluster. Flag will enable Cloud Watch detailed monitoring (one minute increments). Note: there are additional hourly costs for this service based on the region used.
|
|
378
399
|
"""
|
|
379
400
|
return pulumi.get(self, "monitoring")
|
|
380
401
|
|
|
381
402
|
@monitoring.setter
|
|
382
|
-
def monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
403
|
+
def monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
383
404
|
pulumi.set(self, "monitoring", value)
|
|
384
405
|
|
|
385
|
-
@property
|
|
406
|
+
@_builtins.property
|
|
386
407
|
@pulumi.getter
|
|
387
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
408
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
388
409
|
"""
|
|
389
410
|
The Ocean cluster name.
|
|
390
411
|
"""
|
|
391
412
|
return pulumi.get(self, "name")
|
|
392
413
|
|
|
393
414
|
@name.setter
|
|
394
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
415
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
395
416
|
pulumi.set(self, "name", value)
|
|
396
417
|
|
|
397
|
-
@property
|
|
418
|
+
@_builtins.property
|
|
398
419
|
@pulumi.getter(name="optimizeImages")
|
|
399
420
|
def optimize_images(self) -> Optional[pulumi.Input['OceanOptimizeImagesArgs']]:
|
|
400
421
|
"""
|
|
@@ -406,7 +427,7 @@ class OceanArgs:
|
|
|
406
427
|
def optimize_images(self, value: Optional[pulumi.Input['OceanOptimizeImagesArgs']]):
|
|
407
428
|
pulumi.set(self, "optimize_images", value)
|
|
408
429
|
|
|
409
|
-
@property
|
|
430
|
+
@_builtins.property
|
|
410
431
|
@pulumi.getter(name="scheduledTasks")
|
|
411
432
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]:
|
|
412
433
|
"""
|
|
@@ -418,19 +439,19 @@ class OceanArgs:
|
|
|
418
439
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]):
|
|
419
440
|
pulumi.set(self, "scheduled_tasks", value)
|
|
420
441
|
|
|
421
|
-
@property
|
|
442
|
+
@_builtins.property
|
|
422
443
|
@pulumi.getter(name="spotPercentage")
|
|
423
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
444
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
424
445
|
"""
|
|
425
446
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
426
447
|
"""
|
|
427
448
|
return pulumi.get(self, "spot_percentage")
|
|
428
449
|
|
|
429
450
|
@spot_percentage.setter
|
|
430
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
451
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
431
452
|
pulumi.set(self, "spot_percentage", value)
|
|
432
453
|
|
|
433
|
-
@property
|
|
454
|
+
@_builtins.property
|
|
434
455
|
@pulumi.getter
|
|
435
456
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]:
|
|
436
457
|
"""
|
|
@@ -442,7 +463,7 @@ class OceanArgs:
|
|
|
442
463
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]):
|
|
443
464
|
pulumi.set(self, "tags", value)
|
|
444
465
|
|
|
445
|
-
@property
|
|
466
|
+
@_builtins.property
|
|
446
467
|
@pulumi.getter(name="updatePolicy")
|
|
447
468
|
def update_policy(self) -> Optional[pulumi.Input['OceanUpdatePolicyArgs']]:
|
|
448
469
|
"""
|
|
@@ -454,129 +475,131 @@ class OceanArgs:
|
|
|
454
475
|
def update_policy(self, value: Optional[pulumi.Input['OceanUpdatePolicyArgs']]):
|
|
455
476
|
pulumi.set(self, "update_policy", value)
|
|
456
477
|
|
|
457
|
-
@property
|
|
478
|
+
@_builtins.property
|
|
458
479
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
459
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[bool]]:
|
|
480
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
460
481
|
"""
|
|
461
482
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
462
483
|
"""
|
|
463
484
|
return pulumi.get(self, "use_as_template_only")
|
|
464
485
|
|
|
465
486
|
@use_as_template_only.setter
|
|
466
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[bool]]):
|
|
487
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
467
488
|
pulumi.set(self, "use_as_template_only", value)
|
|
468
489
|
|
|
469
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
470
491
|
@pulumi.getter(name="userData")
|
|
471
|
-
def user_data(self) -> Optional[pulumi.Input[str]]:
|
|
492
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
472
493
|
"""
|
|
473
494
|
Base64-encoded MIME user data to make available to the instances.
|
|
474
495
|
"""
|
|
475
496
|
return pulumi.get(self, "user_data")
|
|
476
497
|
|
|
477
498
|
@user_data.setter
|
|
478
|
-
def user_data(self, value: Optional[pulumi.Input[str]]):
|
|
499
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
479
500
|
pulumi.set(self, "user_data", value)
|
|
480
501
|
|
|
481
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
482
503
|
@pulumi.getter(name="utilizeCommitments")
|
|
483
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[bool]]:
|
|
504
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
484
505
|
"""
|
|
485
506
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
486
507
|
"""
|
|
487
508
|
return pulumi.get(self, "utilize_commitments")
|
|
488
509
|
|
|
489
510
|
@utilize_commitments.setter
|
|
490
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[bool]]):
|
|
511
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
491
512
|
pulumi.set(self, "utilize_commitments", value)
|
|
492
513
|
|
|
493
|
-
@property
|
|
514
|
+
@_builtins.property
|
|
494
515
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
495
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[bool]]:
|
|
516
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
496
517
|
"""
|
|
497
518
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
498
519
|
"""
|
|
499
520
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
500
521
|
|
|
501
522
|
@utilize_reserved_instances.setter
|
|
502
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[bool]]):
|
|
523
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
503
524
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
504
525
|
|
|
505
|
-
@property
|
|
526
|
+
@_builtins.property
|
|
506
527
|
@pulumi.getter
|
|
507
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
528
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
508
529
|
return pulumi.get(self, "whitelists")
|
|
509
530
|
|
|
510
531
|
@whitelists.setter
|
|
511
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
532
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
512
533
|
pulumi.set(self, "whitelists", value)
|
|
513
534
|
|
|
514
535
|
|
|
515
536
|
@pulumi.input_type
|
|
516
537
|
class _OceanState:
|
|
517
538
|
def __init__(__self__, *,
|
|
518
|
-
associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
|
|
539
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
519
540
|
autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
|
|
520
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
541
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
521
542
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
|
|
522
|
-
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
543
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
523
544
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
|
|
524
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
525
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
526
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
545
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
546
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
547
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
548
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
527
549
|
filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
|
|
528
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
529
|
-
image_id: Optional[pulumi.Input[str]] = None,
|
|
550
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
551
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
530
552
|
instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
|
|
531
|
-
key_pair: Optional[pulumi.Input[str]] = None,
|
|
553
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
532
554
|
logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
|
|
533
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
534
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
535
|
-
monitoring: Optional[pulumi.Input[bool]] = None,
|
|
536
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
555
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
556
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
557
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
558
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
537
559
|
optimize_images: Optional[pulumi.Input['OceanOptimizeImagesArgs']] = None,
|
|
538
|
-
region: Optional[pulumi.Input[str]] = None,
|
|
560
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
539
561
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
|
|
540
|
-
security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
541
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
542
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
562
|
+
security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
563
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
564
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
543
565
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
|
|
544
566
|
update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
|
|
545
|
-
use_as_template_only: Optional[pulumi.Input[bool]] = None,
|
|
546
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
547
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
548
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
549
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
567
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
568
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
569
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
570
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
571
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
550
572
|
"""
|
|
551
573
|
Input properties used for looking up and filtering Ocean resources.
|
|
552
|
-
:param pulumi.Input[bool] associate_public_ip_address: Configure public IP address allocation.
|
|
574
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
553
575
|
:param pulumi.Input['OceanAutoscalerArgs'] autoscaler: Describes the Ocean ECS autoscaler.
|
|
554
576
|
:param pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]] block_device_mappings: Object. List of block devices that are exposed to the instance, specify either virtual devices and EBS volumes.
|
|
555
|
-
:param pulumi.Input[str] cluster_name: The name of the ECS cluster.
|
|
556
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
557
|
-
:param pulumi.Input[int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
558
|
-
:param pulumi.Input[bool] ebs_optimized: Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
559
|
-
:param pulumi.Input[
|
|
560
|
-
:param pulumi.Input[str]
|
|
577
|
+
:param pulumi.Input[_builtins.str] cluster_name: The name of the ECS cluster.
|
|
578
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
579
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
580
|
+
:param pulumi.Input[_builtins.bool] ebs_optimized: Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
581
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
582
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
583
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
561
584
|
:param pulumi.Input['OceanInstanceMetadataOptionsArgs'] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
562
|
-
:param pulumi.Input[str] key_pair: The key pair to attach the instances.
|
|
585
|
+
:param pulumi.Input[_builtins.str] key_pair: The key pair to attach the instances.
|
|
563
586
|
:param pulumi.Input['OceanLoggingArgs'] logging: Logging configuration.
|
|
564
|
-
:param pulumi.Input[int] max_size: The upper limit of instances the cluster can scale up to.
|
|
565
|
-
:param pulumi.Input[int] min_size: The lower limit of instances the cluster can scale down to.
|
|
566
|
-
:param pulumi.Input[bool] monitoring: Enable detailed monitoring for cluster. Flag will enable Cloud Watch detailed monitoring (one minute increments). Note: there are additional hourly costs for this service based on the region used.
|
|
567
|
-
:param pulumi.Input[str] name: The Ocean cluster name.
|
|
587
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
588
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
589
|
+
:param pulumi.Input[_builtins.bool] monitoring: Enable detailed monitoring for cluster. Flag will enable Cloud Watch detailed monitoring (one minute increments). Note: there are additional hourly costs for this service based on the region used.
|
|
590
|
+
:param pulumi.Input[_builtins.str] name: The Ocean cluster name.
|
|
568
591
|
:param pulumi.Input['OceanOptimizeImagesArgs'] optimize_images: Object. Set auto image update settings.
|
|
569
|
-
:param pulumi.Input[str] region: The region the cluster will run in.
|
|
592
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
570
593
|
:param pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]] scheduled_tasks: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
571
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: One or more security group ids.
|
|
572
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
573
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
594
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_group_ids: One or more security group ids.
|
|
595
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
596
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnet_ids: A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
574
597
|
:param pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
575
598
|
:param pulumi.Input['OceanUpdatePolicyArgs'] update_policy: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
576
|
-
:param pulumi.Input[bool] use_as_template_only: launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
577
|
-
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
578
|
-
:param pulumi.Input[bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
579
|
-
:param pulumi.Input[bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
599
|
+
:param pulumi.Input[_builtins.bool] use_as_template_only: launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
600
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
601
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
602
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
580
603
|
"""
|
|
581
604
|
if associate_public_ip_address is not None:
|
|
582
605
|
pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
|
|
@@ -596,6 +619,8 @@ class _OceanState:
|
|
|
596
619
|
pulumi.set(__self__, "draining_timeout", draining_timeout)
|
|
597
620
|
if ebs_optimized is not None:
|
|
598
621
|
pulumi.set(__self__, "ebs_optimized", ebs_optimized)
|
|
622
|
+
if fallback_to_ondemand is not None:
|
|
623
|
+
pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
|
|
599
624
|
if filters is not None:
|
|
600
625
|
pulumi.set(__self__, "filters", filters)
|
|
601
626
|
if iam_instance_profile is not None:
|
|
@@ -643,19 +668,19 @@ class _OceanState:
|
|
|
643
668
|
if whitelists is not None:
|
|
644
669
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
645
670
|
|
|
646
|
-
@property
|
|
671
|
+
@_builtins.property
|
|
647
672
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
648
|
-
def associate_public_ip_address(self) -> Optional[pulumi.Input[bool]]:
|
|
673
|
+
def associate_public_ip_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
649
674
|
"""
|
|
650
675
|
Configure public IP address allocation.
|
|
651
676
|
"""
|
|
652
677
|
return pulumi.get(self, "associate_public_ip_address")
|
|
653
678
|
|
|
654
679
|
@associate_public_ip_address.setter
|
|
655
|
-
def associate_public_ip_address(self, value: Optional[pulumi.Input[bool]]):
|
|
680
|
+
def associate_public_ip_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
656
681
|
pulumi.set(self, "associate_public_ip_address", value)
|
|
657
682
|
|
|
658
|
-
@property
|
|
683
|
+
@_builtins.property
|
|
659
684
|
@pulumi.getter
|
|
660
685
|
def autoscaler(self) -> Optional[pulumi.Input['OceanAutoscalerArgs']]:
|
|
661
686
|
"""
|
|
@@ -667,16 +692,16 @@ class _OceanState:
|
|
|
667
692
|
def autoscaler(self, value: Optional[pulumi.Input['OceanAutoscalerArgs']]):
|
|
668
693
|
pulumi.set(self, "autoscaler", value)
|
|
669
694
|
|
|
670
|
-
@property
|
|
695
|
+
@_builtins.property
|
|
671
696
|
@pulumi.getter
|
|
672
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
697
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
673
698
|
return pulumi.get(self, "blacklists")
|
|
674
699
|
|
|
675
700
|
@blacklists.setter
|
|
676
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
701
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
677
702
|
pulumi.set(self, "blacklists", value)
|
|
678
703
|
|
|
679
|
-
@property
|
|
704
|
+
@_builtins.property
|
|
680
705
|
@pulumi.getter(name="blockDeviceMappings")
|
|
681
706
|
def block_device_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]:
|
|
682
707
|
"""
|
|
@@ -688,19 +713,19 @@ class _OceanState:
|
|
|
688
713
|
def block_device_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]):
|
|
689
714
|
pulumi.set(self, "block_device_mappings", value)
|
|
690
715
|
|
|
691
|
-
@property
|
|
716
|
+
@_builtins.property
|
|
692
717
|
@pulumi.getter(name="clusterName")
|
|
693
|
-
def cluster_name(self) -> Optional[pulumi.Input[str]]:
|
|
718
|
+
def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
694
719
|
"""
|
|
695
720
|
The name of the ECS cluster.
|
|
696
721
|
"""
|
|
697
722
|
return pulumi.get(self, "cluster_name")
|
|
698
723
|
|
|
699
724
|
@cluster_name.setter
|
|
700
|
-
def cluster_name(self, value: Optional[pulumi.Input[str]]):
|
|
725
|
+
def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
701
726
|
pulumi.set(self, "cluster_name", value)
|
|
702
727
|
|
|
703
|
-
@property
|
|
728
|
+
@_builtins.property
|
|
704
729
|
@pulumi.getter(name="clusterOrientations")
|
|
705
730
|
def cluster_orientations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]:
|
|
706
731
|
return pulumi.get(self, "cluster_orientations")
|
|
@@ -709,43 +734,55 @@ class _OceanState:
|
|
|
709
734
|
def cluster_orientations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]):
|
|
710
735
|
pulumi.set(self, "cluster_orientations", value)
|
|
711
736
|
|
|
712
|
-
@property
|
|
737
|
+
@_builtins.property
|
|
713
738
|
@pulumi.getter(name="desiredCapacity")
|
|
714
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
739
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
715
740
|
"""
|
|
716
741
|
The number of instances to launch and maintain in the cluster.
|
|
717
742
|
"""
|
|
718
743
|
return pulumi.get(self, "desired_capacity")
|
|
719
744
|
|
|
720
745
|
@desired_capacity.setter
|
|
721
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
746
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
722
747
|
pulumi.set(self, "desired_capacity", value)
|
|
723
748
|
|
|
724
|
-
@property
|
|
749
|
+
@_builtins.property
|
|
725
750
|
@pulumi.getter(name="drainingTimeout")
|
|
726
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
751
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
727
752
|
"""
|
|
728
753
|
The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
729
754
|
"""
|
|
730
755
|
return pulumi.get(self, "draining_timeout")
|
|
731
756
|
|
|
732
757
|
@draining_timeout.setter
|
|
733
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
758
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
734
759
|
pulumi.set(self, "draining_timeout", value)
|
|
735
760
|
|
|
736
|
-
@property
|
|
761
|
+
@_builtins.property
|
|
737
762
|
@pulumi.getter(name="ebsOptimized")
|
|
738
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[bool]]:
|
|
763
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
739
764
|
"""
|
|
740
765
|
Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
741
766
|
"""
|
|
742
767
|
return pulumi.get(self, "ebs_optimized")
|
|
743
768
|
|
|
744
769
|
@ebs_optimized.setter
|
|
745
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[bool]]):
|
|
770
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
746
771
|
pulumi.set(self, "ebs_optimized", value)
|
|
747
772
|
|
|
748
|
-
@property
|
|
773
|
+
@_builtins.property
|
|
774
|
+
@pulumi.getter(name="fallbackToOndemand")
|
|
775
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
776
|
+
"""
|
|
777
|
+
If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
778
|
+
"""
|
|
779
|
+
return pulumi.get(self, "fallback_to_ondemand")
|
|
780
|
+
|
|
781
|
+
@fallback_to_ondemand.setter
|
|
782
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
783
|
+
pulumi.set(self, "fallback_to_ondemand", value)
|
|
784
|
+
|
|
785
|
+
@_builtins.property
|
|
749
786
|
@pulumi.getter
|
|
750
787
|
def filters(self) -> Optional[pulumi.Input['OceanFiltersArgs']]:
|
|
751
788
|
return pulumi.get(self, "filters")
|
|
@@ -754,31 +791,31 @@ class _OceanState:
|
|
|
754
791
|
def filters(self, value: Optional[pulumi.Input['OceanFiltersArgs']]):
|
|
755
792
|
pulumi.set(self, "filters", value)
|
|
756
793
|
|
|
757
|
-
@property
|
|
794
|
+
@_builtins.property
|
|
758
795
|
@pulumi.getter(name="iamInstanceProfile")
|
|
759
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
|
|
796
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
760
797
|
"""
|
|
761
798
|
The instance profile iam role.
|
|
762
799
|
"""
|
|
763
800
|
return pulumi.get(self, "iam_instance_profile")
|
|
764
801
|
|
|
765
802
|
@iam_instance_profile.setter
|
|
766
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[str]]):
|
|
803
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
767
804
|
pulumi.set(self, "iam_instance_profile", value)
|
|
768
805
|
|
|
769
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
770
807
|
@pulumi.getter(name="imageId")
|
|
771
|
-
def image_id(self) -> Optional[pulumi.Input[str]]:
|
|
808
|
+
def image_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
772
809
|
"""
|
|
773
810
|
ID of the image used to launch the instances.
|
|
774
811
|
"""
|
|
775
812
|
return pulumi.get(self, "image_id")
|
|
776
813
|
|
|
777
814
|
@image_id.setter
|
|
778
|
-
def image_id(self, value: Optional[pulumi.Input[str]]):
|
|
815
|
+
def image_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
779
816
|
pulumi.set(self, "image_id", value)
|
|
780
817
|
|
|
781
|
-
@property
|
|
818
|
+
@_builtins.property
|
|
782
819
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
783
820
|
def instance_metadata_options(self) -> Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]:
|
|
784
821
|
"""
|
|
@@ -790,19 +827,19 @@ class _OceanState:
|
|
|
790
827
|
def instance_metadata_options(self, value: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]):
|
|
791
828
|
pulumi.set(self, "instance_metadata_options", value)
|
|
792
829
|
|
|
793
|
-
@property
|
|
830
|
+
@_builtins.property
|
|
794
831
|
@pulumi.getter(name="keyPair")
|
|
795
|
-
def key_pair(self) -> Optional[pulumi.Input[str]]:
|
|
832
|
+
def key_pair(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
796
833
|
"""
|
|
797
834
|
The key pair to attach the instances.
|
|
798
835
|
"""
|
|
799
836
|
return pulumi.get(self, "key_pair")
|
|
800
837
|
|
|
801
838
|
@key_pair.setter
|
|
802
|
-
def key_pair(self, value: Optional[pulumi.Input[str]]):
|
|
839
|
+
def key_pair(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
803
840
|
pulumi.set(self, "key_pair", value)
|
|
804
841
|
|
|
805
|
-
@property
|
|
842
|
+
@_builtins.property
|
|
806
843
|
@pulumi.getter
|
|
807
844
|
def logging(self) -> Optional[pulumi.Input['OceanLoggingArgs']]:
|
|
808
845
|
"""
|
|
@@ -814,55 +851,55 @@ class _OceanState:
|
|
|
814
851
|
def logging(self, value: Optional[pulumi.Input['OceanLoggingArgs']]):
|
|
815
852
|
pulumi.set(self, "logging", value)
|
|
816
853
|
|
|
817
|
-
@property
|
|
854
|
+
@_builtins.property
|
|
818
855
|
@pulumi.getter(name="maxSize")
|
|
819
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
856
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
820
857
|
"""
|
|
821
858
|
The upper limit of instances the cluster can scale up to.
|
|
822
859
|
"""
|
|
823
860
|
return pulumi.get(self, "max_size")
|
|
824
861
|
|
|
825
862
|
@max_size.setter
|
|
826
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
863
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
827
864
|
pulumi.set(self, "max_size", value)
|
|
828
865
|
|
|
829
|
-
@property
|
|
866
|
+
@_builtins.property
|
|
830
867
|
@pulumi.getter(name="minSize")
|
|
831
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
868
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
832
869
|
"""
|
|
833
870
|
The lower limit of instances the cluster can scale down to.
|
|
834
871
|
"""
|
|
835
872
|
return pulumi.get(self, "min_size")
|
|
836
873
|
|
|
837
874
|
@min_size.setter
|
|
838
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
875
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
839
876
|
pulumi.set(self, "min_size", value)
|
|
840
877
|
|
|
841
|
-
@property
|
|
878
|
+
@_builtins.property
|
|
842
879
|
@pulumi.getter
|
|
843
|
-
def monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
880
|
+
def monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
844
881
|
"""
|
|
845
882
|
Enable detailed monitoring for cluster. Flag will enable Cloud Watch detailed monitoring (one minute increments). Note: there are additional hourly costs for this service based on the region used.
|
|
846
883
|
"""
|
|
847
884
|
return pulumi.get(self, "monitoring")
|
|
848
885
|
|
|
849
886
|
@monitoring.setter
|
|
850
|
-
def monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
887
|
+
def monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
851
888
|
pulumi.set(self, "monitoring", value)
|
|
852
889
|
|
|
853
|
-
@property
|
|
890
|
+
@_builtins.property
|
|
854
891
|
@pulumi.getter
|
|
855
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
892
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
856
893
|
"""
|
|
857
894
|
The Ocean cluster name.
|
|
858
895
|
"""
|
|
859
896
|
return pulumi.get(self, "name")
|
|
860
897
|
|
|
861
898
|
@name.setter
|
|
862
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
899
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
863
900
|
pulumi.set(self, "name", value)
|
|
864
901
|
|
|
865
|
-
@property
|
|
902
|
+
@_builtins.property
|
|
866
903
|
@pulumi.getter(name="optimizeImages")
|
|
867
904
|
def optimize_images(self) -> Optional[pulumi.Input['OceanOptimizeImagesArgs']]:
|
|
868
905
|
"""
|
|
@@ -874,19 +911,19 @@ class _OceanState:
|
|
|
874
911
|
def optimize_images(self, value: Optional[pulumi.Input['OceanOptimizeImagesArgs']]):
|
|
875
912
|
pulumi.set(self, "optimize_images", value)
|
|
876
913
|
|
|
877
|
-
@property
|
|
914
|
+
@_builtins.property
|
|
878
915
|
@pulumi.getter
|
|
879
|
-
def region(self) -> Optional[pulumi.Input[str]]:
|
|
916
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
880
917
|
"""
|
|
881
918
|
The region the cluster will run in.
|
|
882
919
|
"""
|
|
883
920
|
return pulumi.get(self, "region")
|
|
884
921
|
|
|
885
922
|
@region.setter
|
|
886
|
-
def region(self, value: Optional[pulumi.Input[str]]):
|
|
923
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
887
924
|
pulumi.set(self, "region", value)
|
|
888
925
|
|
|
889
|
-
@property
|
|
926
|
+
@_builtins.property
|
|
890
927
|
@pulumi.getter(name="scheduledTasks")
|
|
891
928
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]:
|
|
892
929
|
"""
|
|
@@ -898,43 +935,43 @@ class _OceanState:
|
|
|
898
935
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]):
|
|
899
936
|
pulumi.set(self, "scheduled_tasks", value)
|
|
900
937
|
|
|
901
|
-
@property
|
|
938
|
+
@_builtins.property
|
|
902
939
|
@pulumi.getter(name="securityGroupIds")
|
|
903
|
-
def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
940
|
+
def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
904
941
|
"""
|
|
905
942
|
One or more security group ids.
|
|
906
943
|
"""
|
|
907
944
|
return pulumi.get(self, "security_group_ids")
|
|
908
945
|
|
|
909
946
|
@security_group_ids.setter
|
|
910
|
-
def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
947
|
+
def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
911
948
|
pulumi.set(self, "security_group_ids", value)
|
|
912
949
|
|
|
913
|
-
@property
|
|
950
|
+
@_builtins.property
|
|
914
951
|
@pulumi.getter(name="spotPercentage")
|
|
915
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
952
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
916
953
|
"""
|
|
917
954
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
918
955
|
"""
|
|
919
956
|
return pulumi.get(self, "spot_percentage")
|
|
920
957
|
|
|
921
958
|
@spot_percentage.setter
|
|
922
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
959
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
923
960
|
pulumi.set(self, "spot_percentage", value)
|
|
924
961
|
|
|
925
|
-
@property
|
|
962
|
+
@_builtins.property
|
|
926
963
|
@pulumi.getter(name="subnetIds")
|
|
927
|
-
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
964
|
+
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
928
965
|
"""
|
|
929
966
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
930
967
|
"""
|
|
931
968
|
return pulumi.get(self, "subnet_ids")
|
|
932
969
|
|
|
933
970
|
@subnet_ids.setter
|
|
934
|
-
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
971
|
+
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
935
972
|
pulumi.set(self, "subnet_ids", value)
|
|
936
973
|
|
|
937
|
-
@property
|
|
974
|
+
@_builtins.property
|
|
938
975
|
@pulumi.getter
|
|
939
976
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]:
|
|
940
977
|
"""
|
|
@@ -946,7 +983,7 @@ class _OceanState:
|
|
|
946
983
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]):
|
|
947
984
|
pulumi.set(self, "tags", value)
|
|
948
985
|
|
|
949
|
-
@property
|
|
986
|
+
@_builtins.property
|
|
950
987
|
@pulumi.getter(name="updatePolicy")
|
|
951
988
|
def update_policy(self) -> Optional[pulumi.Input['OceanUpdatePolicyArgs']]:
|
|
952
989
|
"""
|
|
@@ -958,105 +995,213 @@ class _OceanState:
|
|
|
958
995
|
def update_policy(self, value: Optional[pulumi.Input['OceanUpdatePolicyArgs']]):
|
|
959
996
|
pulumi.set(self, "update_policy", value)
|
|
960
997
|
|
|
961
|
-
@property
|
|
998
|
+
@_builtins.property
|
|
962
999
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
963
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[bool]]:
|
|
1000
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
964
1001
|
"""
|
|
965
1002
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
966
1003
|
"""
|
|
967
1004
|
return pulumi.get(self, "use_as_template_only")
|
|
968
1005
|
|
|
969
1006
|
@use_as_template_only.setter
|
|
970
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[bool]]):
|
|
1007
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
971
1008
|
pulumi.set(self, "use_as_template_only", value)
|
|
972
1009
|
|
|
973
|
-
@property
|
|
1010
|
+
@_builtins.property
|
|
974
1011
|
@pulumi.getter(name="userData")
|
|
975
|
-
def user_data(self) -> Optional[pulumi.Input[str]]:
|
|
1012
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
976
1013
|
"""
|
|
977
1014
|
Base64-encoded MIME user data to make available to the instances.
|
|
978
1015
|
"""
|
|
979
1016
|
return pulumi.get(self, "user_data")
|
|
980
1017
|
|
|
981
1018
|
@user_data.setter
|
|
982
|
-
def user_data(self, value: Optional[pulumi.Input[str]]):
|
|
1019
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
983
1020
|
pulumi.set(self, "user_data", value)
|
|
984
1021
|
|
|
985
|
-
@property
|
|
1022
|
+
@_builtins.property
|
|
986
1023
|
@pulumi.getter(name="utilizeCommitments")
|
|
987
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[bool]]:
|
|
1024
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
988
1025
|
"""
|
|
989
1026
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
990
1027
|
"""
|
|
991
1028
|
return pulumi.get(self, "utilize_commitments")
|
|
992
1029
|
|
|
993
1030
|
@utilize_commitments.setter
|
|
994
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[bool]]):
|
|
1031
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
995
1032
|
pulumi.set(self, "utilize_commitments", value)
|
|
996
1033
|
|
|
997
|
-
@property
|
|
1034
|
+
@_builtins.property
|
|
998
1035
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
999
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[bool]]:
|
|
1036
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1000
1037
|
"""
|
|
1001
1038
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1002
1039
|
"""
|
|
1003
1040
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
1004
1041
|
|
|
1005
1042
|
@utilize_reserved_instances.setter
|
|
1006
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[bool]]):
|
|
1043
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1007
1044
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
1008
1045
|
|
|
1009
|
-
@property
|
|
1046
|
+
@_builtins.property
|
|
1010
1047
|
@pulumi.getter
|
|
1011
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1048
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1012
1049
|
return pulumi.get(self, "whitelists")
|
|
1013
1050
|
|
|
1014
1051
|
@whitelists.setter
|
|
1015
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1052
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1016
1053
|
pulumi.set(self, "whitelists", value)
|
|
1017
1054
|
|
|
1018
1055
|
|
|
1056
|
+
@pulumi.type_token("spotinst:ecs/ocean:Ocean")
|
|
1019
1057
|
class Ocean(pulumi.CustomResource):
|
|
1020
1058
|
@overload
|
|
1021
1059
|
def __init__(__self__,
|
|
1022
1060
|
resource_name: str,
|
|
1023
1061
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1024
|
-
associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
|
|
1025
|
-
autoscaler: Optional[pulumi.Input[
|
|
1026
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1027
|
-
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1028
|
-
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
1029
|
-
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1030
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1031
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1032
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
1039
|
-
|
|
1040
|
-
|
|
1041
|
-
|
|
1042
|
-
|
|
1043
|
-
|
|
1044
|
-
|
|
1045
|
-
|
|
1046
|
-
|
|
1047
|
-
|
|
1048
|
-
|
|
1049
|
-
|
|
1050
|
-
|
|
1051
|
-
|
|
1052
|
-
|
|
1053
|
-
|
|
1054
|
-
|
|
1055
|
-
|
|
1062
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1063
|
+
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1064
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1065
|
+
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1066
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1067
|
+
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1068
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1069
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1070
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1071
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1072
|
+
filters: Optional[pulumi.Input[Union['OceanFiltersArgs', 'OceanFiltersArgsDict']]] = None,
|
|
1073
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1074
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1075
|
+
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1076
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1077
|
+
logging: Optional[pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']]] = None,
|
|
1078
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1079
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1080
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1081
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1082
|
+
optimize_images: Optional[pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']]] = None,
|
|
1083
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1084
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]]] = None,
|
|
1085
|
+
security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1086
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1087
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1088
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1089
|
+
update_policy: Optional[pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']]] = None,
|
|
1090
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1091
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1092
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1093
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1094
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1056
1095
|
__props__=None):
|
|
1057
1096
|
"""
|
|
1058
1097
|
Manages a Spotinst Ocean ECS resource.
|
|
1059
1098
|
|
|
1099
|
+
## Example Usage
|
|
1100
|
+
|
|
1101
|
+
```python
|
|
1102
|
+
import pulumi
|
|
1103
|
+
import pulumi_spotinst as spotinst
|
|
1104
|
+
|
|
1105
|
+
example = spotinst.ecs.Ocean("example",
|
|
1106
|
+
region="us-west-2",
|
|
1107
|
+
name="sample-ecs-cluster",
|
|
1108
|
+
cluster_name="sample-ecs-cluster",
|
|
1109
|
+
min_size=0,
|
|
1110
|
+
max_size=1,
|
|
1111
|
+
desired_capacity=0,
|
|
1112
|
+
subnet_ids=["subnet-12345"],
|
|
1113
|
+
instance_types=[{
|
|
1114
|
+
"filters": [{
|
|
1115
|
+
"architectures": [
|
|
1116
|
+
"x86_64",
|
|
1117
|
+
"i386",
|
|
1118
|
+
],
|
|
1119
|
+
"categories": [
|
|
1120
|
+
"Accelerated_computing",
|
|
1121
|
+
"Compute_optimized",
|
|
1122
|
+
],
|
|
1123
|
+
"diskTypes": [
|
|
1124
|
+
"EBS",
|
|
1125
|
+
"SSD",
|
|
1126
|
+
],
|
|
1127
|
+
"excludeFamilies": ["m*"],
|
|
1128
|
+
"excludeMetal": False,
|
|
1129
|
+
"hypervisor": ["xen"],
|
|
1130
|
+
"includeFamilies": [
|
|
1131
|
+
"c*",
|
|
1132
|
+
"t*",
|
|
1133
|
+
],
|
|
1134
|
+
"isEnaSupported": False,
|
|
1135
|
+
"maxGpu": 4,
|
|
1136
|
+
"minGpu": 0,
|
|
1137
|
+
"maxMemoryGib": 16,
|
|
1138
|
+
"maxNetworkPerformance": 20,
|
|
1139
|
+
"maxVcpu": 16,
|
|
1140
|
+
"minEnis": 2,
|
|
1141
|
+
"minMemoryGib": 8,
|
|
1142
|
+
"minNetworkPerformance": 2,
|
|
1143
|
+
"minVcpu": 2,
|
|
1144
|
+
"rootDeviceTypes": ["ebs"],
|
|
1145
|
+
"virtualizationTypes": ["hvm"],
|
|
1146
|
+
}],
|
|
1147
|
+
}],
|
|
1148
|
+
security_group_ids=["sg-12345"],
|
|
1149
|
+
image_id="ami-12345",
|
|
1150
|
+
iam_instance_profile="iam-profile",
|
|
1151
|
+
key_pair="KeyPair",
|
|
1152
|
+
user_data="echo hello world",
|
|
1153
|
+
associate_public_ip_address=False,
|
|
1154
|
+
utilize_reserved_instances=False,
|
|
1155
|
+
draining_timeout=120,
|
|
1156
|
+
monitoring=True,
|
|
1157
|
+
ebs_optimized=True,
|
|
1158
|
+
use_as_template_only=True,
|
|
1159
|
+
spot_percentage=100,
|
|
1160
|
+
utilize_commitments=False,
|
|
1161
|
+
fallback_to_ondemand=True,
|
|
1162
|
+
cluster_orientations=[{
|
|
1163
|
+
"availability_vs_cost": "balanced",
|
|
1164
|
+
}],
|
|
1165
|
+
instance_metadata_options={
|
|
1166
|
+
"http_tokens": "required",
|
|
1167
|
+
"http_put_response_hop_limit": 10,
|
|
1168
|
+
},
|
|
1169
|
+
block_device_mappings=[{
|
|
1170
|
+
"device_name": "/dev/xvda1",
|
|
1171
|
+
"ebs": {
|
|
1172
|
+
"delete_on_termination": True,
|
|
1173
|
+
"encrypted": False,
|
|
1174
|
+
"volume_type": "gp2",
|
|
1175
|
+
"volume_size": 50,
|
|
1176
|
+
"throughput": 500,
|
|
1177
|
+
"dynamic_volume_size": {
|
|
1178
|
+
"base_size": 50,
|
|
1179
|
+
"resource": "CPU",
|
|
1180
|
+
"size_per_resource_unit": 20,
|
|
1181
|
+
},
|
|
1182
|
+
},
|
|
1183
|
+
}],
|
|
1184
|
+
optimize_images={
|
|
1185
|
+
"perform_at": "timeWindow",
|
|
1186
|
+
"time_windows": [
|
|
1187
|
+
"Sun:02:00-Sun:12:00",
|
|
1188
|
+
"Sun:05:00-Sun:16:00",
|
|
1189
|
+
],
|
|
1190
|
+
"should_optimize_ecs_ami": True,
|
|
1191
|
+
},
|
|
1192
|
+
tags=[{
|
|
1193
|
+
"key": "fakeKey",
|
|
1194
|
+
"value": "fakeValue",
|
|
1195
|
+
}],
|
|
1196
|
+
logging={
|
|
1197
|
+
"export": {
|
|
1198
|
+
"s3s": [{
|
|
1199
|
+
"id": "di-abcd123",
|
|
1200
|
+
}],
|
|
1201
|
+
},
|
|
1202
|
+
})
|
|
1203
|
+
```
|
|
1204
|
+
|
|
1060
1205
|
## Import
|
|
1061
1206
|
|
|
1062
1207
|
Clusters can be imported using the Ocean `id`, e.g.,
|
|
@@ -1064,39 +1209,40 @@ class Ocean(pulumi.CustomResource):
|
|
|
1064
1209
|
hcl
|
|
1065
1210
|
|
|
1066
1211
|
```sh
|
|
1067
|
-
$ pulumi import spotinst:ecs/ocean:Ocean
|
|
1212
|
+
$ pulumi import spotinst:ecs/ocean:Ocean nameOfTheResource o-12345678
|
|
1068
1213
|
```
|
|
1069
1214
|
|
|
1070
1215
|
:param str resource_name: The name of the resource.
|
|
1071
1216
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1072
|
-
:param pulumi.Input[bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1073
|
-
:param pulumi.Input[
|
|
1074
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1075
|
-
:param pulumi.Input[str] cluster_name: The name of the ECS cluster.
|
|
1076
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1077
|
-
:param pulumi.Input[int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
1078
|
-
:param pulumi.Input[bool] ebs_optimized: Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
1079
|
-
:param pulumi.Input[
|
|
1080
|
-
:param pulumi.Input[str]
|
|
1081
|
-
:param pulumi.Input[
|
|
1082
|
-
:param pulumi.Input[
|
|
1083
|
-
:param pulumi.Input[
|
|
1084
|
-
:param pulumi.Input[
|
|
1085
|
-
:param pulumi.Input[int]
|
|
1086
|
-
:param pulumi.Input[
|
|
1087
|
-
:param pulumi.Input[
|
|
1088
|
-
:param pulumi.Input[
|
|
1089
|
-
:param pulumi.Input[
|
|
1090
|
-
:param pulumi.Input[
|
|
1091
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1092
|
-
:param pulumi.Input[
|
|
1093
|
-
:param pulumi.Input[
|
|
1094
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1095
|
-
:param pulumi.Input[pulumi.
|
|
1096
|
-
:param pulumi.Input[
|
|
1097
|
-
:param pulumi.Input[
|
|
1098
|
-
:param pulumi.Input[
|
|
1099
|
-
:param pulumi.Input[bool]
|
|
1217
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1218
|
+
:param pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']] autoscaler: Describes the Ocean ECS autoscaler.
|
|
1219
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]] block_device_mappings: Object. List of block devices that are exposed to the instance, specify either virtual devices and EBS volumes.
|
|
1220
|
+
:param pulumi.Input[_builtins.str] cluster_name: The name of the ECS cluster.
|
|
1221
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1222
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
1223
|
+
:param pulumi.Input[_builtins.bool] ebs_optimized: Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
1224
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1225
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
1226
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
1227
|
+
:param pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
1228
|
+
:param pulumi.Input[_builtins.str] key_pair: The key pair to attach the instances.
|
|
1229
|
+
:param pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']] logging: Logging configuration.
|
|
1230
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
1231
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
1232
|
+
:param pulumi.Input[_builtins.bool] monitoring: Enable detailed monitoring for cluster. Flag will enable Cloud Watch detailed monitoring (one minute increments). Note: there are additional hourly costs for this service based on the region used.
|
|
1233
|
+
:param pulumi.Input[_builtins.str] name: The Ocean cluster name.
|
|
1234
|
+
:param pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']] optimize_images: Object. Set auto image update settings.
|
|
1235
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
1236
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]] scheduled_tasks: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
1237
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_group_ids: One or more security group ids.
|
|
1238
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1239
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnet_ids: A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
1240
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
1241
|
+
:param pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']] update_policy: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
1242
|
+
:param pulumi.Input[_builtins.bool] use_as_template_only: launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
1243
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
1244
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1245
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1100
1246
|
"""
|
|
1101
1247
|
...
|
|
1102
1248
|
@overload
|
|
@@ -1107,6 +1253,112 @@ class Ocean(pulumi.CustomResource):
|
|
|
1107
1253
|
"""
|
|
1108
1254
|
Manages a Spotinst Ocean ECS resource.
|
|
1109
1255
|
|
|
1256
|
+
## Example Usage
|
|
1257
|
+
|
|
1258
|
+
```python
|
|
1259
|
+
import pulumi
|
|
1260
|
+
import pulumi_spotinst as spotinst
|
|
1261
|
+
|
|
1262
|
+
example = spotinst.ecs.Ocean("example",
|
|
1263
|
+
region="us-west-2",
|
|
1264
|
+
name="sample-ecs-cluster",
|
|
1265
|
+
cluster_name="sample-ecs-cluster",
|
|
1266
|
+
min_size=0,
|
|
1267
|
+
max_size=1,
|
|
1268
|
+
desired_capacity=0,
|
|
1269
|
+
subnet_ids=["subnet-12345"],
|
|
1270
|
+
instance_types=[{
|
|
1271
|
+
"filters": [{
|
|
1272
|
+
"architectures": [
|
|
1273
|
+
"x86_64",
|
|
1274
|
+
"i386",
|
|
1275
|
+
],
|
|
1276
|
+
"categories": [
|
|
1277
|
+
"Accelerated_computing",
|
|
1278
|
+
"Compute_optimized",
|
|
1279
|
+
],
|
|
1280
|
+
"diskTypes": [
|
|
1281
|
+
"EBS",
|
|
1282
|
+
"SSD",
|
|
1283
|
+
],
|
|
1284
|
+
"excludeFamilies": ["m*"],
|
|
1285
|
+
"excludeMetal": False,
|
|
1286
|
+
"hypervisor": ["xen"],
|
|
1287
|
+
"includeFamilies": [
|
|
1288
|
+
"c*",
|
|
1289
|
+
"t*",
|
|
1290
|
+
],
|
|
1291
|
+
"isEnaSupported": False,
|
|
1292
|
+
"maxGpu": 4,
|
|
1293
|
+
"minGpu": 0,
|
|
1294
|
+
"maxMemoryGib": 16,
|
|
1295
|
+
"maxNetworkPerformance": 20,
|
|
1296
|
+
"maxVcpu": 16,
|
|
1297
|
+
"minEnis": 2,
|
|
1298
|
+
"minMemoryGib": 8,
|
|
1299
|
+
"minNetworkPerformance": 2,
|
|
1300
|
+
"minVcpu": 2,
|
|
1301
|
+
"rootDeviceTypes": ["ebs"],
|
|
1302
|
+
"virtualizationTypes": ["hvm"],
|
|
1303
|
+
}],
|
|
1304
|
+
}],
|
|
1305
|
+
security_group_ids=["sg-12345"],
|
|
1306
|
+
image_id="ami-12345",
|
|
1307
|
+
iam_instance_profile="iam-profile",
|
|
1308
|
+
key_pair="KeyPair",
|
|
1309
|
+
user_data="echo hello world",
|
|
1310
|
+
associate_public_ip_address=False,
|
|
1311
|
+
utilize_reserved_instances=False,
|
|
1312
|
+
draining_timeout=120,
|
|
1313
|
+
monitoring=True,
|
|
1314
|
+
ebs_optimized=True,
|
|
1315
|
+
use_as_template_only=True,
|
|
1316
|
+
spot_percentage=100,
|
|
1317
|
+
utilize_commitments=False,
|
|
1318
|
+
fallback_to_ondemand=True,
|
|
1319
|
+
cluster_orientations=[{
|
|
1320
|
+
"availability_vs_cost": "balanced",
|
|
1321
|
+
}],
|
|
1322
|
+
instance_metadata_options={
|
|
1323
|
+
"http_tokens": "required",
|
|
1324
|
+
"http_put_response_hop_limit": 10,
|
|
1325
|
+
},
|
|
1326
|
+
block_device_mappings=[{
|
|
1327
|
+
"device_name": "/dev/xvda1",
|
|
1328
|
+
"ebs": {
|
|
1329
|
+
"delete_on_termination": True,
|
|
1330
|
+
"encrypted": False,
|
|
1331
|
+
"volume_type": "gp2",
|
|
1332
|
+
"volume_size": 50,
|
|
1333
|
+
"throughput": 500,
|
|
1334
|
+
"dynamic_volume_size": {
|
|
1335
|
+
"base_size": 50,
|
|
1336
|
+
"resource": "CPU",
|
|
1337
|
+
"size_per_resource_unit": 20,
|
|
1338
|
+
},
|
|
1339
|
+
},
|
|
1340
|
+
}],
|
|
1341
|
+
optimize_images={
|
|
1342
|
+
"perform_at": "timeWindow",
|
|
1343
|
+
"time_windows": [
|
|
1344
|
+
"Sun:02:00-Sun:12:00",
|
|
1345
|
+
"Sun:05:00-Sun:16:00",
|
|
1346
|
+
],
|
|
1347
|
+
"should_optimize_ecs_ami": True,
|
|
1348
|
+
},
|
|
1349
|
+
tags=[{
|
|
1350
|
+
"key": "fakeKey",
|
|
1351
|
+
"value": "fakeValue",
|
|
1352
|
+
}],
|
|
1353
|
+
logging={
|
|
1354
|
+
"export": {
|
|
1355
|
+
"s3s": [{
|
|
1356
|
+
"id": "di-abcd123",
|
|
1357
|
+
}],
|
|
1358
|
+
},
|
|
1359
|
+
})
|
|
1360
|
+
```
|
|
1361
|
+
|
|
1110
1362
|
## Import
|
|
1111
1363
|
|
|
1112
1364
|
Clusters can be imported using the Ocean `id`, e.g.,
|
|
@@ -1114,7 +1366,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1114
1366
|
hcl
|
|
1115
1367
|
|
|
1116
1368
|
```sh
|
|
1117
|
-
$ pulumi import spotinst:ecs/ocean:Ocean
|
|
1369
|
+
$ pulumi import spotinst:ecs/ocean:Ocean nameOfTheResource o-12345678
|
|
1118
1370
|
```
|
|
1119
1371
|
|
|
1120
1372
|
:param str resource_name: The name of the resource.
|
|
@@ -1132,38 +1384,39 @@ class Ocean(pulumi.CustomResource):
|
|
|
1132
1384
|
def _internal_init(__self__,
|
|
1133
1385
|
resource_name: str,
|
|
1134
1386
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1135
|
-
associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
|
|
1136
|
-
autoscaler: Optional[pulumi.Input[
|
|
1137
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1138
|
-
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1139
|
-
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
1140
|
-
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1141
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1142
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1143
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
1144
|
-
|
|
1145
|
-
|
|
1146
|
-
|
|
1147
|
-
|
|
1148
|
-
|
|
1149
|
-
|
|
1150
|
-
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
|
|
1158
|
-
|
|
1159
|
-
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1166
|
-
|
|
1387
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1388
|
+
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1389
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1390
|
+
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1391
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1392
|
+
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1393
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1394
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1395
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1396
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1397
|
+
filters: Optional[pulumi.Input[Union['OceanFiltersArgs', 'OceanFiltersArgsDict']]] = None,
|
|
1398
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1399
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1400
|
+
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1401
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1402
|
+
logging: Optional[pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']]] = None,
|
|
1403
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1404
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1405
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1406
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1407
|
+
optimize_images: Optional[pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']]] = None,
|
|
1408
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1409
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]]] = None,
|
|
1410
|
+
security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1411
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1412
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1413
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1414
|
+
update_policy: Optional[pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']]] = None,
|
|
1415
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1416
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1417
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1418
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1419
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1167
1420
|
__props__=None):
|
|
1168
1421
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1169
1422
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1184,6 +1437,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1184
1437
|
__props__.__dict__["desired_capacity"] = desired_capacity
|
|
1185
1438
|
__props__.__dict__["draining_timeout"] = draining_timeout
|
|
1186
1439
|
__props__.__dict__["ebs_optimized"] = ebs_optimized
|
|
1440
|
+
__props__.__dict__["fallback_to_ondemand"] = fallback_to_ondemand
|
|
1187
1441
|
__props__.__dict__["filters"] = filters
|
|
1188
1442
|
__props__.__dict__["iam_instance_profile"] = iam_instance_profile
|
|
1189
1443
|
if image_id is None and not opts.urn:
|
|
@@ -1225,38 +1479,39 @@ class Ocean(pulumi.CustomResource):
|
|
|
1225
1479
|
def get(resource_name: str,
|
|
1226
1480
|
id: pulumi.Input[str],
|
|
1227
1481
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1228
|
-
associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
|
|
1229
|
-
autoscaler: Optional[pulumi.Input[
|
|
1230
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1231
|
-
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1232
|
-
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
1233
|
-
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1234
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1235
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1236
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
1237
|
-
|
|
1238
|
-
|
|
1239
|
-
|
|
1240
|
-
|
|
1241
|
-
|
|
1242
|
-
|
|
1243
|
-
|
|
1244
|
-
|
|
1245
|
-
|
|
1246
|
-
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
|
|
1250
|
-
|
|
1251
|
-
|
|
1252
|
-
|
|
1253
|
-
|
|
1254
|
-
|
|
1255
|
-
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
|
|
1482
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1483
|
+
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1484
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1485
|
+
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1486
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1487
|
+
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1488
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1489
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1490
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1491
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1492
|
+
filters: Optional[pulumi.Input[Union['OceanFiltersArgs', 'OceanFiltersArgsDict']]] = None,
|
|
1493
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1494
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1495
|
+
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1496
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1497
|
+
logging: Optional[pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']]] = None,
|
|
1498
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1499
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1500
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1501
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1502
|
+
optimize_images: Optional[pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']]] = None,
|
|
1503
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1504
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]]] = None,
|
|
1505
|
+
security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1506
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1507
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1508
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1509
|
+
update_policy: Optional[pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']]] = None,
|
|
1510
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1511
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1512
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1513
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1514
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'Ocean':
|
|
1260
1515
|
"""
|
|
1261
1516
|
Get an existing Ocean resource's state with the given name, id, and optional extra
|
|
1262
1517
|
properties used to qualify the lookup.
|
|
@@ -1264,34 +1519,35 @@ class Ocean(pulumi.CustomResource):
|
|
|
1264
1519
|
:param str resource_name: The unique name of the resulting resource.
|
|
1265
1520
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1266
1521
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1267
|
-
:param pulumi.Input[bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1268
|
-
:param pulumi.Input[
|
|
1269
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1270
|
-
:param pulumi.Input[str] cluster_name: The name of the ECS cluster.
|
|
1271
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1272
|
-
:param pulumi.Input[int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
1273
|
-
:param pulumi.Input[bool] ebs_optimized: Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
1274
|
-
:param pulumi.Input[
|
|
1275
|
-
:param pulumi.Input[str]
|
|
1276
|
-
:param pulumi.Input[
|
|
1277
|
-
:param pulumi.Input[
|
|
1278
|
-
:param pulumi.Input[
|
|
1279
|
-
:param pulumi.Input[
|
|
1280
|
-
:param pulumi.Input[int]
|
|
1281
|
-
:param pulumi.Input[
|
|
1282
|
-
:param pulumi.Input[
|
|
1283
|
-
:param pulumi.Input[
|
|
1284
|
-
:param pulumi.Input[
|
|
1285
|
-
:param pulumi.Input[
|
|
1286
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1287
|
-
:param pulumi.Input[
|
|
1288
|
-
:param pulumi.Input[
|
|
1289
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1290
|
-
:param pulumi.Input[pulumi.
|
|
1291
|
-
:param pulumi.Input[
|
|
1292
|
-
:param pulumi.Input[
|
|
1293
|
-
:param pulumi.Input[
|
|
1294
|
-
:param pulumi.Input[bool]
|
|
1522
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1523
|
+
:param pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']] autoscaler: Describes the Ocean ECS autoscaler.
|
|
1524
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]] block_device_mappings: Object. List of block devices that are exposed to the instance, specify either virtual devices and EBS volumes.
|
|
1525
|
+
:param pulumi.Input[_builtins.str] cluster_name: The name of the ECS cluster.
|
|
1526
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1527
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
1528
|
+
:param pulumi.Input[_builtins.bool] ebs_optimized: Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
1529
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1530
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
1531
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
1532
|
+
:param pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
1533
|
+
:param pulumi.Input[_builtins.str] key_pair: The key pair to attach the instances.
|
|
1534
|
+
:param pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']] logging: Logging configuration.
|
|
1535
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
1536
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
1537
|
+
:param pulumi.Input[_builtins.bool] monitoring: Enable detailed monitoring for cluster. Flag will enable Cloud Watch detailed monitoring (one minute increments). Note: there are additional hourly costs for this service based on the region used.
|
|
1538
|
+
:param pulumi.Input[_builtins.str] name: The Ocean cluster name.
|
|
1539
|
+
:param pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']] optimize_images: Object. Set auto image update settings.
|
|
1540
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
1541
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]] scheduled_tasks: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
1542
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_group_ids: One or more security group ids.
|
|
1543
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1544
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnet_ids: A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
1545
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
1546
|
+
:param pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']] update_policy: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
1547
|
+
:param pulumi.Input[_builtins.bool] use_as_template_only: launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
1548
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
1549
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1550
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1295
1551
|
"""
|
|
1296
1552
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1297
1553
|
|
|
@@ -1306,6 +1562,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1306
1562
|
__props__.__dict__["desired_capacity"] = desired_capacity
|
|
1307
1563
|
__props__.__dict__["draining_timeout"] = draining_timeout
|
|
1308
1564
|
__props__.__dict__["ebs_optimized"] = ebs_optimized
|
|
1565
|
+
__props__.__dict__["fallback_to_ondemand"] = fallback_to_ondemand
|
|
1309
1566
|
__props__.__dict__["filters"] = filters
|
|
1310
1567
|
__props__.__dict__["iam_instance_profile"] = iam_instance_profile
|
|
1311
1568
|
__props__.__dict__["image_id"] = image_id
|
|
@@ -1331,15 +1588,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
1331
1588
|
__props__.__dict__["whitelists"] = whitelists
|
|
1332
1589
|
return Ocean(resource_name, opts=opts, __props__=__props__)
|
|
1333
1590
|
|
|
1334
|
-
@property
|
|
1591
|
+
@_builtins.property
|
|
1335
1592
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
1336
|
-
def associate_public_ip_address(self) -> pulumi.Output[Optional[bool]]:
|
|
1593
|
+
def associate_public_ip_address(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1337
1594
|
"""
|
|
1338
1595
|
Configure public IP address allocation.
|
|
1339
1596
|
"""
|
|
1340
1597
|
return pulumi.get(self, "associate_public_ip_address")
|
|
1341
1598
|
|
|
1342
|
-
@property
|
|
1599
|
+
@_builtins.property
|
|
1343
1600
|
@pulumi.getter
|
|
1344
1601
|
def autoscaler(self) -> pulumi.Output[Optional['outputs.OceanAutoscaler']]:
|
|
1345
1602
|
"""
|
|
@@ -1347,12 +1604,12 @@ class Ocean(pulumi.CustomResource):
|
|
|
1347
1604
|
"""
|
|
1348
1605
|
return pulumi.get(self, "autoscaler")
|
|
1349
1606
|
|
|
1350
|
-
@property
|
|
1607
|
+
@_builtins.property
|
|
1351
1608
|
@pulumi.getter
|
|
1352
|
-
def blacklists(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1609
|
+
def blacklists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1353
1610
|
return pulumi.get(self, "blacklists")
|
|
1354
1611
|
|
|
1355
|
-
@property
|
|
1612
|
+
@_builtins.property
|
|
1356
1613
|
@pulumi.getter(name="blockDeviceMappings")
|
|
1357
1614
|
def block_device_mappings(self) -> pulumi.Output[Optional[Sequence['outputs.OceanBlockDeviceMapping']]]:
|
|
1358
1615
|
"""
|
|
@@ -1360,65 +1617,73 @@ class Ocean(pulumi.CustomResource):
|
|
|
1360
1617
|
"""
|
|
1361
1618
|
return pulumi.get(self, "block_device_mappings")
|
|
1362
1619
|
|
|
1363
|
-
@property
|
|
1620
|
+
@_builtins.property
|
|
1364
1621
|
@pulumi.getter(name="clusterName")
|
|
1365
|
-
def cluster_name(self) -> pulumi.Output[str]:
|
|
1622
|
+
def cluster_name(self) -> pulumi.Output[_builtins.str]:
|
|
1366
1623
|
"""
|
|
1367
1624
|
The name of the ECS cluster.
|
|
1368
1625
|
"""
|
|
1369
1626
|
return pulumi.get(self, "cluster_name")
|
|
1370
1627
|
|
|
1371
|
-
@property
|
|
1628
|
+
@_builtins.property
|
|
1372
1629
|
@pulumi.getter(name="clusterOrientations")
|
|
1373
1630
|
def cluster_orientations(self) -> pulumi.Output[Optional[Sequence['outputs.OceanClusterOrientation']]]:
|
|
1374
1631
|
return pulumi.get(self, "cluster_orientations")
|
|
1375
1632
|
|
|
1376
|
-
@property
|
|
1633
|
+
@_builtins.property
|
|
1377
1634
|
@pulumi.getter(name="desiredCapacity")
|
|
1378
|
-
def desired_capacity(self) -> pulumi.Output[int]:
|
|
1635
|
+
def desired_capacity(self) -> pulumi.Output[_builtins.int]:
|
|
1379
1636
|
"""
|
|
1380
1637
|
The number of instances to launch and maintain in the cluster.
|
|
1381
1638
|
"""
|
|
1382
1639
|
return pulumi.get(self, "desired_capacity")
|
|
1383
1640
|
|
|
1384
|
-
@property
|
|
1641
|
+
@_builtins.property
|
|
1385
1642
|
@pulumi.getter(name="drainingTimeout")
|
|
1386
|
-
def draining_timeout(self) -> pulumi.Output[Optional[int]]:
|
|
1643
|
+
def draining_timeout(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1387
1644
|
"""
|
|
1388
1645
|
The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
1389
1646
|
"""
|
|
1390
1647
|
return pulumi.get(self, "draining_timeout")
|
|
1391
1648
|
|
|
1392
|
-
@property
|
|
1649
|
+
@_builtins.property
|
|
1393
1650
|
@pulumi.getter(name="ebsOptimized")
|
|
1394
|
-
def ebs_optimized(self) -> pulumi.Output[Optional[bool]]:
|
|
1651
|
+
def ebs_optimized(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1395
1652
|
"""
|
|
1396
1653
|
Enable EBS optimized for cluster. Flag will enable optimized capacity for high bandwidth connectivity to the EB service for non EBS optimized instance types. For instances that are EBS optimized this flag will be ignored.
|
|
1397
1654
|
"""
|
|
1398
1655
|
return pulumi.get(self, "ebs_optimized")
|
|
1399
1656
|
|
|
1400
|
-
@property
|
|
1657
|
+
@_builtins.property
|
|
1658
|
+
@pulumi.getter(name="fallbackToOndemand")
|
|
1659
|
+
def fallback_to_ondemand(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1660
|
+
"""
|
|
1661
|
+
If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1662
|
+
"""
|
|
1663
|
+
return pulumi.get(self, "fallback_to_ondemand")
|
|
1664
|
+
|
|
1665
|
+
@_builtins.property
|
|
1401
1666
|
@pulumi.getter
|
|
1402
1667
|
def filters(self) -> pulumi.Output[Optional['outputs.OceanFilters']]:
|
|
1403
1668
|
return pulumi.get(self, "filters")
|
|
1404
1669
|
|
|
1405
|
-
@property
|
|
1670
|
+
@_builtins.property
|
|
1406
1671
|
@pulumi.getter(name="iamInstanceProfile")
|
|
1407
|
-
def iam_instance_profile(self) -> pulumi.Output[Optional[str]]:
|
|
1672
|
+
def iam_instance_profile(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1408
1673
|
"""
|
|
1409
1674
|
The instance profile iam role.
|
|
1410
1675
|
"""
|
|
1411
1676
|
return pulumi.get(self, "iam_instance_profile")
|
|
1412
1677
|
|
|
1413
|
-
@property
|
|
1678
|
+
@_builtins.property
|
|
1414
1679
|
@pulumi.getter(name="imageId")
|
|
1415
|
-
def image_id(self) -> pulumi.Output[str]:
|
|
1680
|
+
def image_id(self) -> pulumi.Output[_builtins.str]:
|
|
1416
1681
|
"""
|
|
1417
1682
|
ID of the image used to launch the instances.
|
|
1418
1683
|
"""
|
|
1419
1684
|
return pulumi.get(self, "image_id")
|
|
1420
1685
|
|
|
1421
|
-
@property
|
|
1686
|
+
@_builtins.property
|
|
1422
1687
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
1423
1688
|
def instance_metadata_options(self) -> pulumi.Output[Optional['outputs.OceanInstanceMetadataOptions']]:
|
|
1424
1689
|
"""
|
|
@@ -1426,15 +1691,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
1426
1691
|
"""
|
|
1427
1692
|
return pulumi.get(self, "instance_metadata_options")
|
|
1428
1693
|
|
|
1429
|
-
@property
|
|
1694
|
+
@_builtins.property
|
|
1430
1695
|
@pulumi.getter(name="keyPair")
|
|
1431
|
-
def key_pair(self) -> pulumi.Output[Optional[str]]:
|
|
1696
|
+
def key_pair(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1432
1697
|
"""
|
|
1433
1698
|
The key pair to attach the instances.
|
|
1434
1699
|
"""
|
|
1435
1700
|
return pulumi.get(self, "key_pair")
|
|
1436
1701
|
|
|
1437
|
-
@property
|
|
1702
|
+
@_builtins.property
|
|
1438
1703
|
@pulumi.getter
|
|
1439
1704
|
def logging(self) -> pulumi.Output[Optional['outputs.OceanLogging']]:
|
|
1440
1705
|
"""
|
|
@@ -1442,39 +1707,39 @@ class Ocean(pulumi.CustomResource):
|
|
|
1442
1707
|
"""
|
|
1443
1708
|
return pulumi.get(self, "logging")
|
|
1444
1709
|
|
|
1445
|
-
@property
|
|
1710
|
+
@_builtins.property
|
|
1446
1711
|
@pulumi.getter(name="maxSize")
|
|
1447
|
-
def max_size(self) -> pulumi.Output[int]:
|
|
1712
|
+
def max_size(self) -> pulumi.Output[_builtins.int]:
|
|
1448
1713
|
"""
|
|
1449
1714
|
The upper limit of instances the cluster can scale up to.
|
|
1450
1715
|
"""
|
|
1451
1716
|
return pulumi.get(self, "max_size")
|
|
1452
1717
|
|
|
1453
|
-
@property
|
|
1718
|
+
@_builtins.property
|
|
1454
1719
|
@pulumi.getter(name="minSize")
|
|
1455
|
-
def min_size(self) -> pulumi.Output[int]:
|
|
1720
|
+
def min_size(self) -> pulumi.Output[_builtins.int]:
|
|
1456
1721
|
"""
|
|
1457
1722
|
The lower limit of instances the cluster can scale down to.
|
|
1458
1723
|
"""
|
|
1459
1724
|
return pulumi.get(self, "min_size")
|
|
1460
1725
|
|
|
1461
|
-
@property
|
|
1726
|
+
@_builtins.property
|
|
1462
1727
|
@pulumi.getter
|
|
1463
|
-
def monitoring(self) -> pulumi.Output[Optional[bool]]:
|
|
1728
|
+
def monitoring(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1464
1729
|
"""
|
|
1465
1730
|
Enable detailed monitoring for cluster. Flag will enable Cloud Watch detailed monitoring (one minute increments). Note: there are additional hourly costs for this service based on the region used.
|
|
1466
1731
|
"""
|
|
1467
1732
|
return pulumi.get(self, "monitoring")
|
|
1468
1733
|
|
|
1469
|
-
@property
|
|
1734
|
+
@_builtins.property
|
|
1470
1735
|
@pulumi.getter
|
|
1471
|
-
def name(self) -> pulumi.Output[str]:
|
|
1736
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1472
1737
|
"""
|
|
1473
1738
|
The Ocean cluster name.
|
|
1474
1739
|
"""
|
|
1475
1740
|
return pulumi.get(self, "name")
|
|
1476
1741
|
|
|
1477
|
-
@property
|
|
1742
|
+
@_builtins.property
|
|
1478
1743
|
@pulumi.getter(name="optimizeImages")
|
|
1479
1744
|
def optimize_images(self) -> pulumi.Output[Optional['outputs.OceanOptimizeImages']]:
|
|
1480
1745
|
"""
|
|
@@ -1482,15 +1747,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
1482
1747
|
"""
|
|
1483
1748
|
return pulumi.get(self, "optimize_images")
|
|
1484
1749
|
|
|
1485
|
-
@property
|
|
1750
|
+
@_builtins.property
|
|
1486
1751
|
@pulumi.getter
|
|
1487
|
-
def region(self) -> pulumi.Output[str]:
|
|
1752
|
+
def region(self) -> pulumi.Output[_builtins.str]:
|
|
1488
1753
|
"""
|
|
1489
1754
|
The region the cluster will run in.
|
|
1490
1755
|
"""
|
|
1491
1756
|
return pulumi.get(self, "region")
|
|
1492
1757
|
|
|
1493
|
-
@property
|
|
1758
|
+
@_builtins.property
|
|
1494
1759
|
@pulumi.getter(name="scheduledTasks")
|
|
1495
1760
|
def scheduled_tasks(self) -> pulumi.Output[Optional[Sequence['outputs.OceanScheduledTask']]]:
|
|
1496
1761
|
"""
|
|
@@ -1498,31 +1763,31 @@ class Ocean(pulumi.CustomResource):
|
|
|
1498
1763
|
"""
|
|
1499
1764
|
return pulumi.get(self, "scheduled_tasks")
|
|
1500
1765
|
|
|
1501
|
-
@property
|
|
1766
|
+
@_builtins.property
|
|
1502
1767
|
@pulumi.getter(name="securityGroupIds")
|
|
1503
|
-
def security_group_ids(self) -> pulumi.Output[Sequence[str]]:
|
|
1768
|
+
def security_group_ids(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1504
1769
|
"""
|
|
1505
1770
|
One or more security group ids.
|
|
1506
1771
|
"""
|
|
1507
1772
|
return pulumi.get(self, "security_group_ids")
|
|
1508
1773
|
|
|
1509
|
-
@property
|
|
1774
|
+
@_builtins.property
|
|
1510
1775
|
@pulumi.getter(name="spotPercentage")
|
|
1511
|
-
def spot_percentage(self) -> pulumi.Output[Optional[int]]:
|
|
1776
|
+
def spot_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1512
1777
|
"""
|
|
1513
1778
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1514
1779
|
"""
|
|
1515
1780
|
return pulumi.get(self, "spot_percentage")
|
|
1516
1781
|
|
|
1517
|
-
@property
|
|
1782
|
+
@_builtins.property
|
|
1518
1783
|
@pulumi.getter(name="subnetIds")
|
|
1519
|
-
def subnet_ids(self) -> pulumi.Output[Sequence[str]]:
|
|
1784
|
+
def subnet_ids(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1520
1785
|
"""
|
|
1521
1786
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
1522
1787
|
"""
|
|
1523
1788
|
return pulumi.get(self, "subnet_ids")
|
|
1524
1789
|
|
|
1525
|
-
@property
|
|
1790
|
+
@_builtins.property
|
|
1526
1791
|
@pulumi.getter
|
|
1527
1792
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.OceanTag']]]:
|
|
1528
1793
|
"""
|
|
@@ -1530,7 +1795,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1530
1795
|
"""
|
|
1531
1796
|
return pulumi.get(self, "tags")
|
|
1532
1797
|
|
|
1533
|
-
@property
|
|
1798
|
+
@_builtins.property
|
|
1534
1799
|
@pulumi.getter(name="updatePolicy")
|
|
1535
1800
|
def update_policy(self) -> pulumi.Output[Optional['outputs.OceanUpdatePolicy']]:
|
|
1536
1801
|
"""
|
|
@@ -1538,40 +1803,40 @@ class Ocean(pulumi.CustomResource):
|
|
|
1538
1803
|
"""
|
|
1539
1804
|
return pulumi.get(self, "update_policy")
|
|
1540
1805
|
|
|
1541
|
-
@property
|
|
1806
|
+
@_builtins.property
|
|
1542
1807
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
1543
|
-
def use_as_template_only(self) -> pulumi.Output[Optional[bool]]:
|
|
1808
|
+
def use_as_template_only(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1544
1809
|
"""
|
|
1545
1810
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
1546
1811
|
"""
|
|
1547
1812
|
return pulumi.get(self, "use_as_template_only")
|
|
1548
1813
|
|
|
1549
|
-
@property
|
|
1814
|
+
@_builtins.property
|
|
1550
1815
|
@pulumi.getter(name="userData")
|
|
1551
|
-
def user_data(self) -> pulumi.Output[Optional[str]]:
|
|
1816
|
+
def user_data(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1552
1817
|
"""
|
|
1553
1818
|
Base64-encoded MIME user data to make available to the instances.
|
|
1554
1819
|
"""
|
|
1555
1820
|
return pulumi.get(self, "user_data")
|
|
1556
1821
|
|
|
1557
|
-
@property
|
|
1822
|
+
@_builtins.property
|
|
1558
1823
|
@pulumi.getter(name="utilizeCommitments")
|
|
1559
|
-
def utilize_commitments(self) -> pulumi.Output[Optional[bool]]:
|
|
1824
|
+
def utilize_commitments(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1560
1825
|
"""
|
|
1561
1826
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1562
1827
|
"""
|
|
1563
1828
|
return pulumi.get(self, "utilize_commitments")
|
|
1564
1829
|
|
|
1565
|
-
@property
|
|
1830
|
+
@_builtins.property
|
|
1566
1831
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
1567
|
-
def utilize_reserved_instances(self) -> pulumi.Output[Optional[bool]]:
|
|
1832
|
+
def utilize_reserved_instances(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1568
1833
|
"""
|
|
1569
1834
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1570
1835
|
"""
|
|
1571
1836
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
1572
1837
|
|
|
1573
|
-
@property
|
|
1838
|
+
@_builtins.property
|
|
1574
1839
|
@pulumi.getter
|
|
1575
|
-
def whitelists(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1840
|
+
def whitelists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1576
1841
|
return pulumi.get(self, "whitelists")
|
|
1577
1842
|
|