pulumi-spotinst 3.115.0a1742873189__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 +11 -1
- pulumi_spotinst/_inputs.py +2206 -1519
- pulumi_spotinst/_utilities.py +1 -1
- pulumi_spotinst/account.py +20 -19
- pulumi_spotinst/aws/__init__.py +2 -1
- pulumi_spotinst/aws/_inputs.py +3991 -3619
- pulumi_spotinst/aws/account.py +20 -19
- pulumi_spotinst/aws/beanstalk.py +254 -177
- pulumi_spotinst/aws/credentials.py +37 -36
- pulumi_spotinst/aws/elastigroup.py +938 -950
- pulumi_spotinst/aws/managed_instance.py +507 -506
- pulumi_spotinst/aws/mr_scalar.py +658 -653
- pulumi_spotinst/aws/ocean.py +624 -529
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +37 -36
- pulumi_spotinst/aws/ocean_launch_spec.py +395 -300
- pulumi_spotinst/aws/outputs.py +2631 -2371
- pulumi_spotinst/aws/suspension.py +23 -22
- pulumi_spotinst/azure/__init__.py +2 -1
- pulumi_spotinst/azure/_inputs.py +607 -607
- pulumi_spotinst/azure/ocean_np.py +387 -386
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +323 -322
- pulumi_spotinst/azure/outputs.py +411 -411
- pulumi_spotinst/config/__init__.py +2 -1
- pulumi_spotinst/config/__init__.pyi +2 -2
- pulumi_spotinst/config/vars.py +6 -6
- pulumi_spotinst/credentials_azure.py +139 -89
- pulumi_spotinst/credentials_gcp.py +190 -189
- pulumi_spotinst/data_integration.py +40 -39
- pulumi_spotinst/ecs/__init__.py +2 -1
- pulumi_spotinst/ecs/_inputs.py +584 -584
- pulumi_spotinst/ecs/ocean.py +628 -415
- pulumi_spotinst/ecs/ocean_launch_spec.py +197 -196
- pulumi_spotinst/ecs/outputs.py +394 -394
- pulumi_spotinst/elastigroup_azure_v3.py +326 -325
- pulumi_spotinst/gcp/__init__.py +2 -1
- pulumi_spotinst/gcp/_inputs.py +573 -499
- pulumi_spotinst/gcp/elastigroup.py +491 -482
- pulumi_spotinst/gcp/outputs.py +395 -330
- pulumi_spotinst/gke/__init__.py +2 -1
- pulumi_spotinst/gke/_inputs.py +1120 -895
- pulumi_spotinst/gke/elastigroup.py +341 -340
- pulumi_spotinst/gke/ocean_import.py +204 -203
- pulumi_spotinst/gke/ocean_launch_spec.py +285 -213
- pulumi_spotinst/gke/ocean_launch_spec_import.py +37 -36
- pulumi_spotinst/gke/outputs.py +769 -583
- pulumi_spotinst/health_check.py +106 -65
- pulumi_spotinst/notification_center.py +344 -0
- pulumi_spotinst/ocean_right_sizing_rule.py +424 -77
- pulumi_spotinst/oceancd/__init__.py +2 -1
- pulumi_spotinst/oceancd/_inputs.py +764 -764
- pulumi_spotinst/oceancd/outputs.py +526 -526
- pulumi_spotinst/oceancd/rollout_spec.py +35 -34
- pulumi_spotinst/oceancd/strategy.py +22 -21
- pulumi_spotinst/oceancd/verification_provider.py +52 -51
- pulumi_spotinst/oceancd/verification_template.py +26 -25
- pulumi_spotinst/organization/__init__.py +2 -1
- pulumi_spotinst/organization/_inputs.py +68 -68
- pulumi_spotinst/organization/outputs.py +46 -46
- pulumi_spotinst/organization/policy.py +40 -39
- pulumi_spotinst/organization/programmatic_user.py +60 -59
- pulumi_spotinst/organization/user.py +108 -107
- pulumi_spotinst/organization/user_group.py +57 -56
- pulumi_spotinst/outputs.py +1472 -932
- pulumi_spotinst/provider.py +61 -40
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +2 -1
- pulumi_spotinst/spark/_inputs.py +104 -104
- pulumi_spotinst/spark/ocean.py +38 -37
- pulumi_spotinst/spark/ocean_virtual_node_group.py +29 -28
- pulumi_spotinst/spark/outputs.py +72 -72
- pulumi_spotinst/stateful_node_azure.py +318 -343
- pulumi_spotinst/subscription.py +88 -87
- {pulumi_spotinst-3.115.0a1742873189.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/METADATA +3 -3
- pulumi_spotinst-3.128.0a1767140134.dist-info/RECORD +77 -0
- {pulumi_spotinst-3.115.0a1742873189.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/WHEEL +1 -1
- pulumi_spotinst-3.115.0a1742873189.dist-info/RECORD +0 -76
- {pulumi_spotinst-3.115.0a1742873189.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/top_level.txt +0 -0
pulumi_spotinst/ecs/ocean.py
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
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
7
|
import sys
|
|
8
8
|
import pulumi
|
|
@@ -21,70 +21,70 @@ __all__ = ['OceanArgs', 'Ocean']
|
|
|
21
21
|
@pulumi.input_type
|
|
22
22
|
class OceanArgs:
|
|
23
23
|
def __init__(__self__, *,
|
|
24
|
-
cluster_name: pulumi.Input[str],
|
|
25
|
-
image_id: pulumi.Input[str],
|
|
26
|
-
region: pulumi.Input[str],
|
|
27
|
-
security_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
28
|
-
subnet_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
29
|
-
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,
|
|
30
30
|
autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
|
|
31
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
31
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
32
32
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
|
|
33
33
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
|
|
34
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
35
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
36
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
37
|
-
fallback_to_ondemand: 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,
|
|
38
38
|
filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
|
|
39
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
39
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
40
|
instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
|
|
41
|
-
key_pair: Optional[pulumi.Input[str]] = None,
|
|
41
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
42
42
|
logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
|
|
43
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
44
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
45
|
-
monitoring: Optional[pulumi.Input[bool]] = None,
|
|
46
|
-
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,
|
|
47
47
|
optimize_images: Optional[pulumi.Input['OceanOptimizeImagesArgs']] = None,
|
|
48
48
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
|
|
49
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
49
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
50
50
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
|
|
51
51
|
update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
|
|
52
|
-
use_as_template_only: Optional[pulumi.Input[bool]] = None,
|
|
53
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
54
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
55
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
56
|
-
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):
|
|
57
57
|
"""
|
|
58
58
|
The set of arguments for constructing a Ocean resource.
|
|
59
|
-
:param pulumi.Input[str] cluster_name: The name of the ECS cluster.
|
|
60
|
-
:param pulumi.Input[str] image_id: ID of the image used to launch the instances.
|
|
61
|
-
:param pulumi.Input[str] region: The region the cluster will run in.
|
|
62
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: One or more security group ids.
|
|
63
|
-
: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.
|
|
64
|
-
: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.
|
|
65
65
|
:param pulumi.Input['OceanAutoscalerArgs'] autoscaler: Describes the Ocean ECS autoscaler.
|
|
66
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.
|
|
67
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
68
|
-
: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.
|
|
69
|
-
: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.
|
|
70
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
71
|
-
:param pulumi.Input[str] iam_instance_profile: The instance profile iam role.
|
|
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.
|
|
72
72
|
:param pulumi.Input['OceanInstanceMetadataOptionsArgs'] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
73
|
-
: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.
|
|
74
74
|
:param pulumi.Input['OceanLoggingArgs'] logging: Logging configuration.
|
|
75
|
-
:param pulumi.Input[int] max_size: The upper limit of instances the cluster can scale up to.
|
|
76
|
-
:param pulumi.Input[int] min_size: The lower limit of instances the cluster can scale down to.
|
|
77
|
-
: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.
|
|
78
|
-
: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.
|
|
79
79
|
:param pulumi.Input['OceanOptimizeImagesArgs'] optimize_images: Object. Set auto image update settings.
|
|
80
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.
|
|
81
|
-
: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.
|
|
82
82
|
:param pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
83
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.
|
|
84
|
-
: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.
|
|
85
|
-
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
86
|
-
:param pulumi.Input[bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
87
|
-
: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.
|
|
88
88
|
"""
|
|
89
89
|
pulumi.set(__self__, "cluster_name", cluster_name)
|
|
90
90
|
pulumi.set(__self__, "image_id", image_id)
|
|
@@ -148,79 +148,79 @@ class OceanArgs:
|
|
|
148
148
|
if whitelists is not None:
|
|
149
149
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
150
150
|
|
|
151
|
-
@property
|
|
151
|
+
@_builtins.property
|
|
152
152
|
@pulumi.getter(name="clusterName")
|
|
153
|
-
def cluster_name(self) -> pulumi.Input[str]:
|
|
153
|
+
def cluster_name(self) -> pulumi.Input[_builtins.str]:
|
|
154
154
|
"""
|
|
155
155
|
The name of the ECS cluster.
|
|
156
156
|
"""
|
|
157
157
|
return pulumi.get(self, "cluster_name")
|
|
158
158
|
|
|
159
159
|
@cluster_name.setter
|
|
160
|
-
def cluster_name(self, value: pulumi.Input[str]):
|
|
160
|
+
def cluster_name(self, value: pulumi.Input[_builtins.str]):
|
|
161
161
|
pulumi.set(self, "cluster_name", value)
|
|
162
162
|
|
|
163
|
-
@property
|
|
163
|
+
@_builtins.property
|
|
164
164
|
@pulumi.getter(name="imageId")
|
|
165
|
-
def image_id(self) -> pulumi.Input[str]:
|
|
165
|
+
def image_id(self) -> pulumi.Input[_builtins.str]:
|
|
166
166
|
"""
|
|
167
167
|
ID of the image used to launch the instances.
|
|
168
168
|
"""
|
|
169
169
|
return pulumi.get(self, "image_id")
|
|
170
170
|
|
|
171
171
|
@image_id.setter
|
|
172
|
-
def image_id(self, value: pulumi.Input[str]):
|
|
172
|
+
def image_id(self, value: pulumi.Input[_builtins.str]):
|
|
173
173
|
pulumi.set(self, "image_id", value)
|
|
174
174
|
|
|
175
|
-
@property
|
|
175
|
+
@_builtins.property
|
|
176
176
|
@pulumi.getter
|
|
177
|
-
def region(self) -> pulumi.Input[str]:
|
|
177
|
+
def region(self) -> pulumi.Input[_builtins.str]:
|
|
178
178
|
"""
|
|
179
179
|
The region the cluster will run in.
|
|
180
180
|
"""
|
|
181
181
|
return pulumi.get(self, "region")
|
|
182
182
|
|
|
183
183
|
@region.setter
|
|
184
|
-
def region(self, value: pulumi.Input[str]):
|
|
184
|
+
def region(self, value: pulumi.Input[_builtins.str]):
|
|
185
185
|
pulumi.set(self, "region", value)
|
|
186
186
|
|
|
187
|
-
@property
|
|
187
|
+
@_builtins.property
|
|
188
188
|
@pulumi.getter(name="securityGroupIds")
|
|
189
|
-
def security_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
189
|
+
def security_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
190
190
|
"""
|
|
191
191
|
One or more security group ids.
|
|
192
192
|
"""
|
|
193
193
|
return pulumi.get(self, "security_group_ids")
|
|
194
194
|
|
|
195
195
|
@security_group_ids.setter
|
|
196
|
-
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]]]):
|
|
197
197
|
pulumi.set(self, "security_group_ids", value)
|
|
198
198
|
|
|
199
|
-
@property
|
|
199
|
+
@_builtins.property
|
|
200
200
|
@pulumi.getter(name="subnetIds")
|
|
201
|
-
def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
201
|
+
def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
202
202
|
"""
|
|
203
203
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
204
204
|
"""
|
|
205
205
|
return pulumi.get(self, "subnet_ids")
|
|
206
206
|
|
|
207
207
|
@subnet_ids.setter
|
|
208
|
-
def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
208
|
+
def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
209
209
|
pulumi.set(self, "subnet_ids", value)
|
|
210
210
|
|
|
211
|
-
@property
|
|
211
|
+
@_builtins.property
|
|
212
212
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
213
|
-
def associate_public_ip_address(self) -> Optional[pulumi.Input[bool]]:
|
|
213
|
+
def associate_public_ip_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
214
214
|
"""
|
|
215
215
|
Configure public IP address allocation.
|
|
216
216
|
"""
|
|
217
217
|
return pulumi.get(self, "associate_public_ip_address")
|
|
218
218
|
|
|
219
219
|
@associate_public_ip_address.setter
|
|
220
|
-
def associate_public_ip_address(self, value: Optional[pulumi.Input[bool]]):
|
|
220
|
+
def associate_public_ip_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
221
221
|
pulumi.set(self, "associate_public_ip_address", value)
|
|
222
222
|
|
|
223
|
-
@property
|
|
223
|
+
@_builtins.property
|
|
224
224
|
@pulumi.getter
|
|
225
225
|
def autoscaler(self) -> Optional[pulumi.Input['OceanAutoscalerArgs']]:
|
|
226
226
|
"""
|
|
@@ -232,16 +232,16 @@ class OceanArgs:
|
|
|
232
232
|
def autoscaler(self, value: Optional[pulumi.Input['OceanAutoscalerArgs']]):
|
|
233
233
|
pulumi.set(self, "autoscaler", value)
|
|
234
234
|
|
|
235
|
-
@property
|
|
235
|
+
@_builtins.property
|
|
236
236
|
@pulumi.getter
|
|
237
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
237
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
238
238
|
return pulumi.get(self, "blacklists")
|
|
239
239
|
|
|
240
240
|
@blacklists.setter
|
|
241
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
241
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
242
242
|
pulumi.set(self, "blacklists", value)
|
|
243
243
|
|
|
244
|
-
@property
|
|
244
|
+
@_builtins.property
|
|
245
245
|
@pulumi.getter(name="blockDeviceMappings")
|
|
246
246
|
def block_device_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]:
|
|
247
247
|
"""
|
|
@@ -253,7 +253,7 @@ class OceanArgs:
|
|
|
253
253
|
def block_device_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]):
|
|
254
254
|
pulumi.set(self, "block_device_mappings", value)
|
|
255
255
|
|
|
256
|
-
@property
|
|
256
|
+
@_builtins.property
|
|
257
257
|
@pulumi.getter(name="clusterOrientations")
|
|
258
258
|
def cluster_orientations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]:
|
|
259
259
|
return pulumi.get(self, "cluster_orientations")
|
|
@@ -262,55 +262,55 @@ class OceanArgs:
|
|
|
262
262
|
def cluster_orientations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]):
|
|
263
263
|
pulumi.set(self, "cluster_orientations", value)
|
|
264
264
|
|
|
265
|
-
@property
|
|
265
|
+
@_builtins.property
|
|
266
266
|
@pulumi.getter(name="desiredCapacity")
|
|
267
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
267
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
268
268
|
"""
|
|
269
269
|
The number of instances to launch and maintain in the cluster.
|
|
270
270
|
"""
|
|
271
271
|
return pulumi.get(self, "desired_capacity")
|
|
272
272
|
|
|
273
273
|
@desired_capacity.setter
|
|
274
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
274
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
275
275
|
pulumi.set(self, "desired_capacity", value)
|
|
276
276
|
|
|
277
|
-
@property
|
|
277
|
+
@_builtins.property
|
|
278
278
|
@pulumi.getter(name="drainingTimeout")
|
|
279
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
279
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
280
280
|
"""
|
|
281
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.
|
|
282
282
|
"""
|
|
283
283
|
return pulumi.get(self, "draining_timeout")
|
|
284
284
|
|
|
285
285
|
@draining_timeout.setter
|
|
286
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
286
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
287
287
|
pulumi.set(self, "draining_timeout", value)
|
|
288
288
|
|
|
289
|
-
@property
|
|
289
|
+
@_builtins.property
|
|
290
290
|
@pulumi.getter(name="ebsOptimized")
|
|
291
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[bool]]:
|
|
291
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
292
292
|
"""
|
|
293
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.
|
|
294
294
|
"""
|
|
295
295
|
return pulumi.get(self, "ebs_optimized")
|
|
296
296
|
|
|
297
297
|
@ebs_optimized.setter
|
|
298
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[bool]]):
|
|
298
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
299
299
|
pulumi.set(self, "ebs_optimized", value)
|
|
300
300
|
|
|
301
|
-
@property
|
|
301
|
+
@_builtins.property
|
|
302
302
|
@pulumi.getter(name="fallbackToOndemand")
|
|
303
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
303
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
304
304
|
"""
|
|
305
305
|
If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
306
306
|
"""
|
|
307
307
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
308
308
|
|
|
309
309
|
@fallback_to_ondemand.setter
|
|
310
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
310
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
311
311
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
312
312
|
|
|
313
|
-
@property
|
|
313
|
+
@_builtins.property
|
|
314
314
|
@pulumi.getter
|
|
315
315
|
def filters(self) -> Optional[pulumi.Input['OceanFiltersArgs']]:
|
|
316
316
|
return pulumi.get(self, "filters")
|
|
@@ -319,19 +319,19 @@ class OceanArgs:
|
|
|
319
319
|
def filters(self, value: Optional[pulumi.Input['OceanFiltersArgs']]):
|
|
320
320
|
pulumi.set(self, "filters", value)
|
|
321
321
|
|
|
322
|
-
@property
|
|
322
|
+
@_builtins.property
|
|
323
323
|
@pulumi.getter(name="iamInstanceProfile")
|
|
324
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
|
|
324
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
325
325
|
"""
|
|
326
326
|
The instance profile iam role.
|
|
327
327
|
"""
|
|
328
328
|
return pulumi.get(self, "iam_instance_profile")
|
|
329
329
|
|
|
330
330
|
@iam_instance_profile.setter
|
|
331
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[str]]):
|
|
331
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
332
332
|
pulumi.set(self, "iam_instance_profile", value)
|
|
333
333
|
|
|
334
|
-
@property
|
|
334
|
+
@_builtins.property
|
|
335
335
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
336
336
|
def instance_metadata_options(self) -> Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]:
|
|
337
337
|
"""
|
|
@@ -343,19 +343,19 @@ class OceanArgs:
|
|
|
343
343
|
def instance_metadata_options(self, value: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]):
|
|
344
344
|
pulumi.set(self, "instance_metadata_options", value)
|
|
345
345
|
|
|
346
|
-
@property
|
|
346
|
+
@_builtins.property
|
|
347
347
|
@pulumi.getter(name="keyPair")
|
|
348
|
-
def key_pair(self) -> Optional[pulumi.Input[str]]:
|
|
348
|
+
def key_pair(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
349
349
|
"""
|
|
350
350
|
The key pair to attach the instances.
|
|
351
351
|
"""
|
|
352
352
|
return pulumi.get(self, "key_pair")
|
|
353
353
|
|
|
354
354
|
@key_pair.setter
|
|
355
|
-
def key_pair(self, value: Optional[pulumi.Input[str]]):
|
|
355
|
+
def key_pair(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
356
356
|
pulumi.set(self, "key_pair", value)
|
|
357
357
|
|
|
358
|
-
@property
|
|
358
|
+
@_builtins.property
|
|
359
359
|
@pulumi.getter
|
|
360
360
|
def logging(self) -> Optional[pulumi.Input['OceanLoggingArgs']]:
|
|
361
361
|
"""
|
|
@@ -367,55 +367,55 @@ class OceanArgs:
|
|
|
367
367
|
def logging(self, value: Optional[pulumi.Input['OceanLoggingArgs']]):
|
|
368
368
|
pulumi.set(self, "logging", value)
|
|
369
369
|
|
|
370
|
-
@property
|
|
370
|
+
@_builtins.property
|
|
371
371
|
@pulumi.getter(name="maxSize")
|
|
372
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
372
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
373
373
|
"""
|
|
374
374
|
The upper limit of instances the cluster can scale up to.
|
|
375
375
|
"""
|
|
376
376
|
return pulumi.get(self, "max_size")
|
|
377
377
|
|
|
378
378
|
@max_size.setter
|
|
379
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
379
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
380
380
|
pulumi.set(self, "max_size", value)
|
|
381
381
|
|
|
382
|
-
@property
|
|
382
|
+
@_builtins.property
|
|
383
383
|
@pulumi.getter(name="minSize")
|
|
384
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
384
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
385
385
|
"""
|
|
386
386
|
The lower limit of instances the cluster can scale down to.
|
|
387
387
|
"""
|
|
388
388
|
return pulumi.get(self, "min_size")
|
|
389
389
|
|
|
390
390
|
@min_size.setter
|
|
391
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
391
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
392
392
|
pulumi.set(self, "min_size", value)
|
|
393
393
|
|
|
394
|
-
@property
|
|
394
|
+
@_builtins.property
|
|
395
395
|
@pulumi.getter
|
|
396
|
-
def monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
396
|
+
def monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
397
397
|
"""
|
|
398
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.
|
|
399
399
|
"""
|
|
400
400
|
return pulumi.get(self, "monitoring")
|
|
401
401
|
|
|
402
402
|
@monitoring.setter
|
|
403
|
-
def monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
403
|
+
def monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
404
404
|
pulumi.set(self, "monitoring", value)
|
|
405
405
|
|
|
406
|
-
@property
|
|
406
|
+
@_builtins.property
|
|
407
407
|
@pulumi.getter
|
|
408
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
408
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
409
409
|
"""
|
|
410
410
|
The Ocean cluster name.
|
|
411
411
|
"""
|
|
412
412
|
return pulumi.get(self, "name")
|
|
413
413
|
|
|
414
414
|
@name.setter
|
|
415
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
415
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
416
416
|
pulumi.set(self, "name", value)
|
|
417
417
|
|
|
418
|
-
@property
|
|
418
|
+
@_builtins.property
|
|
419
419
|
@pulumi.getter(name="optimizeImages")
|
|
420
420
|
def optimize_images(self) -> Optional[pulumi.Input['OceanOptimizeImagesArgs']]:
|
|
421
421
|
"""
|
|
@@ -427,7 +427,7 @@ class OceanArgs:
|
|
|
427
427
|
def optimize_images(self, value: Optional[pulumi.Input['OceanOptimizeImagesArgs']]):
|
|
428
428
|
pulumi.set(self, "optimize_images", value)
|
|
429
429
|
|
|
430
|
-
@property
|
|
430
|
+
@_builtins.property
|
|
431
431
|
@pulumi.getter(name="scheduledTasks")
|
|
432
432
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]:
|
|
433
433
|
"""
|
|
@@ -439,19 +439,19 @@ class OceanArgs:
|
|
|
439
439
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]):
|
|
440
440
|
pulumi.set(self, "scheduled_tasks", value)
|
|
441
441
|
|
|
442
|
-
@property
|
|
442
|
+
@_builtins.property
|
|
443
443
|
@pulumi.getter(name="spotPercentage")
|
|
444
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
444
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
445
445
|
"""
|
|
446
446
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
447
447
|
"""
|
|
448
448
|
return pulumi.get(self, "spot_percentage")
|
|
449
449
|
|
|
450
450
|
@spot_percentage.setter
|
|
451
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
451
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
452
452
|
pulumi.set(self, "spot_percentage", value)
|
|
453
453
|
|
|
454
|
-
@property
|
|
454
|
+
@_builtins.property
|
|
455
455
|
@pulumi.getter
|
|
456
456
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]:
|
|
457
457
|
"""
|
|
@@ -463,7 +463,7 @@ class OceanArgs:
|
|
|
463
463
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]):
|
|
464
464
|
pulumi.set(self, "tags", value)
|
|
465
465
|
|
|
466
|
-
@property
|
|
466
|
+
@_builtins.property
|
|
467
467
|
@pulumi.getter(name="updatePolicy")
|
|
468
468
|
def update_policy(self) -> Optional[pulumi.Input['OceanUpdatePolicyArgs']]:
|
|
469
469
|
"""
|
|
@@ -475,131 +475,131 @@ class OceanArgs:
|
|
|
475
475
|
def update_policy(self, value: Optional[pulumi.Input['OceanUpdatePolicyArgs']]):
|
|
476
476
|
pulumi.set(self, "update_policy", value)
|
|
477
477
|
|
|
478
|
-
@property
|
|
478
|
+
@_builtins.property
|
|
479
479
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
480
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[bool]]:
|
|
480
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
481
481
|
"""
|
|
482
482
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
483
483
|
"""
|
|
484
484
|
return pulumi.get(self, "use_as_template_only")
|
|
485
485
|
|
|
486
486
|
@use_as_template_only.setter
|
|
487
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[bool]]):
|
|
487
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
488
488
|
pulumi.set(self, "use_as_template_only", value)
|
|
489
489
|
|
|
490
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
491
491
|
@pulumi.getter(name="userData")
|
|
492
|
-
def user_data(self) -> Optional[pulumi.Input[str]]:
|
|
492
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
493
493
|
"""
|
|
494
494
|
Base64-encoded MIME user data to make available to the instances.
|
|
495
495
|
"""
|
|
496
496
|
return pulumi.get(self, "user_data")
|
|
497
497
|
|
|
498
498
|
@user_data.setter
|
|
499
|
-
def user_data(self, value: Optional[pulumi.Input[str]]):
|
|
499
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
500
500
|
pulumi.set(self, "user_data", value)
|
|
501
501
|
|
|
502
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
503
503
|
@pulumi.getter(name="utilizeCommitments")
|
|
504
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[bool]]:
|
|
504
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
505
505
|
"""
|
|
506
506
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
507
507
|
"""
|
|
508
508
|
return pulumi.get(self, "utilize_commitments")
|
|
509
509
|
|
|
510
510
|
@utilize_commitments.setter
|
|
511
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[bool]]):
|
|
511
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
512
512
|
pulumi.set(self, "utilize_commitments", value)
|
|
513
513
|
|
|
514
|
-
@property
|
|
514
|
+
@_builtins.property
|
|
515
515
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
516
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[bool]]:
|
|
516
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
517
517
|
"""
|
|
518
518
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
519
519
|
"""
|
|
520
520
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
521
521
|
|
|
522
522
|
@utilize_reserved_instances.setter
|
|
523
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[bool]]):
|
|
523
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
524
524
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
525
525
|
|
|
526
|
-
@property
|
|
526
|
+
@_builtins.property
|
|
527
527
|
@pulumi.getter
|
|
528
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
528
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
529
529
|
return pulumi.get(self, "whitelists")
|
|
530
530
|
|
|
531
531
|
@whitelists.setter
|
|
532
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
532
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
533
533
|
pulumi.set(self, "whitelists", value)
|
|
534
534
|
|
|
535
535
|
|
|
536
536
|
@pulumi.input_type
|
|
537
537
|
class _OceanState:
|
|
538
538
|
def __init__(__self__, *,
|
|
539
|
-
associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
|
|
539
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
540
540
|
autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
|
|
541
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
541
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
542
542
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
|
|
543
|
-
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
543
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
544
544
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
|
|
545
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
546
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
547
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
548
|
-
fallback_to_ondemand: 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,
|
|
549
549
|
filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
|
|
550
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
551
|
-
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,
|
|
552
552
|
instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
|
|
553
|
-
key_pair: Optional[pulumi.Input[str]] = None,
|
|
553
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
554
554
|
logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
|
|
555
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
556
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
557
|
-
monitoring: Optional[pulumi.Input[bool]] = None,
|
|
558
|
-
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,
|
|
559
559
|
optimize_images: Optional[pulumi.Input['OceanOptimizeImagesArgs']] = None,
|
|
560
|
-
region: Optional[pulumi.Input[str]] = None,
|
|
560
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
561
561
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
|
|
562
|
-
security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
563
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
564
|
-
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,
|
|
565
565
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
|
|
566
566
|
update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
|
|
567
|
-
use_as_template_only: Optional[pulumi.Input[bool]] = None,
|
|
568
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
569
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
570
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
571
|
-
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):
|
|
572
572
|
"""
|
|
573
573
|
Input properties used for looking up and filtering Ocean resources.
|
|
574
|
-
: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.
|
|
575
575
|
:param pulumi.Input['OceanAutoscalerArgs'] autoscaler: Describes the Ocean ECS autoscaler.
|
|
576
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.
|
|
577
|
-
:param pulumi.Input[str] cluster_name: The name of the ECS cluster.
|
|
578
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
579
|
-
: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.
|
|
580
|
-
: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.
|
|
581
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
582
|
-
:param pulumi.Input[str] iam_instance_profile: The instance profile iam role.
|
|
583
|
-
:param pulumi.Input[str] image_id: ID of the image used to launch the instances.
|
|
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.
|
|
584
584
|
:param pulumi.Input['OceanInstanceMetadataOptionsArgs'] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
585
|
-
: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.
|
|
586
586
|
:param pulumi.Input['OceanLoggingArgs'] logging: Logging configuration.
|
|
587
|
-
:param pulumi.Input[int] max_size: The upper limit of instances the cluster can scale up to.
|
|
588
|
-
:param pulumi.Input[int] min_size: The lower limit of instances the cluster can scale down to.
|
|
589
|
-
: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.
|
|
590
|
-
: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.
|
|
591
591
|
:param pulumi.Input['OceanOptimizeImagesArgs'] optimize_images: Object. Set auto image update settings.
|
|
592
|
-
: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.
|
|
593
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.
|
|
594
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: One or more security group ids.
|
|
595
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
596
|
-
: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.
|
|
597
597
|
:param pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
598
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.
|
|
599
|
-
: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.
|
|
600
|
-
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
601
|
-
:param pulumi.Input[bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
602
|
-
: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.
|
|
603
603
|
"""
|
|
604
604
|
if associate_public_ip_address is not None:
|
|
605
605
|
pulumi.set(__self__, "associate_public_ip_address", associate_public_ip_address)
|
|
@@ -668,19 +668,19 @@ class _OceanState:
|
|
|
668
668
|
if whitelists is not None:
|
|
669
669
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
670
670
|
|
|
671
|
-
@property
|
|
671
|
+
@_builtins.property
|
|
672
672
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
673
|
-
def associate_public_ip_address(self) -> Optional[pulumi.Input[bool]]:
|
|
673
|
+
def associate_public_ip_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
674
674
|
"""
|
|
675
675
|
Configure public IP address allocation.
|
|
676
676
|
"""
|
|
677
677
|
return pulumi.get(self, "associate_public_ip_address")
|
|
678
678
|
|
|
679
679
|
@associate_public_ip_address.setter
|
|
680
|
-
def associate_public_ip_address(self, value: Optional[pulumi.Input[bool]]):
|
|
680
|
+
def associate_public_ip_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
681
681
|
pulumi.set(self, "associate_public_ip_address", value)
|
|
682
682
|
|
|
683
|
-
@property
|
|
683
|
+
@_builtins.property
|
|
684
684
|
@pulumi.getter
|
|
685
685
|
def autoscaler(self) -> Optional[pulumi.Input['OceanAutoscalerArgs']]:
|
|
686
686
|
"""
|
|
@@ -692,16 +692,16 @@ class _OceanState:
|
|
|
692
692
|
def autoscaler(self, value: Optional[pulumi.Input['OceanAutoscalerArgs']]):
|
|
693
693
|
pulumi.set(self, "autoscaler", value)
|
|
694
694
|
|
|
695
|
-
@property
|
|
695
|
+
@_builtins.property
|
|
696
696
|
@pulumi.getter
|
|
697
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
697
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
698
698
|
return pulumi.get(self, "blacklists")
|
|
699
699
|
|
|
700
700
|
@blacklists.setter
|
|
701
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
701
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
702
702
|
pulumi.set(self, "blacklists", value)
|
|
703
703
|
|
|
704
|
-
@property
|
|
704
|
+
@_builtins.property
|
|
705
705
|
@pulumi.getter(name="blockDeviceMappings")
|
|
706
706
|
def block_device_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]:
|
|
707
707
|
"""
|
|
@@ -713,19 +713,19 @@ class _OceanState:
|
|
|
713
713
|
def block_device_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]):
|
|
714
714
|
pulumi.set(self, "block_device_mappings", value)
|
|
715
715
|
|
|
716
|
-
@property
|
|
716
|
+
@_builtins.property
|
|
717
717
|
@pulumi.getter(name="clusterName")
|
|
718
|
-
def cluster_name(self) -> Optional[pulumi.Input[str]]:
|
|
718
|
+
def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
719
719
|
"""
|
|
720
720
|
The name of the ECS cluster.
|
|
721
721
|
"""
|
|
722
722
|
return pulumi.get(self, "cluster_name")
|
|
723
723
|
|
|
724
724
|
@cluster_name.setter
|
|
725
|
-
def cluster_name(self, value: Optional[pulumi.Input[str]]):
|
|
725
|
+
def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
726
726
|
pulumi.set(self, "cluster_name", value)
|
|
727
727
|
|
|
728
|
-
@property
|
|
728
|
+
@_builtins.property
|
|
729
729
|
@pulumi.getter(name="clusterOrientations")
|
|
730
730
|
def cluster_orientations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]:
|
|
731
731
|
return pulumi.get(self, "cluster_orientations")
|
|
@@ -734,55 +734,55 @@ class _OceanState:
|
|
|
734
734
|
def cluster_orientations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]):
|
|
735
735
|
pulumi.set(self, "cluster_orientations", value)
|
|
736
736
|
|
|
737
|
-
@property
|
|
737
|
+
@_builtins.property
|
|
738
738
|
@pulumi.getter(name="desiredCapacity")
|
|
739
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
739
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
740
740
|
"""
|
|
741
741
|
The number of instances to launch and maintain in the cluster.
|
|
742
742
|
"""
|
|
743
743
|
return pulumi.get(self, "desired_capacity")
|
|
744
744
|
|
|
745
745
|
@desired_capacity.setter
|
|
746
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
746
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
747
747
|
pulumi.set(self, "desired_capacity", value)
|
|
748
748
|
|
|
749
|
-
@property
|
|
749
|
+
@_builtins.property
|
|
750
750
|
@pulumi.getter(name="drainingTimeout")
|
|
751
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
751
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
752
752
|
"""
|
|
753
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.
|
|
754
754
|
"""
|
|
755
755
|
return pulumi.get(self, "draining_timeout")
|
|
756
756
|
|
|
757
757
|
@draining_timeout.setter
|
|
758
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
758
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
759
759
|
pulumi.set(self, "draining_timeout", value)
|
|
760
760
|
|
|
761
|
-
@property
|
|
761
|
+
@_builtins.property
|
|
762
762
|
@pulumi.getter(name="ebsOptimized")
|
|
763
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[bool]]:
|
|
763
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
764
764
|
"""
|
|
765
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.
|
|
766
766
|
"""
|
|
767
767
|
return pulumi.get(self, "ebs_optimized")
|
|
768
768
|
|
|
769
769
|
@ebs_optimized.setter
|
|
770
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[bool]]):
|
|
770
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
771
771
|
pulumi.set(self, "ebs_optimized", value)
|
|
772
772
|
|
|
773
|
-
@property
|
|
773
|
+
@_builtins.property
|
|
774
774
|
@pulumi.getter(name="fallbackToOndemand")
|
|
775
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
775
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
776
776
|
"""
|
|
777
777
|
If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
778
778
|
"""
|
|
779
779
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
780
780
|
|
|
781
781
|
@fallback_to_ondemand.setter
|
|
782
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
782
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
783
783
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
784
784
|
|
|
785
|
-
@property
|
|
785
|
+
@_builtins.property
|
|
786
786
|
@pulumi.getter
|
|
787
787
|
def filters(self) -> Optional[pulumi.Input['OceanFiltersArgs']]:
|
|
788
788
|
return pulumi.get(self, "filters")
|
|
@@ -791,31 +791,31 @@ class _OceanState:
|
|
|
791
791
|
def filters(self, value: Optional[pulumi.Input['OceanFiltersArgs']]):
|
|
792
792
|
pulumi.set(self, "filters", value)
|
|
793
793
|
|
|
794
|
-
@property
|
|
794
|
+
@_builtins.property
|
|
795
795
|
@pulumi.getter(name="iamInstanceProfile")
|
|
796
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
|
|
796
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
797
797
|
"""
|
|
798
798
|
The instance profile iam role.
|
|
799
799
|
"""
|
|
800
800
|
return pulumi.get(self, "iam_instance_profile")
|
|
801
801
|
|
|
802
802
|
@iam_instance_profile.setter
|
|
803
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[str]]):
|
|
803
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
804
804
|
pulumi.set(self, "iam_instance_profile", value)
|
|
805
805
|
|
|
806
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
807
807
|
@pulumi.getter(name="imageId")
|
|
808
|
-
def image_id(self) -> Optional[pulumi.Input[str]]:
|
|
808
|
+
def image_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
809
809
|
"""
|
|
810
810
|
ID of the image used to launch the instances.
|
|
811
811
|
"""
|
|
812
812
|
return pulumi.get(self, "image_id")
|
|
813
813
|
|
|
814
814
|
@image_id.setter
|
|
815
|
-
def image_id(self, value: Optional[pulumi.Input[str]]):
|
|
815
|
+
def image_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
816
816
|
pulumi.set(self, "image_id", value)
|
|
817
817
|
|
|
818
|
-
@property
|
|
818
|
+
@_builtins.property
|
|
819
819
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
820
820
|
def instance_metadata_options(self) -> Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]:
|
|
821
821
|
"""
|
|
@@ -827,19 +827,19 @@ class _OceanState:
|
|
|
827
827
|
def instance_metadata_options(self, value: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]):
|
|
828
828
|
pulumi.set(self, "instance_metadata_options", value)
|
|
829
829
|
|
|
830
|
-
@property
|
|
830
|
+
@_builtins.property
|
|
831
831
|
@pulumi.getter(name="keyPair")
|
|
832
|
-
def key_pair(self) -> Optional[pulumi.Input[str]]:
|
|
832
|
+
def key_pair(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
833
833
|
"""
|
|
834
834
|
The key pair to attach the instances.
|
|
835
835
|
"""
|
|
836
836
|
return pulumi.get(self, "key_pair")
|
|
837
837
|
|
|
838
838
|
@key_pair.setter
|
|
839
|
-
def key_pair(self, value: Optional[pulumi.Input[str]]):
|
|
839
|
+
def key_pair(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
840
840
|
pulumi.set(self, "key_pair", value)
|
|
841
841
|
|
|
842
|
-
@property
|
|
842
|
+
@_builtins.property
|
|
843
843
|
@pulumi.getter
|
|
844
844
|
def logging(self) -> Optional[pulumi.Input['OceanLoggingArgs']]:
|
|
845
845
|
"""
|
|
@@ -851,55 +851,55 @@ class _OceanState:
|
|
|
851
851
|
def logging(self, value: Optional[pulumi.Input['OceanLoggingArgs']]):
|
|
852
852
|
pulumi.set(self, "logging", value)
|
|
853
853
|
|
|
854
|
-
@property
|
|
854
|
+
@_builtins.property
|
|
855
855
|
@pulumi.getter(name="maxSize")
|
|
856
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
856
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
857
857
|
"""
|
|
858
858
|
The upper limit of instances the cluster can scale up to.
|
|
859
859
|
"""
|
|
860
860
|
return pulumi.get(self, "max_size")
|
|
861
861
|
|
|
862
862
|
@max_size.setter
|
|
863
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
863
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
864
864
|
pulumi.set(self, "max_size", value)
|
|
865
865
|
|
|
866
|
-
@property
|
|
866
|
+
@_builtins.property
|
|
867
867
|
@pulumi.getter(name="minSize")
|
|
868
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
868
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
869
869
|
"""
|
|
870
870
|
The lower limit of instances the cluster can scale down to.
|
|
871
871
|
"""
|
|
872
872
|
return pulumi.get(self, "min_size")
|
|
873
873
|
|
|
874
874
|
@min_size.setter
|
|
875
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
875
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
876
876
|
pulumi.set(self, "min_size", value)
|
|
877
877
|
|
|
878
|
-
@property
|
|
878
|
+
@_builtins.property
|
|
879
879
|
@pulumi.getter
|
|
880
|
-
def monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
880
|
+
def monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
881
881
|
"""
|
|
882
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.
|
|
883
883
|
"""
|
|
884
884
|
return pulumi.get(self, "monitoring")
|
|
885
885
|
|
|
886
886
|
@monitoring.setter
|
|
887
|
-
def monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
887
|
+
def monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
888
888
|
pulumi.set(self, "monitoring", value)
|
|
889
889
|
|
|
890
|
-
@property
|
|
890
|
+
@_builtins.property
|
|
891
891
|
@pulumi.getter
|
|
892
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
892
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
893
893
|
"""
|
|
894
894
|
The Ocean cluster name.
|
|
895
895
|
"""
|
|
896
896
|
return pulumi.get(self, "name")
|
|
897
897
|
|
|
898
898
|
@name.setter
|
|
899
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
899
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
900
900
|
pulumi.set(self, "name", value)
|
|
901
901
|
|
|
902
|
-
@property
|
|
902
|
+
@_builtins.property
|
|
903
903
|
@pulumi.getter(name="optimizeImages")
|
|
904
904
|
def optimize_images(self) -> Optional[pulumi.Input['OceanOptimizeImagesArgs']]:
|
|
905
905
|
"""
|
|
@@ -911,19 +911,19 @@ class _OceanState:
|
|
|
911
911
|
def optimize_images(self, value: Optional[pulumi.Input['OceanOptimizeImagesArgs']]):
|
|
912
912
|
pulumi.set(self, "optimize_images", value)
|
|
913
913
|
|
|
914
|
-
@property
|
|
914
|
+
@_builtins.property
|
|
915
915
|
@pulumi.getter
|
|
916
|
-
def region(self) -> Optional[pulumi.Input[str]]:
|
|
916
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
917
917
|
"""
|
|
918
918
|
The region the cluster will run in.
|
|
919
919
|
"""
|
|
920
920
|
return pulumi.get(self, "region")
|
|
921
921
|
|
|
922
922
|
@region.setter
|
|
923
|
-
def region(self, value: Optional[pulumi.Input[str]]):
|
|
923
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
924
924
|
pulumi.set(self, "region", value)
|
|
925
925
|
|
|
926
|
-
@property
|
|
926
|
+
@_builtins.property
|
|
927
927
|
@pulumi.getter(name="scheduledTasks")
|
|
928
928
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]:
|
|
929
929
|
"""
|
|
@@ -935,43 +935,43 @@ class _OceanState:
|
|
|
935
935
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]):
|
|
936
936
|
pulumi.set(self, "scheduled_tasks", value)
|
|
937
937
|
|
|
938
|
-
@property
|
|
938
|
+
@_builtins.property
|
|
939
939
|
@pulumi.getter(name="securityGroupIds")
|
|
940
|
-
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]]]]:
|
|
941
941
|
"""
|
|
942
942
|
One or more security group ids.
|
|
943
943
|
"""
|
|
944
944
|
return pulumi.get(self, "security_group_ids")
|
|
945
945
|
|
|
946
946
|
@security_group_ids.setter
|
|
947
|
-
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]]]]):
|
|
948
948
|
pulumi.set(self, "security_group_ids", value)
|
|
949
949
|
|
|
950
|
-
@property
|
|
950
|
+
@_builtins.property
|
|
951
951
|
@pulumi.getter(name="spotPercentage")
|
|
952
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
952
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
953
953
|
"""
|
|
954
954
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
955
955
|
"""
|
|
956
956
|
return pulumi.get(self, "spot_percentage")
|
|
957
957
|
|
|
958
958
|
@spot_percentage.setter
|
|
959
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
959
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
960
960
|
pulumi.set(self, "spot_percentage", value)
|
|
961
961
|
|
|
962
|
-
@property
|
|
962
|
+
@_builtins.property
|
|
963
963
|
@pulumi.getter(name="subnetIds")
|
|
964
|
-
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
964
|
+
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
965
965
|
"""
|
|
966
966
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
967
967
|
"""
|
|
968
968
|
return pulumi.get(self, "subnet_ids")
|
|
969
969
|
|
|
970
970
|
@subnet_ids.setter
|
|
971
|
-
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]]]]):
|
|
972
972
|
pulumi.set(self, "subnet_ids", value)
|
|
973
973
|
|
|
974
|
-
@property
|
|
974
|
+
@_builtins.property
|
|
975
975
|
@pulumi.getter
|
|
976
976
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]:
|
|
977
977
|
"""
|
|
@@ -983,7 +983,7 @@ class _OceanState:
|
|
|
983
983
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]):
|
|
984
984
|
pulumi.set(self, "tags", value)
|
|
985
985
|
|
|
986
|
-
@property
|
|
986
|
+
@_builtins.property
|
|
987
987
|
@pulumi.getter(name="updatePolicy")
|
|
988
988
|
def update_policy(self) -> Optional[pulumi.Input['OceanUpdatePolicyArgs']]:
|
|
989
989
|
"""
|
|
@@ -995,106 +995,213 @@ class _OceanState:
|
|
|
995
995
|
def update_policy(self, value: Optional[pulumi.Input['OceanUpdatePolicyArgs']]):
|
|
996
996
|
pulumi.set(self, "update_policy", value)
|
|
997
997
|
|
|
998
|
-
@property
|
|
998
|
+
@_builtins.property
|
|
999
999
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
1000
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[bool]]:
|
|
1000
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1001
1001
|
"""
|
|
1002
1002
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
1003
1003
|
"""
|
|
1004
1004
|
return pulumi.get(self, "use_as_template_only")
|
|
1005
1005
|
|
|
1006
1006
|
@use_as_template_only.setter
|
|
1007
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[bool]]):
|
|
1007
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1008
1008
|
pulumi.set(self, "use_as_template_only", value)
|
|
1009
1009
|
|
|
1010
|
-
@property
|
|
1010
|
+
@_builtins.property
|
|
1011
1011
|
@pulumi.getter(name="userData")
|
|
1012
|
-
def user_data(self) -> Optional[pulumi.Input[str]]:
|
|
1012
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1013
1013
|
"""
|
|
1014
1014
|
Base64-encoded MIME user data to make available to the instances.
|
|
1015
1015
|
"""
|
|
1016
1016
|
return pulumi.get(self, "user_data")
|
|
1017
1017
|
|
|
1018
1018
|
@user_data.setter
|
|
1019
|
-
def user_data(self, value: Optional[pulumi.Input[str]]):
|
|
1019
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1020
1020
|
pulumi.set(self, "user_data", value)
|
|
1021
1021
|
|
|
1022
|
-
@property
|
|
1022
|
+
@_builtins.property
|
|
1023
1023
|
@pulumi.getter(name="utilizeCommitments")
|
|
1024
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[bool]]:
|
|
1024
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1025
1025
|
"""
|
|
1026
1026
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1027
1027
|
"""
|
|
1028
1028
|
return pulumi.get(self, "utilize_commitments")
|
|
1029
1029
|
|
|
1030
1030
|
@utilize_commitments.setter
|
|
1031
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[bool]]):
|
|
1031
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1032
1032
|
pulumi.set(self, "utilize_commitments", value)
|
|
1033
1033
|
|
|
1034
|
-
@property
|
|
1034
|
+
@_builtins.property
|
|
1035
1035
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
1036
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[bool]]:
|
|
1036
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1037
1037
|
"""
|
|
1038
1038
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1039
1039
|
"""
|
|
1040
1040
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
1041
1041
|
|
|
1042
1042
|
@utilize_reserved_instances.setter
|
|
1043
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[bool]]):
|
|
1043
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1044
1044
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
1045
1045
|
|
|
1046
|
-
@property
|
|
1046
|
+
@_builtins.property
|
|
1047
1047
|
@pulumi.getter
|
|
1048
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1048
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1049
1049
|
return pulumi.get(self, "whitelists")
|
|
1050
1050
|
|
|
1051
1051
|
@whitelists.setter
|
|
1052
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1052
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1053
1053
|
pulumi.set(self, "whitelists", value)
|
|
1054
1054
|
|
|
1055
1055
|
|
|
1056
|
+
@pulumi.type_token("spotinst:ecs/ocean:Ocean")
|
|
1056
1057
|
class Ocean(pulumi.CustomResource):
|
|
1057
1058
|
@overload
|
|
1058
1059
|
def __init__(__self__,
|
|
1059
1060
|
resource_name: str,
|
|
1060
1061
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1061
|
-
associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
|
|
1062
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1062
1063
|
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1063
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1064
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1064
1065
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1065
|
-
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
1066
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1066
1067
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1067
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1068
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1069
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
1070
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = 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,
|
|
1071
1072
|
filters: Optional[pulumi.Input[Union['OceanFiltersArgs', 'OceanFiltersArgsDict']]] = None,
|
|
1072
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
1073
|
-
image_id: Optional[pulumi.Input[str]] = None,
|
|
1073
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1074
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1074
1075
|
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1075
|
-
key_pair: Optional[pulumi.Input[str]] = None,
|
|
1076
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1076
1077
|
logging: Optional[pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']]] = None,
|
|
1077
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
1078
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
1079
|
-
monitoring: Optional[pulumi.Input[bool]] = None,
|
|
1080
|
-
name: Optional[pulumi.Input[str]] = 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,
|
|
1081
1082
|
optimize_images: Optional[pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']]] = None,
|
|
1082
|
-
region: Optional[pulumi.Input[str]] = None,
|
|
1083
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1083
1084
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]]] = None,
|
|
1084
|
-
security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1085
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
1086
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = 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,
|
|
1087
1088
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1088
1089
|
update_policy: Optional[pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']]] = None,
|
|
1089
|
-
use_as_template_only: Optional[pulumi.Input[bool]] = None,
|
|
1090
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
1091
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
1092
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
1093
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = 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,
|
|
1094
1095
|
__props__=None):
|
|
1095
1096
|
"""
|
|
1096
1097
|
Manages a Spotinst Ocean ECS resource.
|
|
1097
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
|
+
|
|
1098
1205
|
## Import
|
|
1099
1206
|
|
|
1100
1207
|
Clusters can be imported using the Ocean `id`, e.g.,
|
|
@@ -1107,35 +1214,35 @@ class Ocean(pulumi.CustomResource):
|
|
|
1107
1214
|
|
|
1108
1215
|
:param str resource_name: The name of the resource.
|
|
1109
1216
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1110
|
-
:param pulumi.Input[bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1217
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1111
1218
|
:param pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']] autoscaler: Describes the Ocean ECS autoscaler.
|
|
1112
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.
|
|
1113
|
-
:param pulumi.Input[str] cluster_name: The name of the ECS cluster.
|
|
1114
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1115
|
-
: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.
|
|
1116
|
-
: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.
|
|
1117
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1118
|
-
:param pulumi.Input[str] iam_instance_profile: The instance profile iam role.
|
|
1119
|
-
:param pulumi.Input[str] image_id: ID of the image used to launch the instances.
|
|
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.
|
|
1120
1227
|
:param pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
1121
|
-
:param pulumi.Input[str] key_pair: The key pair to attach the instances.
|
|
1228
|
+
:param pulumi.Input[_builtins.str] key_pair: The key pair to attach the instances.
|
|
1122
1229
|
:param pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']] logging: Logging configuration.
|
|
1123
|
-
:param pulumi.Input[int] max_size: The upper limit of instances the cluster can scale up to.
|
|
1124
|
-
:param pulumi.Input[int] min_size: The lower limit of instances the cluster can scale down to.
|
|
1125
|
-
: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.
|
|
1126
|
-
:param pulumi.Input[str] name: The Ocean cluster name.
|
|
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.
|
|
1127
1234
|
:param pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']] optimize_images: Object. Set auto image update settings.
|
|
1128
|
-
:param pulumi.Input[str] region: The region the cluster will run in.
|
|
1235
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
1129
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.
|
|
1130
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: One or more security group ids.
|
|
1131
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1132
|
-
: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.
|
|
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.
|
|
1133
1240
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
1134
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.
|
|
1135
|
-
: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.
|
|
1136
|
-
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
1137
|
-
:param pulumi.Input[bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1138
|
-
:param pulumi.Input[bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
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.
|
|
1139
1246
|
"""
|
|
1140
1247
|
...
|
|
1141
1248
|
@overload
|
|
@@ -1146,6 +1253,112 @@ class Ocean(pulumi.CustomResource):
|
|
|
1146
1253
|
"""
|
|
1147
1254
|
Manages a Spotinst Ocean ECS resource.
|
|
1148
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
|
+
|
|
1149
1362
|
## Import
|
|
1150
1363
|
|
|
1151
1364
|
Clusters can be imported using the Ocean `id`, e.g.,
|
|
@@ -1171,39 +1384,39 @@ class Ocean(pulumi.CustomResource):
|
|
|
1171
1384
|
def _internal_init(__self__,
|
|
1172
1385
|
resource_name: str,
|
|
1173
1386
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1174
|
-
associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
|
|
1387
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1175
1388
|
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1176
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1389
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1177
1390
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1178
|
-
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
1391
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1179
1392
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1180
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1181
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1182
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
1183
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = 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,
|
|
1184
1397
|
filters: Optional[pulumi.Input[Union['OceanFiltersArgs', 'OceanFiltersArgsDict']]] = None,
|
|
1185
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
1186
|
-
image_id: Optional[pulumi.Input[str]] = None,
|
|
1398
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1399
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1187
1400
|
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1188
|
-
key_pair: Optional[pulumi.Input[str]] = None,
|
|
1401
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1189
1402
|
logging: Optional[pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']]] = None,
|
|
1190
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
1191
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
1192
|
-
monitoring: Optional[pulumi.Input[bool]] = None,
|
|
1193
|
-
name: Optional[pulumi.Input[str]] = 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,
|
|
1194
1407
|
optimize_images: Optional[pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']]] = None,
|
|
1195
|
-
region: Optional[pulumi.Input[str]] = None,
|
|
1408
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1196
1409
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]]] = None,
|
|
1197
|
-
security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1198
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
1199
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = 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,
|
|
1200
1413
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1201
1414
|
update_policy: Optional[pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']]] = None,
|
|
1202
|
-
use_as_template_only: Optional[pulumi.Input[bool]] = None,
|
|
1203
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
1204
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
1205
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
1206
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = 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,
|
|
1207
1420
|
__props__=None):
|
|
1208
1421
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1209
1422
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1266,39 +1479,39 @@ class Ocean(pulumi.CustomResource):
|
|
|
1266
1479
|
def get(resource_name: str,
|
|
1267
1480
|
id: pulumi.Input[str],
|
|
1268
1481
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1269
|
-
associate_public_ip_address: Optional[pulumi.Input[bool]] = None,
|
|
1482
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1270
1483
|
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1271
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1484
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1272
1485
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1273
|
-
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
1486
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1274
1487
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1275
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1276
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1277
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
1278
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = 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,
|
|
1279
1492
|
filters: Optional[pulumi.Input[Union['OceanFiltersArgs', 'OceanFiltersArgsDict']]] = None,
|
|
1280
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
1281
|
-
image_id: Optional[pulumi.Input[str]] = None,
|
|
1493
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1494
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1282
1495
|
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1283
|
-
key_pair: Optional[pulumi.Input[str]] = None,
|
|
1496
|
+
key_pair: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1284
1497
|
logging: Optional[pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']]] = None,
|
|
1285
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
1286
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
1287
|
-
monitoring: Optional[pulumi.Input[bool]] = None,
|
|
1288
|
-
name: Optional[pulumi.Input[str]] = 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,
|
|
1289
1502
|
optimize_images: Optional[pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']]] = None,
|
|
1290
|
-
region: Optional[pulumi.Input[str]] = None,
|
|
1503
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1291
1504
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]]] = None,
|
|
1292
|
-
security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1293
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
1294
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = 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,
|
|
1295
1508
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1296
1509
|
update_policy: Optional[pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']]] = None,
|
|
1297
|
-
use_as_template_only: Optional[pulumi.Input[bool]] = None,
|
|
1298
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
1299
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
1300
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
1301
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None) -> 'Ocean':
|
|
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':
|
|
1302
1515
|
"""
|
|
1303
1516
|
Get an existing Ocean resource's state with the given name, id, and optional extra
|
|
1304
1517
|
properties used to qualify the lookup.
|
|
@@ -1306,35 +1519,35 @@ class Ocean(pulumi.CustomResource):
|
|
|
1306
1519
|
:param str resource_name: The unique name of the resulting resource.
|
|
1307
1520
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1308
1521
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1309
|
-
:param pulumi.Input[bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1522
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1310
1523
|
:param pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']] autoscaler: Describes the Ocean ECS autoscaler.
|
|
1311
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.
|
|
1312
|
-
:param pulumi.Input[str] cluster_name: The name of the ECS cluster.
|
|
1313
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1314
|
-
: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.
|
|
1315
|
-
: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.
|
|
1316
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1317
|
-
:param pulumi.Input[str] iam_instance_profile: The instance profile iam role.
|
|
1318
|
-
:param pulumi.Input[str] image_id: ID of the image used to launch the instances.
|
|
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.
|
|
1319
1532
|
:param pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
1320
|
-
:param pulumi.Input[str] key_pair: The key pair to attach the instances.
|
|
1533
|
+
:param pulumi.Input[_builtins.str] key_pair: The key pair to attach the instances.
|
|
1321
1534
|
:param pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']] logging: Logging configuration.
|
|
1322
|
-
:param pulumi.Input[int] max_size: The upper limit of instances the cluster can scale up to.
|
|
1323
|
-
:param pulumi.Input[int] min_size: The lower limit of instances the cluster can scale down to.
|
|
1324
|
-
: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.
|
|
1325
|
-
:param pulumi.Input[str] name: The Ocean cluster name.
|
|
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.
|
|
1326
1539
|
:param pulumi.Input[Union['OceanOptimizeImagesArgs', 'OceanOptimizeImagesArgsDict']] optimize_images: Object. Set auto image update settings.
|
|
1327
|
-
:param pulumi.Input[str] region: The region the cluster will run in.
|
|
1540
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
1328
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.
|
|
1329
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: One or more security group ids.
|
|
1330
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1331
|
-
: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.
|
|
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.
|
|
1332
1545
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
1333
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.
|
|
1334
|
-
: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.
|
|
1335
|
-
:param pulumi.Input[str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
1336
|
-
:param pulumi.Input[bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1337
|
-
:param pulumi.Input[bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
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.
|
|
1338
1551
|
"""
|
|
1339
1552
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1340
1553
|
|
|
@@ -1375,15 +1588,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
1375
1588
|
__props__.__dict__["whitelists"] = whitelists
|
|
1376
1589
|
return Ocean(resource_name, opts=opts, __props__=__props__)
|
|
1377
1590
|
|
|
1378
|
-
@property
|
|
1591
|
+
@_builtins.property
|
|
1379
1592
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
1380
|
-
def associate_public_ip_address(self) -> pulumi.Output[Optional[bool]]:
|
|
1593
|
+
def associate_public_ip_address(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1381
1594
|
"""
|
|
1382
1595
|
Configure public IP address allocation.
|
|
1383
1596
|
"""
|
|
1384
1597
|
return pulumi.get(self, "associate_public_ip_address")
|
|
1385
1598
|
|
|
1386
|
-
@property
|
|
1599
|
+
@_builtins.property
|
|
1387
1600
|
@pulumi.getter
|
|
1388
1601
|
def autoscaler(self) -> pulumi.Output[Optional['outputs.OceanAutoscaler']]:
|
|
1389
1602
|
"""
|
|
@@ -1391,12 +1604,12 @@ class Ocean(pulumi.CustomResource):
|
|
|
1391
1604
|
"""
|
|
1392
1605
|
return pulumi.get(self, "autoscaler")
|
|
1393
1606
|
|
|
1394
|
-
@property
|
|
1607
|
+
@_builtins.property
|
|
1395
1608
|
@pulumi.getter
|
|
1396
|
-
def blacklists(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1609
|
+
def blacklists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1397
1610
|
return pulumi.get(self, "blacklists")
|
|
1398
1611
|
|
|
1399
|
-
@property
|
|
1612
|
+
@_builtins.property
|
|
1400
1613
|
@pulumi.getter(name="blockDeviceMappings")
|
|
1401
1614
|
def block_device_mappings(self) -> pulumi.Output[Optional[Sequence['outputs.OceanBlockDeviceMapping']]]:
|
|
1402
1615
|
"""
|
|
@@ -1404,73 +1617,73 @@ class Ocean(pulumi.CustomResource):
|
|
|
1404
1617
|
"""
|
|
1405
1618
|
return pulumi.get(self, "block_device_mappings")
|
|
1406
1619
|
|
|
1407
|
-
@property
|
|
1620
|
+
@_builtins.property
|
|
1408
1621
|
@pulumi.getter(name="clusterName")
|
|
1409
|
-
def cluster_name(self) -> pulumi.Output[str]:
|
|
1622
|
+
def cluster_name(self) -> pulumi.Output[_builtins.str]:
|
|
1410
1623
|
"""
|
|
1411
1624
|
The name of the ECS cluster.
|
|
1412
1625
|
"""
|
|
1413
1626
|
return pulumi.get(self, "cluster_name")
|
|
1414
1627
|
|
|
1415
|
-
@property
|
|
1628
|
+
@_builtins.property
|
|
1416
1629
|
@pulumi.getter(name="clusterOrientations")
|
|
1417
1630
|
def cluster_orientations(self) -> pulumi.Output[Optional[Sequence['outputs.OceanClusterOrientation']]]:
|
|
1418
1631
|
return pulumi.get(self, "cluster_orientations")
|
|
1419
1632
|
|
|
1420
|
-
@property
|
|
1633
|
+
@_builtins.property
|
|
1421
1634
|
@pulumi.getter(name="desiredCapacity")
|
|
1422
|
-
def desired_capacity(self) -> pulumi.Output[int]:
|
|
1635
|
+
def desired_capacity(self) -> pulumi.Output[_builtins.int]:
|
|
1423
1636
|
"""
|
|
1424
1637
|
The number of instances to launch and maintain in the cluster.
|
|
1425
1638
|
"""
|
|
1426
1639
|
return pulumi.get(self, "desired_capacity")
|
|
1427
1640
|
|
|
1428
|
-
@property
|
|
1641
|
+
@_builtins.property
|
|
1429
1642
|
@pulumi.getter(name="drainingTimeout")
|
|
1430
|
-
def draining_timeout(self) -> pulumi.Output[Optional[int]]:
|
|
1643
|
+
def draining_timeout(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1431
1644
|
"""
|
|
1432
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.
|
|
1433
1646
|
"""
|
|
1434
1647
|
return pulumi.get(self, "draining_timeout")
|
|
1435
1648
|
|
|
1436
|
-
@property
|
|
1649
|
+
@_builtins.property
|
|
1437
1650
|
@pulumi.getter(name="ebsOptimized")
|
|
1438
|
-
def ebs_optimized(self) -> pulumi.Output[Optional[bool]]:
|
|
1651
|
+
def ebs_optimized(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1439
1652
|
"""
|
|
1440
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.
|
|
1441
1654
|
"""
|
|
1442
1655
|
return pulumi.get(self, "ebs_optimized")
|
|
1443
1656
|
|
|
1444
|
-
@property
|
|
1657
|
+
@_builtins.property
|
|
1445
1658
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1446
|
-
def fallback_to_ondemand(self) -> pulumi.Output[Optional[bool]]:
|
|
1659
|
+
def fallback_to_ondemand(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1447
1660
|
"""
|
|
1448
1661
|
If no Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1449
1662
|
"""
|
|
1450
1663
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1451
1664
|
|
|
1452
|
-
@property
|
|
1665
|
+
@_builtins.property
|
|
1453
1666
|
@pulumi.getter
|
|
1454
1667
|
def filters(self) -> pulumi.Output[Optional['outputs.OceanFilters']]:
|
|
1455
1668
|
return pulumi.get(self, "filters")
|
|
1456
1669
|
|
|
1457
|
-
@property
|
|
1670
|
+
@_builtins.property
|
|
1458
1671
|
@pulumi.getter(name="iamInstanceProfile")
|
|
1459
|
-
def iam_instance_profile(self) -> pulumi.Output[Optional[str]]:
|
|
1672
|
+
def iam_instance_profile(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1460
1673
|
"""
|
|
1461
1674
|
The instance profile iam role.
|
|
1462
1675
|
"""
|
|
1463
1676
|
return pulumi.get(self, "iam_instance_profile")
|
|
1464
1677
|
|
|
1465
|
-
@property
|
|
1678
|
+
@_builtins.property
|
|
1466
1679
|
@pulumi.getter(name="imageId")
|
|
1467
|
-
def image_id(self) -> pulumi.Output[str]:
|
|
1680
|
+
def image_id(self) -> pulumi.Output[_builtins.str]:
|
|
1468
1681
|
"""
|
|
1469
1682
|
ID of the image used to launch the instances.
|
|
1470
1683
|
"""
|
|
1471
1684
|
return pulumi.get(self, "image_id")
|
|
1472
1685
|
|
|
1473
|
-
@property
|
|
1686
|
+
@_builtins.property
|
|
1474
1687
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
1475
1688
|
def instance_metadata_options(self) -> pulumi.Output[Optional['outputs.OceanInstanceMetadataOptions']]:
|
|
1476
1689
|
"""
|
|
@@ -1478,15 +1691,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
1478
1691
|
"""
|
|
1479
1692
|
return pulumi.get(self, "instance_metadata_options")
|
|
1480
1693
|
|
|
1481
|
-
@property
|
|
1694
|
+
@_builtins.property
|
|
1482
1695
|
@pulumi.getter(name="keyPair")
|
|
1483
|
-
def key_pair(self) -> pulumi.Output[Optional[str]]:
|
|
1696
|
+
def key_pair(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1484
1697
|
"""
|
|
1485
1698
|
The key pair to attach the instances.
|
|
1486
1699
|
"""
|
|
1487
1700
|
return pulumi.get(self, "key_pair")
|
|
1488
1701
|
|
|
1489
|
-
@property
|
|
1702
|
+
@_builtins.property
|
|
1490
1703
|
@pulumi.getter
|
|
1491
1704
|
def logging(self) -> pulumi.Output[Optional['outputs.OceanLogging']]:
|
|
1492
1705
|
"""
|
|
@@ -1494,39 +1707,39 @@ class Ocean(pulumi.CustomResource):
|
|
|
1494
1707
|
"""
|
|
1495
1708
|
return pulumi.get(self, "logging")
|
|
1496
1709
|
|
|
1497
|
-
@property
|
|
1710
|
+
@_builtins.property
|
|
1498
1711
|
@pulumi.getter(name="maxSize")
|
|
1499
|
-
def max_size(self) -> pulumi.Output[int]:
|
|
1712
|
+
def max_size(self) -> pulumi.Output[_builtins.int]:
|
|
1500
1713
|
"""
|
|
1501
1714
|
The upper limit of instances the cluster can scale up to.
|
|
1502
1715
|
"""
|
|
1503
1716
|
return pulumi.get(self, "max_size")
|
|
1504
1717
|
|
|
1505
|
-
@property
|
|
1718
|
+
@_builtins.property
|
|
1506
1719
|
@pulumi.getter(name="minSize")
|
|
1507
|
-
def min_size(self) -> pulumi.Output[int]:
|
|
1720
|
+
def min_size(self) -> pulumi.Output[_builtins.int]:
|
|
1508
1721
|
"""
|
|
1509
1722
|
The lower limit of instances the cluster can scale down to.
|
|
1510
1723
|
"""
|
|
1511
1724
|
return pulumi.get(self, "min_size")
|
|
1512
1725
|
|
|
1513
|
-
@property
|
|
1726
|
+
@_builtins.property
|
|
1514
1727
|
@pulumi.getter
|
|
1515
|
-
def monitoring(self) -> pulumi.Output[Optional[bool]]:
|
|
1728
|
+
def monitoring(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1516
1729
|
"""
|
|
1517
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.
|
|
1518
1731
|
"""
|
|
1519
1732
|
return pulumi.get(self, "monitoring")
|
|
1520
1733
|
|
|
1521
|
-
@property
|
|
1734
|
+
@_builtins.property
|
|
1522
1735
|
@pulumi.getter
|
|
1523
|
-
def name(self) -> pulumi.Output[str]:
|
|
1736
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1524
1737
|
"""
|
|
1525
1738
|
The Ocean cluster name.
|
|
1526
1739
|
"""
|
|
1527
1740
|
return pulumi.get(self, "name")
|
|
1528
1741
|
|
|
1529
|
-
@property
|
|
1742
|
+
@_builtins.property
|
|
1530
1743
|
@pulumi.getter(name="optimizeImages")
|
|
1531
1744
|
def optimize_images(self) -> pulumi.Output[Optional['outputs.OceanOptimizeImages']]:
|
|
1532
1745
|
"""
|
|
@@ -1534,15 +1747,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
1534
1747
|
"""
|
|
1535
1748
|
return pulumi.get(self, "optimize_images")
|
|
1536
1749
|
|
|
1537
|
-
@property
|
|
1750
|
+
@_builtins.property
|
|
1538
1751
|
@pulumi.getter
|
|
1539
|
-
def region(self) -> pulumi.Output[str]:
|
|
1752
|
+
def region(self) -> pulumi.Output[_builtins.str]:
|
|
1540
1753
|
"""
|
|
1541
1754
|
The region the cluster will run in.
|
|
1542
1755
|
"""
|
|
1543
1756
|
return pulumi.get(self, "region")
|
|
1544
1757
|
|
|
1545
|
-
@property
|
|
1758
|
+
@_builtins.property
|
|
1546
1759
|
@pulumi.getter(name="scheduledTasks")
|
|
1547
1760
|
def scheduled_tasks(self) -> pulumi.Output[Optional[Sequence['outputs.OceanScheduledTask']]]:
|
|
1548
1761
|
"""
|
|
@@ -1550,31 +1763,31 @@ class Ocean(pulumi.CustomResource):
|
|
|
1550
1763
|
"""
|
|
1551
1764
|
return pulumi.get(self, "scheduled_tasks")
|
|
1552
1765
|
|
|
1553
|
-
@property
|
|
1766
|
+
@_builtins.property
|
|
1554
1767
|
@pulumi.getter(name="securityGroupIds")
|
|
1555
|
-
def security_group_ids(self) -> pulumi.Output[Sequence[str]]:
|
|
1768
|
+
def security_group_ids(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1556
1769
|
"""
|
|
1557
1770
|
One or more security group ids.
|
|
1558
1771
|
"""
|
|
1559
1772
|
return pulumi.get(self, "security_group_ids")
|
|
1560
1773
|
|
|
1561
|
-
@property
|
|
1774
|
+
@_builtins.property
|
|
1562
1775
|
@pulumi.getter(name="spotPercentage")
|
|
1563
|
-
def spot_percentage(self) -> pulumi.Output[Optional[int]]:
|
|
1776
|
+
def spot_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1564
1777
|
"""
|
|
1565
1778
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1566
1779
|
"""
|
|
1567
1780
|
return pulumi.get(self, "spot_percentage")
|
|
1568
1781
|
|
|
1569
|
-
@property
|
|
1782
|
+
@_builtins.property
|
|
1570
1783
|
@pulumi.getter(name="subnetIds")
|
|
1571
|
-
def subnet_ids(self) -> pulumi.Output[Sequence[str]]:
|
|
1784
|
+
def subnet_ids(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1572
1785
|
"""
|
|
1573
1786
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public ip.
|
|
1574
1787
|
"""
|
|
1575
1788
|
return pulumi.get(self, "subnet_ids")
|
|
1576
1789
|
|
|
1577
|
-
@property
|
|
1790
|
+
@_builtins.property
|
|
1578
1791
|
@pulumi.getter
|
|
1579
1792
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.OceanTag']]]:
|
|
1580
1793
|
"""
|
|
@@ -1582,7 +1795,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1582
1795
|
"""
|
|
1583
1796
|
return pulumi.get(self, "tags")
|
|
1584
1797
|
|
|
1585
|
-
@property
|
|
1798
|
+
@_builtins.property
|
|
1586
1799
|
@pulumi.getter(name="updatePolicy")
|
|
1587
1800
|
def update_policy(self) -> pulumi.Output[Optional['outputs.OceanUpdatePolicy']]:
|
|
1588
1801
|
"""
|
|
@@ -1590,40 +1803,40 @@ class Ocean(pulumi.CustomResource):
|
|
|
1590
1803
|
"""
|
|
1591
1804
|
return pulumi.get(self, "update_policy")
|
|
1592
1805
|
|
|
1593
|
-
@property
|
|
1806
|
+
@_builtins.property
|
|
1594
1807
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
1595
|
-
def use_as_template_only(self) -> pulumi.Output[Optional[bool]]:
|
|
1808
|
+
def use_as_template_only(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1596
1809
|
"""
|
|
1597
1810
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
1598
1811
|
"""
|
|
1599
1812
|
return pulumi.get(self, "use_as_template_only")
|
|
1600
1813
|
|
|
1601
|
-
@property
|
|
1814
|
+
@_builtins.property
|
|
1602
1815
|
@pulumi.getter(name="userData")
|
|
1603
|
-
def user_data(self) -> pulumi.Output[Optional[str]]:
|
|
1816
|
+
def user_data(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1604
1817
|
"""
|
|
1605
1818
|
Base64-encoded MIME user data to make available to the instances.
|
|
1606
1819
|
"""
|
|
1607
1820
|
return pulumi.get(self, "user_data")
|
|
1608
1821
|
|
|
1609
|
-
@property
|
|
1822
|
+
@_builtins.property
|
|
1610
1823
|
@pulumi.getter(name="utilizeCommitments")
|
|
1611
|
-
def utilize_commitments(self) -> pulumi.Output[Optional[bool]]:
|
|
1824
|
+
def utilize_commitments(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1612
1825
|
"""
|
|
1613
1826
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1614
1827
|
"""
|
|
1615
1828
|
return pulumi.get(self, "utilize_commitments")
|
|
1616
1829
|
|
|
1617
|
-
@property
|
|
1830
|
+
@_builtins.property
|
|
1618
1831
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
1619
|
-
def utilize_reserved_instances(self) -> pulumi.Output[Optional[bool]]:
|
|
1832
|
+
def utilize_reserved_instances(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1620
1833
|
"""
|
|
1621
1834
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1622
1835
|
"""
|
|
1623
1836
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
1624
1837
|
|
|
1625
|
-
@property
|
|
1838
|
+
@_builtins.property
|
|
1626
1839
|
@pulumi.getter
|
|
1627
|
-
def whitelists(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1840
|
+
def whitelists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1628
1841
|
return pulumi.get(self, "whitelists")
|
|
1629
1842
|
|