pulumi-spotinst 3.124.0a1753339288__py3-none-any.whl → 3.124.0a1753511976__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.
Potentially problematic release.
This version of pulumi-spotinst might be problematic. Click here for more details.
- pulumi_spotinst/__init__.py +1 -1
- pulumi_spotinst/_inputs.py +1616 -1617
- pulumi_spotinst/account.py +18 -19
- pulumi_spotinst/aws/__init__.py +1 -1
- pulumi_spotinst/aws/_inputs.py +3654 -3655
- pulumi_spotinst/aws/account.py +18 -19
- pulumi_spotinst/aws/beanstalk.py +176 -177
- pulumi_spotinst/aws/credentials.py +35 -36
- pulumi_spotinst/aws/elastigroup.py +936 -937
- pulumi_spotinst/aws/managed_instance.py +505 -506
- pulumi_spotinst/aws/mr_scalar.py +652 -653
- pulumi_spotinst/aws/ocean.py +531 -532
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +35 -36
- pulumi_spotinst/aws/ocean_launch_spec.py +302 -303
- pulumi_spotinst/aws/outputs.py +2392 -2393
- pulumi_spotinst/aws/suspension.py +21 -22
- pulumi_spotinst/azure/__init__.py +1 -1
- pulumi_spotinst/azure/_inputs.py +606 -607
- pulumi_spotinst/azure/ocean_np.py +385 -386
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +321 -322
- pulumi_spotinst/azure/outputs.py +410 -411
- pulumi_spotinst/config/__init__.py +1 -1
- pulumi_spotinst/config/__init__.pyi +1 -2
- pulumi_spotinst/config/vars.py +5 -6
- pulumi_spotinst/credentials_azure.py +103 -104
- pulumi_spotinst/credentials_gcp.py +188 -189
- pulumi_spotinst/data_integration.py +38 -39
- pulumi_spotinst/ecs/__init__.py +1 -1
- pulumi_spotinst/ecs/_inputs.py +583 -584
- pulumi_spotinst/ecs/ocean.py +414 -415
- pulumi_spotinst/ecs/ocean_launch_spec.py +195 -196
- pulumi_spotinst/ecs/outputs.py +393 -394
- pulumi_spotinst/elastigroup_azure_v3.py +324 -325
- pulumi_spotinst/gcp/__init__.py +1 -1
- pulumi_spotinst/gcp/_inputs.py +505 -506
- pulumi_spotinst/gcp/elastigroup.py +481 -482
- pulumi_spotinst/gcp/outputs.py +335 -336
- pulumi_spotinst/gke/__init__.py +1 -1
- pulumi_spotinst/gke/_inputs.py +917 -918
- pulumi_spotinst/gke/elastigroup.py +339 -340
- pulumi_spotinst/gke/ocean_import.py +202 -203
- pulumi_spotinst/gke/ocean_launch_spec.py +210 -211
- pulumi_spotinst/gke/ocean_launch_spec_import.py +35 -36
- pulumi_spotinst/gke/outputs.py +597 -598
- pulumi_spotinst/health_check.py +64 -65
- pulumi_spotinst/notification_center.py +62 -63
- pulumi_spotinst/ocean_right_sizing_rule.py +74 -75
- pulumi_spotinst/oceancd/__init__.py +1 -1
- pulumi_spotinst/oceancd/_inputs.py +763 -764
- pulumi_spotinst/oceancd/outputs.py +525 -526
- pulumi_spotinst/oceancd/rollout_spec.py +33 -34
- pulumi_spotinst/oceancd/strategy.py +20 -21
- pulumi_spotinst/oceancd/verification_provider.py +50 -51
- pulumi_spotinst/oceancd/verification_template.py +24 -25
- pulumi_spotinst/organization/__init__.py +1 -1
- pulumi_spotinst/organization/_inputs.py +67 -68
- pulumi_spotinst/organization/outputs.py +45 -46
- pulumi_spotinst/organization/policy.py +38 -39
- pulumi_spotinst/organization/programmatic_user.py +58 -59
- pulumi_spotinst/organization/user.py +106 -107
- pulumi_spotinst/organization/user_group.py +55 -56
- pulumi_spotinst/outputs.py +990 -991
- pulumi_spotinst/provider.py +40 -41
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +1 -1
- pulumi_spotinst/spark/_inputs.py +103 -104
- pulumi_spotinst/spark/ocean.py +36 -37
- pulumi_spotinst/spark/ocean_virtual_node_group.py +27 -28
- pulumi_spotinst/spark/outputs.py +71 -72
- pulumi_spotinst/stateful_node_azure.py +304 -305
- pulumi_spotinst/subscription.py +86 -87
- {pulumi_spotinst-3.124.0a1753339288.dist-info → pulumi_spotinst-3.124.0a1753511976.dist-info}/METADATA +1 -1
- pulumi_spotinst-3.124.0a1753511976.dist-info/RECORD +77 -0
- pulumi_spotinst-3.124.0a1753339288.dist-info/RECORD +0 -77
- {pulumi_spotinst-3.124.0a1753339288.dist-info → pulumi_spotinst-3.124.0a1753511976.dist-info}/WHEEL +0 -0
- {pulumi_spotinst-3.124.0a1753339288.dist-info → pulumi_spotinst-3.124.0a1753511976.dist-info}/top_level.txt +0 -0
pulumi_spotinst/aws/ocean.py
CHANGED
|
@@ -2,8 +2,7 @@
|
|
|
2
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 builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -22,93 +21,93 @@ __all__ = ['OceanArgs', 'Ocean']
|
|
|
22
21
|
@pulumi.input_type
|
|
23
22
|
class OceanArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
|
-
image_id: pulumi.Input[
|
|
26
|
-
security_groups: pulumi.Input[Sequence[pulumi.Input[
|
|
27
|
-
subnet_ids: pulumi.Input[Sequence[pulumi.Input[
|
|
28
|
-
associate_ipv6_address: Optional[pulumi.Input[
|
|
29
|
-
associate_public_ip_address: Optional[pulumi.Input[
|
|
24
|
+
image_id: pulumi.Input[_builtins.str],
|
|
25
|
+
security_groups: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
26
|
+
subnet_ids: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
27
|
+
associate_ipv6_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
28
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
30
29
|
attach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]] = None,
|
|
31
30
|
autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
|
|
32
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
31
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
33
32
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
|
|
34
33
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
|
|
35
|
-
controller_id: Optional[pulumi.Input[
|
|
36
|
-
desired_capacity: Optional[pulumi.Input[
|
|
34
|
+
controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
37
36
|
detach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]] = None,
|
|
38
|
-
draining_timeout: Optional[pulumi.Input[
|
|
39
|
-
ebs_optimized: Optional[pulumi.Input[
|
|
40
|
-
fallback_to_ondemand: Optional[pulumi.Input[
|
|
37
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
38
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
39
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
41
40
|
filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
|
|
42
|
-
grace_period: Optional[pulumi.Input[
|
|
43
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[
|
|
44
|
-
iam_instance_profile: Optional[pulumi.Input[
|
|
41
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
42
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
43
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
45
44
|
instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
|
|
46
45
|
instance_store_policy: Optional[pulumi.Input['OceanInstanceStorePolicyArgs']] = None,
|
|
47
|
-
key_name: Optional[pulumi.Input[
|
|
46
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
48
47
|
load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]] = None,
|
|
49
48
|
logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
|
|
50
|
-
max_size: Optional[pulumi.Input[
|
|
51
|
-
min_size: Optional[pulumi.Input[
|
|
52
|
-
monitoring: Optional[pulumi.Input[
|
|
53
|
-
name: Optional[pulumi.Input[
|
|
54
|
-
region: Optional[pulumi.Input[
|
|
55
|
-
reserved_enis: Optional[pulumi.Input[
|
|
49
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
50
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
51
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
52
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
53
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
54
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
56
55
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]] = None,
|
|
57
|
-
root_volume_size: Optional[pulumi.Input[
|
|
56
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
58
57
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
|
|
59
|
-
spot_percentage: Optional[pulumi.Input[
|
|
60
|
-
spread_nodes_by: Optional[pulumi.Input[
|
|
58
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
59
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
61
60
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]] = None,
|
|
62
61
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
|
|
63
62
|
update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
|
|
64
|
-
use_as_template_only: Optional[pulumi.Input[
|
|
65
|
-
user_data: Optional[pulumi.Input[
|
|
66
|
-
utilize_commitments: Optional[pulumi.Input[
|
|
67
|
-
utilize_reserved_instances: Optional[pulumi.Input[
|
|
68
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
63
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
64
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
65
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
66
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
67
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
69
68
|
"""
|
|
70
69
|
The set of arguments for constructing a Ocean resource.
|
|
71
|
-
:param pulumi.Input[
|
|
72
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
73
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
70
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
71
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: One or more security group ids.
|
|
72
|
+
: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.
|
|
74
73
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
75
|
-
:param pulumi.Input[
|
|
76
|
-
:param pulumi.Input[
|
|
74
|
+
:param pulumi.Input[_builtins.bool] associate_ipv6_address: Configure IPv6 address allocation.
|
|
75
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
77
76
|
:param pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]] attach_load_balancers: Attach load balancers to the cluster.
|
|
78
77
|
:param pulumi.Input['OceanAutoscalerArgs'] autoscaler: Describes the Ocean Kubernetes Auto Scaler.
|
|
79
78
|
:param pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]] block_device_mappings: Object. Array list of block devices that are exposed to the instance, specify either virtual devices and EBS volumes.
|
|
80
|
-
:param pulumi.Input[
|
|
81
|
-
:param pulumi.Input[
|
|
79
|
+
:param pulumi.Input[_builtins.str] controller_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
80
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
82
81
|
:param pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]] detach_load_balancers: Detach load balancers from the cluster.
|
|
83
|
-
:param pulumi.Input[
|
|
84
|
-
:param pulumi.Input[
|
|
85
|
-
:param pulumi.Input[
|
|
86
|
-
:param pulumi.Input[
|
|
87
|
-
:param pulumi.Input[
|
|
88
|
-
:param pulumi.Input[
|
|
82
|
+
: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.
|
|
83
|
+
: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.
|
|
84
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
85
|
+
:param pulumi.Input[_builtins.int] grace_period: The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
86
|
+
:param pulumi.Input[_builtins.int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, an existing instance should remain active after becoming unhealthy. After the set time out the instance will be replaced. The minimum value allowed is 60, and it must be a multiple of 60.
|
|
87
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
89
88
|
:param pulumi.Input['OceanInstanceMetadataOptionsArgs'] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
90
89
|
:param pulumi.Input['OceanInstanceStorePolicyArgs'] instance_store_policy: Determines the utilization of instance store volumes. If not defined, instance store volumes will not be used.
|
|
91
|
-
:param pulumi.Input[
|
|
90
|
+
:param pulumi.Input[_builtins.str] key_name: The key pair to attach the instances.
|
|
92
91
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]] load_balancers: Array of load balancer objects to add to ocean cluster
|
|
93
92
|
:param pulumi.Input['OceanLoggingArgs'] logging: Logging configuration.
|
|
94
|
-
:param pulumi.Input[
|
|
95
|
-
:param pulumi.Input[
|
|
96
|
-
:param pulumi.Input[
|
|
97
|
-
:param pulumi.Input[
|
|
98
|
-
:param pulumi.Input[
|
|
99
|
-
:param pulumi.Input[
|
|
93
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
94
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
95
|
+
: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.
|
|
96
|
+
:param pulumi.Input[_builtins.str] name: The cluster name.
|
|
97
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
98
|
+
:param pulumi.Input[_builtins.int] reserved_enis: Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
100
99
|
:param pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]] resource_tag_specifications: Specify which resources should be tagged with Virtual Node Group tags or Ocean tags. If tags are set on the VNG, the resources will be tagged with the VNG tags; otherwise, they will be tagged with the Ocean tags.
|
|
101
|
-
:param pulumi.Input[
|
|
100
|
+
:param pulumi.Input[_builtins.int] root_volume_size: The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
102
101
|
:param pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]] scheduled_tasks: Set scheduling object.
|
|
103
|
-
:param pulumi.Input[
|
|
104
|
-
:param pulumi.Input[
|
|
102
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The desired percentage of Spot instances out of all running instances. Only available when the field is not set in any VNG directly (launchSpec.strategy.spotPercentage).
|
|
103
|
+
:param pulumi.Input[_builtins.str] spread_nodes_by: Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
105
104
|
:param pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]] startup_taints: Temporary taints applied to a node during its initialization phase. For a startup taint to work, it must also be set as a regular taint in the userData for the cluster.
|
|
106
105
|
:param pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
107
|
-
:param pulumi.Input[
|
|
106
|
+
: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.
|
|
108
107
|
When set to true, on Ocean resource creation please make sure your custom VNG has an initial_nodes parameter to create nodes for your VNG.
|
|
109
|
-
:param pulumi.Input[
|
|
110
|
-
:param pulumi.Input[
|
|
111
|
-
:param pulumi.Input[
|
|
108
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
109
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
110
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
112
111
|
"""
|
|
113
112
|
pulumi.set(__self__, "image_id", image_id)
|
|
114
113
|
pulumi.set(__self__, "security_groups", security_groups)
|
|
@@ -196,33 +195,33 @@ class OceanArgs:
|
|
|
196
195
|
if whitelists is not None:
|
|
197
196
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
198
197
|
|
|
199
|
-
@property
|
|
198
|
+
@_builtins.property
|
|
200
199
|
@pulumi.getter(name="imageId")
|
|
201
|
-
def image_id(self) -> pulumi.Input[
|
|
200
|
+
def image_id(self) -> pulumi.Input[_builtins.str]:
|
|
202
201
|
"""
|
|
203
202
|
ID of the image used to launch the instances.
|
|
204
203
|
"""
|
|
205
204
|
return pulumi.get(self, "image_id")
|
|
206
205
|
|
|
207
206
|
@image_id.setter
|
|
208
|
-
def image_id(self, value: pulumi.Input[
|
|
207
|
+
def image_id(self, value: pulumi.Input[_builtins.str]):
|
|
209
208
|
pulumi.set(self, "image_id", value)
|
|
210
209
|
|
|
211
|
-
@property
|
|
210
|
+
@_builtins.property
|
|
212
211
|
@pulumi.getter(name="securityGroups")
|
|
213
|
-
def security_groups(self) -> pulumi.Input[Sequence[pulumi.Input[
|
|
212
|
+
def security_groups(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
214
213
|
"""
|
|
215
214
|
One or more security group ids.
|
|
216
215
|
"""
|
|
217
216
|
return pulumi.get(self, "security_groups")
|
|
218
217
|
|
|
219
218
|
@security_groups.setter
|
|
220
|
-
def security_groups(self, value: pulumi.Input[Sequence[pulumi.Input[
|
|
219
|
+
def security_groups(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
221
220
|
pulumi.set(self, "security_groups", value)
|
|
222
221
|
|
|
223
|
-
@property
|
|
222
|
+
@_builtins.property
|
|
224
223
|
@pulumi.getter(name="subnetIds")
|
|
225
|
-
def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[
|
|
224
|
+
def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
226
225
|
"""
|
|
227
226
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public IP.
|
|
228
227
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
@@ -230,34 +229,34 @@ class OceanArgs:
|
|
|
230
229
|
return pulumi.get(self, "subnet_ids")
|
|
231
230
|
|
|
232
231
|
@subnet_ids.setter
|
|
233
|
-
def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[
|
|
232
|
+
def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
234
233
|
pulumi.set(self, "subnet_ids", value)
|
|
235
234
|
|
|
236
|
-
@property
|
|
235
|
+
@_builtins.property
|
|
237
236
|
@pulumi.getter(name="associateIpv6Address")
|
|
238
|
-
def associate_ipv6_address(self) -> Optional[pulumi.Input[
|
|
237
|
+
def associate_ipv6_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
239
238
|
"""
|
|
240
239
|
Configure IPv6 address allocation.
|
|
241
240
|
"""
|
|
242
241
|
return pulumi.get(self, "associate_ipv6_address")
|
|
243
242
|
|
|
244
243
|
@associate_ipv6_address.setter
|
|
245
|
-
def associate_ipv6_address(self, value: Optional[pulumi.Input[
|
|
244
|
+
def associate_ipv6_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
246
245
|
pulumi.set(self, "associate_ipv6_address", value)
|
|
247
246
|
|
|
248
|
-
@property
|
|
247
|
+
@_builtins.property
|
|
249
248
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
250
|
-
def associate_public_ip_address(self) -> Optional[pulumi.Input[
|
|
249
|
+
def associate_public_ip_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
251
250
|
"""
|
|
252
251
|
Configure public IP address allocation.
|
|
253
252
|
"""
|
|
254
253
|
return pulumi.get(self, "associate_public_ip_address")
|
|
255
254
|
|
|
256
255
|
@associate_public_ip_address.setter
|
|
257
|
-
def associate_public_ip_address(self, value: Optional[pulumi.Input[
|
|
256
|
+
def associate_public_ip_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
258
257
|
pulumi.set(self, "associate_public_ip_address", value)
|
|
259
258
|
|
|
260
|
-
@property
|
|
259
|
+
@_builtins.property
|
|
261
260
|
@pulumi.getter(name="attachLoadBalancers")
|
|
262
261
|
def attach_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]]:
|
|
263
262
|
"""
|
|
@@ -269,7 +268,7 @@ class OceanArgs:
|
|
|
269
268
|
def attach_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]]):
|
|
270
269
|
pulumi.set(self, "attach_load_balancers", value)
|
|
271
270
|
|
|
272
|
-
@property
|
|
271
|
+
@_builtins.property
|
|
273
272
|
@pulumi.getter
|
|
274
273
|
def autoscaler(self) -> Optional[pulumi.Input['OceanAutoscalerArgs']]:
|
|
275
274
|
"""
|
|
@@ -281,16 +280,16 @@ class OceanArgs:
|
|
|
281
280
|
def autoscaler(self, value: Optional[pulumi.Input['OceanAutoscalerArgs']]):
|
|
282
281
|
pulumi.set(self, "autoscaler", value)
|
|
283
282
|
|
|
284
|
-
@property
|
|
283
|
+
@_builtins.property
|
|
285
284
|
@pulumi.getter
|
|
286
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
285
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
287
286
|
return pulumi.get(self, "blacklists")
|
|
288
287
|
|
|
289
288
|
@blacklists.setter
|
|
290
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
289
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
291
290
|
pulumi.set(self, "blacklists", value)
|
|
292
291
|
|
|
293
|
-
@property
|
|
292
|
+
@_builtins.property
|
|
294
293
|
@pulumi.getter(name="blockDeviceMappings")
|
|
295
294
|
def block_device_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]:
|
|
296
295
|
"""
|
|
@@ -302,7 +301,7 @@ class OceanArgs:
|
|
|
302
301
|
def block_device_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]):
|
|
303
302
|
pulumi.set(self, "block_device_mappings", value)
|
|
304
303
|
|
|
305
|
-
@property
|
|
304
|
+
@_builtins.property
|
|
306
305
|
@pulumi.getter(name="clusterOrientations")
|
|
307
306
|
def cluster_orientations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]:
|
|
308
307
|
return pulumi.get(self, "cluster_orientations")
|
|
@@ -311,31 +310,31 @@ class OceanArgs:
|
|
|
311
310
|
def cluster_orientations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]):
|
|
312
311
|
pulumi.set(self, "cluster_orientations", value)
|
|
313
312
|
|
|
314
|
-
@property
|
|
313
|
+
@_builtins.property
|
|
315
314
|
@pulumi.getter(name="controllerId")
|
|
316
|
-
def controller_id(self) -> Optional[pulumi.Input[
|
|
315
|
+
def controller_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
317
316
|
"""
|
|
318
317
|
A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
319
318
|
"""
|
|
320
319
|
return pulumi.get(self, "controller_id")
|
|
321
320
|
|
|
322
321
|
@controller_id.setter
|
|
323
|
-
def controller_id(self, value: Optional[pulumi.Input[
|
|
322
|
+
def controller_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
324
323
|
pulumi.set(self, "controller_id", value)
|
|
325
324
|
|
|
326
|
-
@property
|
|
325
|
+
@_builtins.property
|
|
327
326
|
@pulumi.getter(name="desiredCapacity")
|
|
328
|
-
def desired_capacity(self) -> Optional[pulumi.Input[
|
|
327
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
329
328
|
"""
|
|
330
329
|
The number of instances to launch and maintain in the cluster.
|
|
331
330
|
"""
|
|
332
331
|
return pulumi.get(self, "desired_capacity")
|
|
333
332
|
|
|
334
333
|
@desired_capacity.setter
|
|
335
|
-
def desired_capacity(self, value: Optional[pulumi.Input[
|
|
334
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
336
335
|
pulumi.set(self, "desired_capacity", value)
|
|
337
336
|
|
|
338
|
-
@property
|
|
337
|
+
@_builtins.property
|
|
339
338
|
@pulumi.getter(name="detachLoadBalancers")
|
|
340
339
|
def detach_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]]:
|
|
341
340
|
"""
|
|
@@ -347,43 +346,43 @@ class OceanArgs:
|
|
|
347
346
|
def detach_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]]):
|
|
348
347
|
pulumi.set(self, "detach_load_balancers", value)
|
|
349
348
|
|
|
350
|
-
@property
|
|
349
|
+
@_builtins.property
|
|
351
350
|
@pulumi.getter(name="drainingTimeout")
|
|
352
|
-
def draining_timeout(self) -> Optional[pulumi.Input[
|
|
351
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
353
352
|
"""
|
|
354
353
|
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.
|
|
355
354
|
"""
|
|
356
355
|
return pulumi.get(self, "draining_timeout")
|
|
357
356
|
|
|
358
357
|
@draining_timeout.setter
|
|
359
|
-
def draining_timeout(self, value: Optional[pulumi.Input[
|
|
358
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
360
359
|
pulumi.set(self, "draining_timeout", value)
|
|
361
360
|
|
|
362
|
-
@property
|
|
361
|
+
@_builtins.property
|
|
363
362
|
@pulumi.getter(name="ebsOptimized")
|
|
364
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[
|
|
363
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
365
364
|
"""
|
|
366
365
|
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.
|
|
367
366
|
"""
|
|
368
367
|
return pulumi.get(self, "ebs_optimized")
|
|
369
368
|
|
|
370
369
|
@ebs_optimized.setter
|
|
371
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[
|
|
370
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
372
371
|
pulumi.set(self, "ebs_optimized", value)
|
|
373
372
|
|
|
374
|
-
@property
|
|
373
|
+
@_builtins.property
|
|
375
374
|
@pulumi.getter(name="fallbackToOndemand")
|
|
376
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[
|
|
375
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
377
376
|
"""
|
|
378
377
|
If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
379
378
|
"""
|
|
380
379
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
381
380
|
|
|
382
381
|
@fallback_to_ondemand.setter
|
|
383
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[
|
|
382
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
384
383
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
385
384
|
|
|
386
|
-
@property
|
|
385
|
+
@_builtins.property
|
|
387
386
|
@pulumi.getter
|
|
388
387
|
def filters(self) -> Optional[pulumi.Input['OceanFiltersArgs']]:
|
|
389
388
|
return pulumi.get(self, "filters")
|
|
@@ -392,43 +391,43 @@ class OceanArgs:
|
|
|
392
391
|
def filters(self, value: Optional[pulumi.Input['OceanFiltersArgs']]):
|
|
393
392
|
pulumi.set(self, "filters", value)
|
|
394
393
|
|
|
395
|
-
@property
|
|
394
|
+
@_builtins.property
|
|
396
395
|
@pulumi.getter(name="gracePeriod")
|
|
397
|
-
def grace_period(self) -> Optional[pulumi.Input[
|
|
396
|
+
def grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
398
397
|
"""
|
|
399
398
|
The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
400
399
|
"""
|
|
401
400
|
return pulumi.get(self, "grace_period")
|
|
402
401
|
|
|
403
402
|
@grace_period.setter
|
|
404
|
-
def grace_period(self, value: Optional[pulumi.Input[
|
|
403
|
+
def grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
405
404
|
pulumi.set(self, "grace_period", value)
|
|
406
405
|
|
|
407
|
-
@property
|
|
406
|
+
@_builtins.property
|
|
408
407
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
409
|
-
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[
|
|
408
|
+
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
410
409
|
"""
|
|
411
410
|
The amount of time, in seconds, an existing instance should remain active after becoming unhealthy. After the set time out the instance will be replaced. The minimum value allowed is 60, and it must be a multiple of 60.
|
|
412
411
|
"""
|
|
413
412
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
414
413
|
|
|
415
414
|
@health_check_unhealthy_duration_before_replacement.setter
|
|
416
|
-
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[
|
|
415
|
+
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
417
416
|
pulumi.set(self, "health_check_unhealthy_duration_before_replacement", value)
|
|
418
417
|
|
|
419
|
-
@property
|
|
418
|
+
@_builtins.property
|
|
420
419
|
@pulumi.getter(name="iamInstanceProfile")
|
|
421
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[
|
|
420
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
422
421
|
"""
|
|
423
422
|
The instance profile iam role.
|
|
424
423
|
"""
|
|
425
424
|
return pulumi.get(self, "iam_instance_profile")
|
|
426
425
|
|
|
427
426
|
@iam_instance_profile.setter
|
|
428
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[
|
|
427
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
429
428
|
pulumi.set(self, "iam_instance_profile", value)
|
|
430
429
|
|
|
431
|
-
@property
|
|
430
|
+
@_builtins.property
|
|
432
431
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
433
432
|
def instance_metadata_options(self) -> Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]:
|
|
434
433
|
"""
|
|
@@ -440,7 +439,7 @@ class OceanArgs:
|
|
|
440
439
|
def instance_metadata_options(self, value: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]):
|
|
441
440
|
pulumi.set(self, "instance_metadata_options", value)
|
|
442
441
|
|
|
443
|
-
@property
|
|
442
|
+
@_builtins.property
|
|
444
443
|
@pulumi.getter(name="instanceStorePolicy")
|
|
445
444
|
def instance_store_policy(self) -> Optional[pulumi.Input['OceanInstanceStorePolicyArgs']]:
|
|
446
445
|
"""
|
|
@@ -452,19 +451,19 @@ class OceanArgs:
|
|
|
452
451
|
def instance_store_policy(self, value: Optional[pulumi.Input['OceanInstanceStorePolicyArgs']]):
|
|
453
452
|
pulumi.set(self, "instance_store_policy", value)
|
|
454
453
|
|
|
455
|
-
@property
|
|
454
|
+
@_builtins.property
|
|
456
455
|
@pulumi.getter(name="keyName")
|
|
457
|
-
def key_name(self) -> Optional[pulumi.Input[
|
|
456
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
458
457
|
"""
|
|
459
458
|
The key pair to attach the instances.
|
|
460
459
|
"""
|
|
461
460
|
return pulumi.get(self, "key_name")
|
|
462
461
|
|
|
463
462
|
@key_name.setter
|
|
464
|
-
def key_name(self, value: Optional[pulumi.Input[
|
|
463
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
465
464
|
pulumi.set(self, "key_name", value)
|
|
466
465
|
|
|
467
|
-
@property
|
|
466
|
+
@_builtins.property
|
|
468
467
|
@pulumi.getter(name="loadBalancers")
|
|
469
468
|
def load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]]:
|
|
470
469
|
"""
|
|
@@ -476,7 +475,7 @@ class OceanArgs:
|
|
|
476
475
|
def load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]]):
|
|
477
476
|
pulumi.set(self, "load_balancers", value)
|
|
478
477
|
|
|
479
|
-
@property
|
|
478
|
+
@_builtins.property
|
|
480
479
|
@pulumi.getter
|
|
481
480
|
def logging(self) -> Optional[pulumi.Input['OceanLoggingArgs']]:
|
|
482
481
|
"""
|
|
@@ -488,79 +487,79 @@ class OceanArgs:
|
|
|
488
487
|
def logging(self, value: Optional[pulumi.Input['OceanLoggingArgs']]):
|
|
489
488
|
pulumi.set(self, "logging", value)
|
|
490
489
|
|
|
491
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
492
491
|
@pulumi.getter(name="maxSize")
|
|
493
|
-
def max_size(self) -> Optional[pulumi.Input[
|
|
492
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
494
493
|
"""
|
|
495
494
|
The upper limit of instances the cluster can scale up to.
|
|
496
495
|
"""
|
|
497
496
|
return pulumi.get(self, "max_size")
|
|
498
497
|
|
|
499
498
|
@max_size.setter
|
|
500
|
-
def max_size(self, value: Optional[pulumi.Input[
|
|
499
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
501
500
|
pulumi.set(self, "max_size", value)
|
|
502
501
|
|
|
503
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
504
503
|
@pulumi.getter(name="minSize")
|
|
505
|
-
def min_size(self) -> Optional[pulumi.Input[
|
|
504
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
506
505
|
"""
|
|
507
506
|
The lower limit of instances the cluster can scale down to.
|
|
508
507
|
"""
|
|
509
508
|
return pulumi.get(self, "min_size")
|
|
510
509
|
|
|
511
510
|
@min_size.setter
|
|
512
|
-
def min_size(self, value: Optional[pulumi.Input[
|
|
511
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
513
512
|
pulumi.set(self, "min_size", value)
|
|
514
513
|
|
|
515
|
-
@property
|
|
514
|
+
@_builtins.property
|
|
516
515
|
@pulumi.getter
|
|
517
|
-
def monitoring(self) -> Optional[pulumi.Input[
|
|
516
|
+
def monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
518
517
|
"""
|
|
519
518
|
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.
|
|
520
519
|
"""
|
|
521
520
|
return pulumi.get(self, "monitoring")
|
|
522
521
|
|
|
523
522
|
@monitoring.setter
|
|
524
|
-
def monitoring(self, value: Optional[pulumi.Input[
|
|
523
|
+
def monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
525
524
|
pulumi.set(self, "monitoring", value)
|
|
526
525
|
|
|
527
|
-
@property
|
|
526
|
+
@_builtins.property
|
|
528
527
|
@pulumi.getter
|
|
529
|
-
def name(self) -> Optional[pulumi.Input[
|
|
528
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
530
529
|
"""
|
|
531
530
|
The cluster name.
|
|
532
531
|
"""
|
|
533
532
|
return pulumi.get(self, "name")
|
|
534
533
|
|
|
535
534
|
@name.setter
|
|
536
|
-
def name(self, value: Optional[pulumi.Input[
|
|
535
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
537
536
|
pulumi.set(self, "name", value)
|
|
538
537
|
|
|
539
|
-
@property
|
|
538
|
+
@_builtins.property
|
|
540
539
|
@pulumi.getter
|
|
541
|
-
def region(self) -> Optional[pulumi.Input[
|
|
540
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
542
541
|
"""
|
|
543
542
|
The region the cluster will run in.
|
|
544
543
|
"""
|
|
545
544
|
return pulumi.get(self, "region")
|
|
546
545
|
|
|
547
546
|
@region.setter
|
|
548
|
-
def region(self, value: Optional[pulumi.Input[
|
|
547
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
549
548
|
pulumi.set(self, "region", value)
|
|
550
549
|
|
|
551
|
-
@property
|
|
550
|
+
@_builtins.property
|
|
552
551
|
@pulumi.getter(name="reservedEnis")
|
|
553
|
-
def reserved_enis(self) -> Optional[pulumi.Input[
|
|
552
|
+
def reserved_enis(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
554
553
|
"""
|
|
555
554
|
Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
556
555
|
"""
|
|
557
556
|
return pulumi.get(self, "reserved_enis")
|
|
558
557
|
|
|
559
558
|
@reserved_enis.setter
|
|
560
|
-
def reserved_enis(self, value: Optional[pulumi.Input[
|
|
559
|
+
def reserved_enis(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
561
560
|
pulumi.set(self, "reserved_enis", value)
|
|
562
561
|
|
|
563
|
-
@property
|
|
562
|
+
@_builtins.property
|
|
564
563
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
565
564
|
def resource_tag_specifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]]:
|
|
566
565
|
"""
|
|
@@ -572,19 +571,19 @@ class OceanArgs:
|
|
|
572
571
|
def resource_tag_specifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]]):
|
|
573
572
|
pulumi.set(self, "resource_tag_specifications", value)
|
|
574
573
|
|
|
575
|
-
@property
|
|
574
|
+
@_builtins.property
|
|
576
575
|
@pulumi.getter(name="rootVolumeSize")
|
|
577
|
-
def root_volume_size(self) -> Optional[pulumi.Input[
|
|
576
|
+
def root_volume_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
578
577
|
"""
|
|
579
578
|
The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
580
579
|
"""
|
|
581
580
|
return pulumi.get(self, "root_volume_size")
|
|
582
581
|
|
|
583
582
|
@root_volume_size.setter
|
|
584
|
-
def root_volume_size(self, value: Optional[pulumi.Input[
|
|
583
|
+
def root_volume_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
585
584
|
pulumi.set(self, "root_volume_size", value)
|
|
586
585
|
|
|
587
|
-
@property
|
|
586
|
+
@_builtins.property
|
|
588
587
|
@pulumi.getter(name="scheduledTasks")
|
|
589
588
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]:
|
|
590
589
|
"""
|
|
@@ -596,31 +595,31 @@ class OceanArgs:
|
|
|
596
595
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]):
|
|
597
596
|
pulumi.set(self, "scheduled_tasks", value)
|
|
598
597
|
|
|
599
|
-
@property
|
|
598
|
+
@_builtins.property
|
|
600
599
|
@pulumi.getter(name="spotPercentage")
|
|
601
|
-
def spot_percentage(self) -> Optional[pulumi.Input[
|
|
600
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
602
601
|
"""
|
|
603
602
|
The desired percentage of Spot instances out of all running instances. Only available when the field is not set in any VNG directly (launchSpec.strategy.spotPercentage).
|
|
604
603
|
"""
|
|
605
604
|
return pulumi.get(self, "spot_percentage")
|
|
606
605
|
|
|
607
606
|
@spot_percentage.setter
|
|
608
|
-
def spot_percentage(self, value: Optional[pulumi.Input[
|
|
607
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
609
608
|
pulumi.set(self, "spot_percentage", value)
|
|
610
609
|
|
|
611
|
-
@property
|
|
610
|
+
@_builtins.property
|
|
612
611
|
@pulumi.getter(name="spreadNodesBy")
|
|
613
|
-
def spread_nodes_by(self) -> Optional[pulumi.Input[
|
|
612
|
+
def spread_nodes_by(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
614
613
|
"""
|
|
615
614
|
Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
616
615
|
"""
|
|
617
616
|
return pulumi.get(self, "spread_nodes_by")
|
|
618
617
|
|
|
619
618
|
@spread_nodes_by.setter
|
|
620
|
-
def spread_nodes_by(self, value: Optional[pulumi.Input[
|
|
619
|
+
def spread_nodes_by(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
621
620
|
pulumi.set(self, "spread_nodes_by", value)
|
|
622
621
|
|
|
623
|
-
@property
|
|
622
|
+
@_builtins.property
|
|
624
623
|
@pulumi.getter(name="startupTaints")
|
|
625
624
|
def startup_taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]]:
|
|
626
625
|
"""
|
|
@@ -632,7 +631,7 @@ class OceanArgs:
|
|
|
632
631
|
def startup_taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]]):
|
|
633
632
|
pulumi.set(self, "startup_taints", value)
|
|
634
633
|
|
|
635
|
-
@property
|
|
634
|
+
@_builtins.property
|
|
636
635
|
@pulumi.getter
|
|
637
636
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]:
|
|
638
637
|
"""
|
|
@@ -644,7 +643,7 @@ class OceanArgs:
|
|
|
644
643
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]):
|
|
645
644
|
pulumi.set(self, "tags", value)
|
|
646
645
|
|
|
647
|
-
@property
|
|
646
|
+
@_builtins.property
|
|
648
647
|
@pulumi.getter(name="updatePolicy")
|
|
649
648
|
def update_policy(self) -> Optional[pulumi.Input['OceanUpdatePolicyArgs']]:
|
|
650
649
|
return pulumi.get(self, "update_policy")
|
|
@@ -653,9 +652,9 @@ class OceanArgs:
|
|
|
653
652
|
def update_policy(self, value: Optional[pulumi.Input['OceanUpdatePolicyArgs']]):
|
|
654
653
|
pulumi.set(self, "update_policy", value)
|
|
655
654
|
|
|
656
|
-
@property
|
|
655
|
+
@_builtins.property
|
|
657
656
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
658
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[
|
|
657
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
659
658
|
"""
|
|
660
659
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
661
660
|
When set to true, on Ocean resource creation please make sure your custom VNG has an initial_nodes parameter to create nodes for your VNG.
|
|
@@ -663,145 +662,145 @@ class OceanArgs:
|
|
|
663
662
|
return pulumi.get(self, "use_as_template_only")
|
|
664
663
|
|
|
665
664
|
@use_as_template_only.setter
|
|
666
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[
|
|
665
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
667
666
|
pulumi.set(self, "use_as_template_only", value)
|
|
668
667
|
|
|
669
|
-
@property
|
|
668
|
+
@_builtins.property
|
|
670
669
|
@pulumi.getter(name="userData")
|
|
671
|
-
def user_data(self) -> Optional[pulumi.Input[
|
|
670
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
672
671
|
"""
|
|
673
672
|
Base64-encoded MIME user data to make available to the instances.
|
|
674
673
|
"""
|
|
675
674
|
return pulumi.get(self, "user_data")
|
|
676
675
|
|
|
677
676
|
@user_data.setter
|
|
678
|
-
def user_data(self, value: Optional[pulumi.Input[
|
|
677
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
679
678
|
pulumi.set(self, "user_data", value)
|
|
680
679
|
|
|
681
|
-
@property
|
|
680
|
+
@_builtins.property
|
|
682
681
|
@pulumi.getter(name="utilizeCommitments")
|
|
683
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[
|
|
682
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
684
683
|
"""
|
|
685
684
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
686
685
|
"""
|
|
687
686
|
return pulumi.get(self, "utilize_commitments")
|
|
688
687
|
|
|
689
688
|
@utilize_commitments.setter
|
|
690
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[
|
|
689
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
691
690
|
pulumi.set(self, "utilize_commitments", value)
|
|
692
691
|
|
|
693
|
-
@property
|
|
692
|
+
@_builtins.property
|
|
694
693
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
695
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[
|
|
694
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
696
695
|
"""
|
|
697
696
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
698
697
|
"""
|
|
699
698
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
700
699
|
|
|
701
700
|
@utilize_reserved_instances.setter
|
|
702
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[
|
|
701
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
703
702
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
704
703
|
|
|
705
|
-
@property
|
|
704
|
+
@_builtins.property
|
|
706
705
|
@pulumi.getter
|
|
707
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
706
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
708
707
|
return pulumi.get(self, "whitelists")
|
|
709
708
|
|
|
710
709
|
@whitelists.setter
|
|
711
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
710
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
712
711
|
pulumi.set(self, "whitelists", value)
|
|
713
712
|
|
|
714
713
|
|
|
715
714
|
@pulumi.input_type
|
|
716
715
|
class _OceanState:
|
|
717
716
|
def __init__(__self__, *,
|
|
718
|
-
associate_ipv6_address: Optional[pulumi.Input[
|
|
719
|
-
associate_public_ip_address: Optional[pulumi.Input[
|
|
717
|
+
associate_ipv6_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
718
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
720
719
|
attach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]] = None,
|
|
721
720
|
autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
|
|
722
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
721
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
723
722
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
|
|
724
723
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
|
|
725
|
-
controller_id: Optional[pulumi.Input[
|
|
726
|
-
desired_capacity: Optional[pulumi.Input[
|
|
724
|
+
controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
725
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
727
726
|
detach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]] = None,
|
|
728
|
-
draining_timeout: Optional[pulumi.Input[
|
|
729
|
-
ebs_optimized: Optional[pulumi.Input[
|
|
730
|
-
fallback_to_ondemand: Optional[pulumi.Input[
|
|
727
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
728
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
729
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
731
730
|
filters: Optional[pulumi.Input['OceanFiltersArgs']] = None,
|
|
732
|
-
grace_period: Optional[pulumi.Input[
|
|
733
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[
|
|
734
|
-
iam_instance_profile: Optional[pulumi.Input[
|
|
735
|
-
image_id: Optional[pulumi.Input[
|
|
731
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
732
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
733
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
734
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
736
735
|
instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
|
|
737
736
|
instance_store_policy: Optional[pulumi.Input['OceanInstanceStorePolicyArgs']] = None,
|
|
738
|
-
key_name: Optional[pulumi.Input[
|
|
737
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
739
738
|
load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]] = None,
|
|
740
739
|
logging: Optional[pulumi.Input['OceanLoggingArgs']] = None,
|
|
741
|
-
max_size: Optional[pulumi.Input[
|
|
742
|
-
min_size: Optional[pulumi.Input[
|
|
743
|
-
monitoring: Optional[pulumi.Input[
|
|
744
|
-
name: Optional[pulumi.Input[
|
|
745
|
-
region: Optional[pulumi.Input[
|
|
746
|
-
reserved_enis: Optional[pulumi.Input[
|
|
740
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
741
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
742
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
743
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
744
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
745
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
747
746
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]] = None,
|
|
748
|
-
root_volume_size: Optional[pulumi.Input[
|
|
747
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
749
748
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
|
|
750
|
-
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
751
|
-
spot_percentage: Optional[pulumi.Input[
|
|
752
|
-
spread_nodes_by: Optional[pulumi.Input[
|
|
749
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
750
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
751
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
753
752
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]] = None,
|
|
754
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
753
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
755
754
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
|
|
756
755
|
update_policy: Optional[pulumi.Input['OceanUpdatePolicyArgs']] = None,
|
|
757
|
-
use_as_template_only: Optional[pulumi.Input[
|
|
758
|
-
user_data: Optional[pulumi.Input[
|
|
759
|
-
utilize_commitments: Optional[pulumi.Input[
|
|
760
|
-
utilize_reserved_instances: Optional[pulumi.Input[
|
|
761
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
756
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
757
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
758
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
759
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
760
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
762
761
|
"""
|
|
763
762
|
Input properties used for looking up and filtering Ocean resources.
|
|
764
|
-
:param pulumi.Input[
|
|
765
|
-
:param pulumi.Input[
|
|
763
|
+
:param pulumi.Input[_builtins.bool] associate_ipv6_address: Configure IPv6 address allocation.
|
|
764
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
766
765
|
:param pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]] attach_load_balancers: Attach load balancers to the cluster.
|
|
767
766
|
:param pulumi.Input['OceanAutoscalerArgs'] autoscaler: Describes the Ocean Kubernetes Auto Scaler.
|
|
768
767
|
:param pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]] block_device_mappings: Object. Array list of block devices that are exposed to the instance, specify either virtual devices and EBS volumes.
|
|
769
|
-
:param pulumi.Input[
|
|
770
|
-
:param pulumi.Input[
|
|
768
|
+
:param pulumi.Input[_builtins.str] controller_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
769
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
771
770
|
:param pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]] detach_load_balancers: Detach load balancers from the cluster.
|
|
772
|
-
:param pulumi.Input[
|
|
773
|
-
:param pulumi.Input[
|
|
774
|
-
:param pulumi.Input[
|
|
775
|
-
:param pulumi.Input[
|
|
776
|
-
:param pulumi.Input[
|
|
777
|
-
:param pulumi.Input[
|
|
778
|
-
:param pulumi.Input[
|
|
771
|
+
: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.
|
|
772
|
+
: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.
|
|
773
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
774
|
+
:param pulumi.Input[_builtins.int] grace_period: The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
775
|
+
:param pulumi.Input[_builtins.int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, an existing instance should remain active after becoming unhealthy. After the set time out the instance will be replaced. The minimum value allowed is 60, and it must be a multiple of 60.
|
|
776
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
777
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
779
778
|
:param pulumi.Input['OceanInstanceMetadataOptionsArgs'] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
780
779
|
:param pulumi.Input['OceanInstanceStorePolicyArgs'] instance_store_policy: Determines the utilization of instance store volumes. If not defined, instance store volumes will not be used.
|
|
781
|
-
:param pulumi.Input[
|
|
780
|
+
:param pulumi.Input[_builtins.str] key_name: The key pair to attach the instances.
|
|
782
781
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]] load_balancers: Array of load balancer objects to add to ocean cluster
|
|
783
782
|
:param pulumi.Input['OceanLoggingArgs'] logging: Logging configuration.
|
|
784
|
-
:param pulumi.Input[
|
|
785
|
-
:param pulumi.Input[
|
|
786
|
-
:param pulumi.Input[
|
|
787
|
-
:param pulumi.Input[
|
|
788
|
-
:param pulumi.Input[
|
|
789
|
-
:param pulumi.Input[
|
|
783
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
784
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
785
|
+
: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.
|
|
786
|
+
:param pulumi.Input[_builtins.str] name: The cluster name.
|
|
787
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
788
|
+
:param pulumi.Input[_builtins.int] reserved_enis: Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
790
789
|
:param pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]] resource_tag_specifications: Specify which resources should be tagged with Virtual Node Group tags or Ocean tags. If tags are set on the VNG, the resources will be tagged with the VNG tags; otherwise, they will be tagged with the Ocean tags.
|
|
791
|
-
:param pulumi.Input[
|
|
790
|
+
:param pulumi.Input[_builtins.int] root_volume_size: The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
792
791
|
:param pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]] scheduled_tasks: Set scheduling object.
|
|
793
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
794
|
-
:param pulumi.Input[
|
|
795
|
-
:param pulumi.Input[
|
|
792
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: One or more security group ids.
|
|
793
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The desired percentage of Spot instances out of all running instances. Only available when the field is not set in any VNG directly (launchSpec.strategy.spotPercentage).
|
|
794
|
+
:param pulumi.Input[_builtins.str] spread_nodes_by: Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
796
795
|
:param pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]] startup_taints: Temporary taints applied to a node during its initialization phase. For a startup taint to work, it must also be set as a regular taint in the userData for the cluster.
|
|
797
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
796
|
+
: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.
|
|
798
797
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
799
798
|
:param pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
800
|
-
:param pulumi.Input[
|
|
799
|
+
: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.
|
|
801
800
|
When set to true, on Ocean resource creation please make sure your custom VNG has an initial_nodes parameter to create nodes for your VNG.
|
|
802
|
-
:param pulumi.Input[
|
|
803
|
-
:param pulumi.Input[
|
|
804
|
-
:param pulumi.Input[
|
|
801
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
802
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
803
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
805
804
|
"""
|
|
806
805
|
if associate_ipv6_address is not None:
|
|
807
806
|
pulumi.set(__self__, "associate_ipv6_address", associate_ipv6_address)
|
|
@@ -892,31 +891,31 @@ class _OceanState:
|
|
|
892
891
|
if whitelists is not None:
|
|
893
892
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
894
893
|
|
|
895
|
-
@property
|
|
894
|
+
@_builtins.property
|
|
896
895
|
@pulumi.getter(name="associateIpv6Address")
|
|
897
|
-
def associate_ipv6_address(self) -> Optional[pulumi.Input[
|
|
896
|
+
def associate_ipv6_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
898
897
|
"""
|
|
899
898
|
Configure IPv6 address allocation.
|
|
900
899
|
"""
|
|
901
900
|
return pulumi.get(self, "associate_ipv6_address")
|
|
902
901
|
|
|
903
902
|
@associate_ipv6_address.setter
|
|
904
|
-
def associate_ipv6_address(self, value: Optional[pulumi.Input[
|
|
903
|
+
def associate_ipv6_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
905
904
|
pulumi.set(self, "associate_ipv6_address", value)
|
|
906
905
|
|
|
907
|
-
@property
|
|
906
|
+
@_builtins.property
|
|
908
907
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
909
|
-
def associate_public_ip_address(self) -> Optional[pulumi.Input[
|
|
908
|
+
def associate_public_ip_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
910
909
|
"""
|
|
911
910
|
Configure public IP address allocation.
|
|
912
911
|
"""
|
|
913
912
|
return pulumi.get(self, "associate_public_ip_address")
|
|
914
913
|
|
|
915
914
|
@associate_public_ip_address.setter
|
|
916
|
-
def associate_public_ip_address(self, value: Optional[pulumi.Input[
|
|
915
|
+
def associate_public_ip_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
917
916
|
pulumi.set(self, "associate_public_ip_address", value)
|
|
918
917
|
|
|
919
|
-
@property
|
|
918
|
+
@_builtins.property
|
|
920
919
|
@pulumi.getter(name="attachLoadBalancers")
|
|
921
920
|
def attach_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]]:
|
|
922
921
|
"""
|
|
@@ -928,7 +927,7 @@ class _OceanState:
|
|
|
928
927
|
def attach_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]]):
|
|
929
928
|
pulumi.set(self, "attach_load_balancers", value)
|
|
930
929
|
|
|
931
|
-
@property
|
|
930
|
+
@_builtins.property
|
|
932
931
|
@pulumi.getter
|
|
933
932
|
def autoscaler(self) -> Optional[pulumi.Input['OceanAutoscalerArgs']]:
|
|
934
933
|
"""
|
|
@@ -940,16 +939,16 @@ class _OceanState:
|
|
|
940
939
|
def autoscaler(self, value: Optional[pulumi.Input['OceanAutoscalerArgs']]):
|
|
941
940
|
pulumi.set(self, "autoscaler", value)
|
|
942
941
|
|
|
943
|
-
@property
|
|
942
|
+
@_builtins.property
|
|
944
943
|
@pulumi.getter
|
|
945
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
944
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
946
945
|
return pulumi.get(self, "blacklists")
|
|
947
946
|
|
|
948
947
|
@blacklists.setter
|
|
949
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
948
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
950
949
|
pulumi.set(self, "blacklists", value)
|
|
951
950
|
|
|
952
|
-
@property
|
|
951
|
+
@_builtins.property
|
|
953
952
|
@pulumi.getter(name="blockDeviceMappings")
|
|
954
953
|
def block_device_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]:
|
|
955
954
|
"""
|
|
@@ -961,7 +960,7 @@ class _OceanState:
|
|
|
961
960
|
def block_device_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]):
|
|
962
961
|
pulumi.set(self, "block_device_mappings", value)
|
|
963
962
|
|
|
964
|
-
@property
|
|
963
|
+
@_builtins.property
|
|
965
964
|
@pulumi.getter(name="clusterOrientations")
|
|
966
965
|
def cluster_orientations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]:
|
|
967
966
|
return pulumi.get(self, "cluster_orientations")
|
|
@@ -970,31 +969,31 @@ class _OceanState:
|
|
|
970
969
|
def cluster_orientations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]):
|
|
971
970
|
pulumi.set(self, "cluster_orientations", value)
|
|
972
971
|
|
|
973
|
-
@property
|
|
972
|
+
@_builtins.property
|
|
974
973
|
@pulumi.getter(name="controllerId")
|
|
975
|
-
def controller_id(self) -> Optional[pulumi.Input[
|
|
974
|
+
def controller_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
976
975
|
"""
|
|
977
976
|
A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
978
977
|
"""
|
|
979
978
|
return pulumi.get(self, "controller_id")
|
|
980
979
|
|
|
981
980
|
@controller_id.setter
|
|
982
|
-
def controller_id(self, value: Optional[pulumi.Input[
|
|
981
|
+
def controller_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
983
982
|
pulumi.set(self, "controller_id", value)
|
|
984
983
|
|
|
985
|
-
@property
|
|
984
|
+
@_builtins.property
|
|
986
985
|
@pulumi.getter(name="desiredCapacity")
|
|
987
|
-
def desired_capacity(self) -> Optional[pulumi.Input[
|
|
986
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
988
987
|
"""
|
|
989
988
|
The number of instances to launch and maintain in the cluster.
|
|
990
989
|
"""
|
|
991
990
|
return pulumi.get(self, "desired_capacity")
|
|
992
991
|
|
|
993
992
|
@desired_capacity.setter
|
|
994
|
-
def desired_capacity(self, value: Optional[pulumi.Input[
|
|
993
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
995
994
|
pulumi.set(self, "desired_capacity", value)
|
|
996
995
|
|
|
997
|
-
@property
|
|
996
|
+
@_builtins.property
|
|
998
997
|
@pulumi.getter(name="detachLoadBalancers")
|
|
999
998
|
def detach_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]]:
|
|
1000
999
|
"""
|
|
@@ -1006,43 +1005,43 @@ class _OceanState:
|
|
|
1006
1005
|
def detach_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]]):
|
|
1007
1006
|
pulumi.set(self, "detach_load_balancers", value)
|
|
1008
1007
|
|
|
1009
|
-
@property
|
|
1008
|
+
@_builtins.property
|
|
1010
1009
|
@pulumi.getter(name="drainingTimeout")
|
|
1011
|
-
def draining_timeout(self) -> Optional[pulumi.Input[
|
|
1010
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1012
1011
|
"""
|
|
1013
1012
|
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.
|
|
1014
1013
|
"""
|
|
1015
1014
|
return pulumi.get(self, "draining_timeout")
|
|
1016
1015
|
|
|
1017
1016
|
@draining_timeout.setter
|
|
1018
|
-
def draining_timeout(self, value: Optional[pulumi.Input[
|
|
1017
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1019
1018
|
pulumi.set(self, "draining_timeout", value)
|
|
1020
1019
|
|
|
1021
|
-
@property
|
|
1020
|
+
@_builtins.property
|
|
1022
1021
|
@pulumi.getter(name="ebsOptimized")
|
|
1023
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[
|
|
1022
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1024
1023
|
"""
|
|
1025
1024
|
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.
|
|
1026
1025
|
"""
|
|
1027
1026
|
return pulumi.get(self, "ebs_optimized")
|
|
1028
1027
|
|
|
1029
1028
|
@ebs_optimized.setter
|
|
1030
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[
|
|
1029
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1031
1030
|
pulumi.set(self, "ebs_optimized", value)
|
|
1032
1031
|
|
|
1033
|
-
@property
|
|
1032
|
+
@_builtins.property
|
|
1034
1033
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1035
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[
|
|
1034
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1036
1035
|
"""
|
|
1037
1036
|
If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1038
1037
|
"""
|
|
1039
1038
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1040
1039
|
|
|
1041
1040
|
@fallback_to_ondemand.setter
|
|
1042
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[
|
|
1041
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1043
1042
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
1044
1043
|
|
|
1045
|
-
@property
|
|
1044
|
+
@_builtins.property
|
|
1046
1045
|
@pulumi.getter
|
|
1047
1046
|
def filters(self) -> Optional[pulumi.Input['OceanFiltersArgs']]:
|
|
1048
1047
|
return pulumi.get(self, "filters")
|
|
@@ -1051,55 +1050,55 @@ class _OceanState:
|
|
|
1051
1050
|
def filters(self, value: Optional[pulumi.Input['OceanFiltersArgs']]):
|
|
1052
1051
|
pulumi.set(self, "filters", value)
|
|
1053
1052
|
|
|
1054
|
-
@property
|
|
1053
|
+
@_builtins.property
|
|
1055
1054
|
@pulumi.getter(name="gracePeriod")
|
|
1056
|
-
def grace_period(self) -> Optional[pulumi.Input[
|
|
1055
|
+
def grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1057
1056
|
"""
|
|
1058
1057
|
The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
1059
1058
|
"""
|
|
1060
1059
|
return pulumi.get(self, "grace_period")
|
|
1061
1060
|
|
|
1062
1061
|
@grace_period.setter
|
|
1063
|
-
def grace_period(self, value: Optional[pulumi.Input[
|
|
1062
|
+
def grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1064
1063
|
pulumi.set(self, "grace_period", value)
|
|
1065
1064
|
|
|
1066
|
-
@property
|
|
1065
|
+
@_builtins.property
|
|
1067
1066
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
1068
|
-
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[
|
|
1067
|
+
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1069
1068
|
"""
|
|
1070
1069
|
The amount of time, in seconds, an existing instance should remain active after becoming unhealthy. After the set time out the instance will be replaced. The minimum value allowed is 60, and it must be a multiple of 60.
|
|
1071
1070
|
"""
|
|
1072
1071
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
1073
1072
|
|
|
1074
1073
|
@health_check_unhealthy_duration_before_replacement.setter
|
|
1075
|
-
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[
|
|
1074
|
+
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1076
1075
|
pulumi.set(self, "health_check_unhealthy_duration_before_replacement", value)
|
|
1077
1076
|
|
|
1078
|
-
@property
|
|
1077
|
+
@_builtins.property
|
|
1079
1078
|
@pulumi.getter(name="iamInstanceProfile")
|
|
1080
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[
|
|
1079
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1081
1080
|
"""
|
|
1082
1081
|
The instance profile iam role.
|
|
1083
1082
|
"""
|
|
1084
1083
|
return pulumi.get(self, "iam_instance_profile")
|
|
1085
1084
|
|
|
1086
1085
|
@iam_instance_profile.setter
|
|
1087
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[
|
|
1086
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1088
1087
|
pulumi.set(self, "iam_instance_profile", value)
|
|
1089
1088
|
|
|
1090
|
-
@property
|
|
1089
|
+
@_builtins.property
|
|
1091
1090
|
@pulumi.getter(name="imageId")
|
|
1092
|
-
def image_id(self) -> Optional[pulumi.Input[
|
|
1091
|
+
def image_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1093
1092
|
"""
|
|
1094
1093
|
ID of the image used to launch the instances.
|
|
1095
1094
|
"""
|
|
1096
1095
|
return pulumi.get(self, "image_id")
|
|
1097
1096
|
|
|
1098
1097
|
@image_id.setter
|
|
1099
|
-
def image_id(self, value: Optional[pulumi.Input[
|
|
1098
|
+
def image_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1100
1099
|
pulumi.set(self, "image_id", value)
|
|
1101
1100
|
|
|
1102
|
-
@property
|
|
1101
|
+
@_builtins.property
|
|
1103
1102
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
1104
1103
|
def instance_metadata_options(self) -> Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]:
|
|
1105
1104
|
"""
|
|
@@ -1111,7 +1110,7 @@ class _OceanState:
|
|
|
1111
1110
|
def instance_metadata_options(self, value: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]):
|
|
1112
1111
|
pulumi.set(self, "instance_metadata_options", value)
|
|
1113
1112
|
|
|
1114
|
-
@property
|
|
1113
|
+
@_builtins.property
|
|
1115
1114
|
@pulumi.getter(name="instanceStorePolicy")
|
|
1116
1115
|
def instance_store_policy(self) -> Optional[pulumi.Input['OceanInstanceStorePolicyArgs']]:
|
|
1117
1116
|
"""
|
|
@@ -1123,19 +1122,19 @@ class _OceanState:
|
|
|
1123
1122
|
def instance_store_policy(self, value: Optional[pulumi.Input['OceanInstanceStorePolicyArgs']]):
|
|
1124
1123
|
pulumi.set(self, "instance_store_policy", value)
|
|
1125
1124
|
|
|
1126
|
-
@property
|
|
1125
|
+
@_builtins.property
|
|
1127
1126
|
@pulumi.getter(name="keyName")
|
|
1128
|
-
def key_name(self) -> Optional[pulumi.Input[
|
|
1127
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1129
1128
|
"""
|
|
1130
1129
|
The key pair to attach the instances.
|
|
1131
1130
|
"""
|
|
1132
1131
|
return pulumi.get(self, "key_name")
|
|
1133
1132
|
|
|
1134
1133
|
@key_name.setter
|
|
1135
|
-
def key_name(self, value: Optional[pulumi.Input[
|
|
1134
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1136
1135
|
pulumi.set(self, "key_name", value)
|
|
1137
1136
|
|
|
1138
|
-
@property
|
|
1137
|
+
@_builtins.property
|
|
1139
1138
|
@pulumi.getter(name="loadBalancers")
|
|
1140
1139
|
def load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]]:
|
|
1141
1140
|
"""
|
|
@@ -1147,7 +1146,7 @@ class _OceanState:
|
|
|
1147
1146
|
def load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]]):
|
|
1148
1147
|
pulumi.set(self, "load_balancers", value)
|
|
1149
1148
|
|
|
1150
|
-
@property
|
|
1149
|
+
@_builtins.property
|
|
1151
1150
|
@pulumi.getter
|
|
1152
1151
|
def logging(self) -> Optional[pulumi.Input['OceanLoggingArgs']]:
|
|
1153
1152
|
"""
|
|
@@ -1159,79 +1158,79 @@ class _OceanState:
|
|
|
1159
1158
|
def logging(self, value: Optional[pulumi.Input['OceanLoggingArgs']]):
|
|
1160
1159
|
pulumi.set(self, "logging", value)
|
|
1161
1160
|
|
|
1162
|
-
@property
|
|
1161
|
+
@_builtins.property
|
|
1163
1162
|
@pulumi.getter(name="maxSize")
|
|
1164
|
-
def max_size(self) -> Optional[pulumi.Input[
|
|
1163
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1165
1164
|
"""
|
|
1166
1165
|
The upper limit of instances the cluster can scale up to.
|
|
1167
1166
|
"""
|
|
1168
1167
|
return pulumi.get(self, "max_size")
|
|
1169
1168
|
|
|
1170
1169
|
@max_size.setter
|
|
1171
|
-
def max_size(self, value: Optional[pulumi.Input[
|
|
1170
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1172
1171
|
pulumi.set(self, "max_size", value)
|
|
1173
1172
|
|
|
1174
|
-
@property
|
|
1173
|
+
@_builtins.property
|
|
1175
1174
|
@pulumi.getter(name="minSize")
|
|
1176
|
-
def min_size(self) -> Optional[pulumi.Input[
|
|
1175
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1177
1176
|
"""
|
|
1178
1177
|
The lower limit of instances the cluster can scale down to.
|
|
1179
1178
|
"""
|
|
1180
1179
|
return pulumi.get(self, "min_size")
|
|
1181
1180
|
|
|
1182
1181
|
@min_size.setter
|
|
1183
|
-
def min_size(self, value: Optional[pulumi.Input[
|
|
1182
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1184
1183
|
pulumi.set(self, "min_size", value)
|
|
1185
1184
|
|
|
1186
|
-
@property
|
|
1185
|
+
@_builtins.property
|
|
1187
1186
|
@pulumi.getter
|
|
1188
|
-
def monitoring(self) -> Optional[pulumi.Input[
|
|
1187
|
+
def monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1189
1188
|
"""
|
|
1190
1189
|
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.
|
|
1191
1190
|
"""
|
|
1192
1191
|
return pulumi.get(self, "monitoring")
|
|
1193
1192
|
|
|
1194
1193
|
@monitoring.setter
|
|
1195
|
-
def monitoring(self, value: Optional[pulumi.Input[
|
|
1194
|
+
def monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1196
1195
|
pulumi.set(self, "monitoring", value)
|
|
1197
1196
|
|
|
1198
|
-
@property
|
|
1197
|
+
@_builtins.property
|
|
1199
1198
|
@pulumi.getter
|
|
1200
|
-
def name(self) -> Optional[pulumi.Input[
|
|
1199
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1201
1200
|
"""
|
|
1202
1201
|
The cluster name.
|
|
1203
1202
|
"""
|
|
1204
1203
|
return pulumi.get(self, "name")
|
|
1205
1204
|
|
|
1206
1205
|
@name.setter
|
|
1207
|
-
def name(self, value: Optional[pulumi.Input[
|
|
1206
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1208
1207
|
pulumi.set(self, "name", value)
|
|
1209
1208
|
|
|
1210
|
-
@property
|
|
1209
|
+
@_builtins.property
|
|
1211
1210
|
@pulumi.getter
|
|
1212
|
-
def region(self) -> Optional[pulumi.Input[
|
|
1211
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1213
1212
|
"""
|
|
1214
1213
|
The region the cluster will run in.
|
|
1215
1214
|
"""
|
|
1216
1215
|
return pulumi.get(self, "region")
|
|
1217
1216
|
|
|
1218
1217
|
@region.setter
|
|
1219
|
-
def region(self, value: Optional[pulumi.Input[
|
|
1218
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1220
1219
|
pulumi.set(self, "region", value)
|
|
1221
1220
|
|
|
1222
|
-
@property
|
|
1221
|
+
@_builtins.property
|
|
1223
1222
|
@pulumi.getter(name="reservedEnis")
|
|
1224
|
-
def reserved_enis(self) -> Optional[pulumi.Input[
|
|
1223
|
+
def reserved_enis(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1225
1224
|
"""
|
|
1226
1225
|
Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
1227
1226
|
"""
|
|
1228
1227
|
return pulumi.get(self, "reserved_enis")
|
|
1229
1228
|
|
|
1230
1229
|
@reserved_enis.setter
|
|
1231
|
-
def reserved_enis(self, value: Optional[pulumi.Input[
|
|
1230
|
+
def reserved_enis(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1232
1231
|
pulumi.set(self, "reserved_enis", value)
|
|
1233
1232
|
|
|
1234
|
-
@property
|
|
1233
|
+
@_builtins.property
|
|
1235
1234
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
1236
1235
|
def resource_tag_specifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]]:
|
|
1237
1236
|
"""
|
|
@@ -1243,19 +1242,19 @@ class _OceanState:
|
|
|
1243
1242
|
def resource_tag_specifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]]):
|
|
1244
1243
|
pulumi.set(self, "resource_tag_specifications", value)
|
|
1245
1244
|
|
|
1246
|
-
@property
|
|
1245
|
+
@_builtins.property
|
|
1247
1246
|
@pulumi.getter(name="rootVolumeSize")
|
|
1248
|
-
def root_volume_size(self) -> Optional[pulumi.Input[
|
|
1247
|
+
def root_volume_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1249
1248
|
"""
|
|
1250
1249
|
The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
1251
1250
|
"""
|
|
1252
1251
|
return pulumi.get(self, "root_volume_size")
|
|
1253
1252
|
|
|
1254
1253
|
@root_volume_size.setter
|
|
1255
|
-
def root_volume_size(self, value: Optional[pulumi.Input[
|
|
1254
|
+
def root_volume_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1256
1255
|
pulumi.set(self, "root_volume_size", value)
|
|
1257
1256
|
|
|
1258
|
-
@property
|
|
1257
|
+
@_builtins.property
|
|
1259
1258
|
@pulumi.getter(name="scheduledTasks")
|
|
1260
1259
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]:
|
|
1261
1260
|
"""
|
|
@@ -1267,43 +1266,43 @@ class _OceanState:
|
|
|
1267
1266
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]):
|
|
1268
1267
|
pulumi.set(self, "scheduled_tasks", value)
|
|
1269
1268
|
|
|
1270
|
-
@property
|
|
1269
|
+
@_builtins.property
|
|
1271
1270
|
@pulumi.getter(name="securityGroups")
|
|
1272
|
-
def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1271
|
+
def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1273
1272
|
"""
|
|
1274
1273
|
One or more security group ids.
|
|
1275
1274
|
"""
|
|
1276
1275
|
return pulumi.get(self, "security_groups")
|
|
1277
1276
|
|
|
1278
1277
|
@security_groups.setter
|
|
1279
|
-
def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1278
|
+
def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1280
1279
|
pulumi.set(self, "security_groups", value)
|
|
1281
1280
|
|
|
1282
|
-
@property
|
|
1281
|
+
@_builtins.property
|
|
1283
1282
|
@pulumi.getter(name="spotPercentage")
|
|
1284
|
-
def spot_percentage(self) -> Optional[pulumi.Input[
|
|
1283
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1285
1284
|
"""
|
|
1286
1285
|
The desired percentage of Spot instances out of all running instances. Only available when the field is not set in any VNG directly (launchSpec.strategy.spotPercentage).
|
|
1287
1286
|
"""
|
|
1288
1287
|
return pulumi.get(self, "spot_percentage")
|
|
1289
1288
|
|
|
1290
1289
|
@spot_percentage.setter
|
|
1291
|
-
def spot_percentage(self, value: Optional[pulumi.Input[
|
|
1290
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1292
1291
|
pulumi.set(self, "spot_percentage", value)
|
|
1293
1292
|
|
|
1294
|
-
@property
|
|
1293
|
+
@_builtins.property
|
|
1295
1294
|
@pulumi.getter(name="spreadNodesBy")
|
|
1296
|
-
def spread_nodes_by(self) -> Optional[pulumi.Input[
|
|
1295
|
+
def spread_nodes_by(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1297
1296
|
"""
|
|
1298
1297
|
Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
1299
1298
|
"""
|
|
1300
1299
|
return pulumi.get(self, "spread_nodes_by")
|
|
1301
1300
|
|
|
1302
1301
|
@spread_nodes_by.setter
|
|
1303
|
-
def spread_nodes_by(self, value: Optional[pulumi.Input[
|
|
1302
|
+
def spread_nodes_by(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1304
1303
|
pulumi.set(self, "spread_nodes_by", value)
|
|
1305
1304
|
|
|
1306
|
-
@property
|
|
1305
|
+
@_builtins.property
|
|
1307
1306
|
@pulumi.getter(name="startupTaints")
|
|
1308
1307
|
def startup_taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]]:
|
|
1309
1308
|
"""
|
|
@@ -1315,9 +1314,9 @@ class _OceanState:
|
|
|
1315
1314
|
def startup_taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]]):
|
|
1316
1315
|
pulumi.set(self, "startup_taints", value)
|
|
1317
1316
|
|
|
1318
|
-
@property
|
|
1317
|
+
@_builtins.property
|
|
1319
1318
|
@pulumi.getter(name="subnetIds")
|
|
1320
|
-
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1319
|
+
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1321
1320
|
"""
|
|
1322
1321
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public IP.
|
|
1323
1322
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
@@ -1325,10 +1324,10 @@ class _OceanState:
|
|
|
1325
1324
|
return pulumi.get(self, "subnet_ids")
|
|
1326
1325
|
|
|
1327
1326
|
@subnet_ids.setter
|
|
1328
|
-
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1327
|
+
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1329
1328
|
pulumi.set(self, "subnet_ids", value)
|
|
1330
1329
|
|
|
1331
|
-
@property
|
|
1330
|
+
@_builtins.property
|
|
1332
1331
|
@pulumi.getter
|
|
1333
1332
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]:
|
|
1334
1333
|
"""
|
|
@@ -1340,7 +1339,7 @@ class _OceanState:
|
|
|
1340
1339
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]):
|
|
1341
1340
|
pulumi.set(self, "tags", value)
|
|
1342
1341
|
|
|
1343
|
-
@property
|
|
1342
|
+
@_builtins.property
|
|
1344
1343
|
@pulumi.getter(name="updatePolicy")
|
|
1345
1344
|
def update_policy(self) -> Optional[pulumi.Input['OceanUpdatePolicyArgs']]:
|
|
1346
1345
|
return pulumi.get(self, "update_policy")
|
|
@@ -1349,9 +1348,9 @@ class _OceanState:
|
|
|
1349
1348
|
def update_policy(self, value: Optional[pulumi.Input['OceanUpdatePolicyArgs']]):
|
|
1350
1349
|
pulumi.set(self, "update_policy", value)
|
|
1351
1350
|
|
|
1352
|
-
@property
|
|
1351
|
+
@_builtins.property
|
|
1353
1352
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
1354
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[
|
|
1353
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1355
1354
|
"""
|
|
1356
1355
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
1357
1356
|
When set to true, on Ocean resource creation please make sure your custom VNG has an initial_nodes parameter to create nodes for your VNG.
|
|
@@ -1359,52 +1358,52 @@ class _OceanState:
|
|
|
1359
1358
|
return pulumi.get(self, "use_as_template_only")
|
|
1360
1359
|
|
|
1361
1360
|
@use_as_template_only.setter
|
|
1362
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[
|
|
1361
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1363
1362
|
pulumi.set(self, "use_as_template_only", value)
|
|
1364
1363
|
|
|
1365
|
-
@property
|
|
1364
|
+
@_builtins.property
|
|
1366
1365
|
@pulumi.getter(name="userData")
|
|
1367
|
-
def user_data(self) -> Optional[pulumi.Input[
|
|
1366
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1368
1367
|
"""
|
|
1369
1368
|
Base64-encoded MIME user data to make available to the instances.
|
|
1370
1369
|
"""
|
|
1371
1370
|
return pulumi.get(self, "user_data")
|
|
1372
1371
|
|
|
1373
1372
|
@user_data.setter
|
|
1374
|
-
def user_data(self, value: Optional[pulumi.Input[
|
|
1373
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1375
1374
|
pulumi.set(self, "user_data", value)
|
|
1376
1375
|
|
|
1377
|
-
@property
|
|
1376
|
+
@_builtins.property
|
|
1378
1377
|
@pulumi.getter(name="utilizeCommitments")
|
|
1379
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[
|
|
1378
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1380
1379
|
"""
|
|
1381
1380
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1382
1381
|
"""
|
|
1383
1382
|
return pulumi.get(self, "utilize_commitments")
|
|
1384
1383
|
|
|
1385
1384
|
@utilize_commitments.setter
|
|
1386
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[
|
|
1385
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1387
1386
|
pulumi.set(self, "utilize_commitments", value)
|
|
1388
1387
|
|
|
1389
|
-
@property
|
|
1388
|
+
@_builtins.property
|
|
1390
1389
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
1391
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[
|
|
1390
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1392
1391
|
"""
|
|
1393
1392
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1394
1393
|
"""
|
|
1395
1394
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
1396
1395
|
|
|
1397
1396
|
@utilize_reserved_instances.setter
|
|
1398
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[
|
|
1397
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1399
1398
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
1400
1399
|
|
|
1401
|
-
@property
|
|
1400
|
+
@_builtins.property
|
|
1402
1401
|
@pulumi.getter
|
|
1403
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1402
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1404
1403
|
return pulumi.get(self, "whitelists")
|
|
1405
1404
|
|
|
1406
1405
|
@whitelists.setter
|
|
1407
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1406
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1408
1407
|
pulumi.set(self, "whitelists", value)
|
|
1409
1408
|
|
|
1410
1409
|
|
|
@@ -1414,50 +1413,50 @@ class Ocean(pulumi.CustomResource):
|
|
|
1414
1413
|
def __init__(__self__,
|
|
1415
1414
|
resource_name: str,
|
|
1416
1415
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1417
|
-
associate_ipv6_address: Optional[pulumi.Input[
|
|
1418
|
-
associate_public_ip_address: Optional[pulumi.Input[
|
|
1416
|
+
associate_ipv6_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1417
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1419
1418
|
attach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]]] = None,
|
|
1420
1419
|
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1421
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1420
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1422
1421
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1423
1422
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1424
|
-
controller_id: Optional[pulumi.Input[
|
|
1425
|
-
desired_capacity: Optional[pulumi.Input[
|
|
1423
|
+
controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1424
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1426
1425
|
detach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanDetachLoadBalancerArgs', 'OceanDetachLoadBalancerArgsDict']]]]] = None,
|
|
1427
|
-
draining_timeout: Optional[pulumi.Input[
|
|
1428
|
-
ebs_optimized: Optional[pulumi.Input[
|
|
1429
|
-
fallback_to_ondemand: Optional[pulumi.Input[
|
|
1426
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1427
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1428
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1430
1429
|
filters: Optional[pulumi.Input[Union['OceanFiltersArgs', 'OceanFiltersArgsDict']]] = None,
|
|
1431
|
-
grace_period: Optional[pulumi.Input[
|
|
1432
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[
|
|
1433
|
-
iam_instance_profile: Optional[pulumi.Input[
|
|
1434
|
-
image_id: Optional[pulumi.Input[
|
|
1430
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1431
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1432
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1433
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1435
1434
|
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1436
1435
|
instance_store_policy: Optional[pulumi.Input[Union['OceanInstanceStorePolicyArgs', 'OceanInstanceStorePolicyArgsDict']]] = None,
|
|
1437
|
-
key_name: Optional[pulumi.Input[
|
|
1436
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1438
1437
|
load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]]] = None,
|
|
1439
1438
|
logging: Optional[pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']]] = None,
|
|
1440
|
-
max_size: Optional[pulumi.Input[
|
|
1441
|
-
min_size: Optional[pulumi.Input[
|
|
1442
|
-
monitoring: Optional[pulumi.Input[
|
|
1443
|
-
name: Optional[pulumi.Input[
|
|
1444
|
-
region: Optional[pulumi.Input[
|
|
1445
|
-
reserved_enis: Optional[pulumi.Input[
|
|
1439
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1440
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1441
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1442
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1443
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1444
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1446
1445
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanResourceTagSpecificationArgs', 'OceanResourceTagSpecificationArgsDict']]]]] = None,
|
|
1447
|
-
root_volume_size: Optional[pulumi.Input[
|
|
1446
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1448
1447
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]]] = None,
|
|
1449
|
-
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1450
|
-
spot_percentage: Optional[pulumi.Input[
|
|
1451
|
-
spread_nodes_by: Optional[pulumi.Input[
|
|
1448
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1449
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1450
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1452
1451
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanStartupTaintArgs', 'OceanStartupTaintArgsDict']]]]] = None,
|
|
1453
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1452
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1454
1453
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1455
1454
|
update_policy: Optional[pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']]] = None,
|
|
1456
|
-
use_as_template_only: Optional[pulumi.Input[
|
|
1457
|
-
user_data: Optional[pulumi.Input[
|
|
1458
|
-
utilize_commitments: Optional[pulumi.Input[
|
|
1459
|
-
utilize_reserved_instances: Optional[pulumi.Input[
|
|
1460
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1455
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1456
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1457
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1458
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1459
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1461
1460
|
__props__=None):
|
|
1462
1461
|
"""
|
|
1463
1462
|
## Example Usage
|
|
@@ -1474,47 +1473,47 @@ class Ocean(pulumi.CustomResource):
|
|
|
1474
1473
|
|
|
1475
1474
|
:param str resource_name: The name of the resource.
|
|
1476
1475
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1477
|
-
:param pulumi.Input[
|
|
1478
|
-
:param pulumi.Input[
|
|
1476
|
+
:param pulumi.Input[_builtins.bool] associate_ipv6_address: Configure IPv6 address allocation.
|
|
1477
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1479
1478
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]] attach_load_balancers: Attach load balancers to the cluster.
|
|
1480
1479
|
:param pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']] autoscaler: Describes the Ocean Kubernetes Auto Scaler.
|
|
1481
1480
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]] block_device_mappings: Object. Array list of block devices that are exposed to the instance, specify either virtual devices and EBS volumes.
|
|
1482
|
-
:param pulumi.Input[
|
|
1483
|
-
:param pulumi.Input[
|
|
1481
|
+
:param pulumi.Input[_builtins.str] controller_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
1482
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1484
1483
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanDetachLoadBalancerArgs', 'OceanDetachLoadBalancerArgsDict']]]] detach_load_balancers: Detach load balancers from the cluster.
|
|
1485
|
-
:param pulumi.Input[
|
|
1486
|
-
:param pulumi.Input[
|
|
1487
|
-
:param pulumi.Input[
|
|
1488
|
-
:param pulumi.Input[
|
|
1489
|
-
:param pulumi.Input[
|
|
1490
|
-
:param pulumi.Input[
|
|
1491
|
-
:param pulumi.Input[
|
|
1484
|
+
: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.
|
|
1485
|
+
: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.
|
|
1486
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1487
|
+
:param pulumi.Input[_builtins.int] grace_period: The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
1488
|
+
:param pulumi.Input[_builtins.int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, an existing instance should remain active after becoming unhealthy. After the set time out the instance will be replaced. The minimum value allowed is 60, and it must be a multiple of 60.
|
|
1489
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
1490
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
1492
1491
|
:param pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
1493
1492
|
:param pulumi.Input[Union['OceanInstanceStorePolicyArgs', 'OceanInstanceStorePolicyArgsDict']] instance_store_policy: Determines the utilization of instance store volumes. If not defined, instance store volumes will not be used.
|
|
1494
|
-
:param pulumi.Input[
|
|
1493
|
+
:param pulumi.Input[_builtins.str] key_name: The key pair to attach the instances.
|
|
1495
1494
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]] load_balancers: Array of load balancer objects to add to ocean cluster
|
|
1496
1495
|
:param pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']] logging: Logging configuration.
|
|
1497
|
-
:param pulumi.Input[
|
|
1498
|
-
:param pulumi.Input[
|
|
1499
|
-
:param pulumi.Input[
|
|
1500
|
-
:param pulumi.Input[
|
|
1501
|
-
:param pulumi.Input[
|
|
1502
|
-
:param pulumi.Input[
|
|
1496
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
1497
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
1498
|
+
: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.
|
|
1499
|
+
:param pulumi.Input[_builtins.str] name: The cluster name.
|
|
1500
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
1501
|
+
:param pulumi.Input[_builtins.int] reserved_enis: Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
1503
1502
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanResourceTagSpecificationArgs', 'OceanResourceTagSpecificationArgsDict']]]] resource_tag_specifications: Specify which resources should be tagged with Virtual Node Group tags or Ocean tags. If tags are set on the VNG, the resources will be tagged with the VNG tags; otherwise, they will be tagged with the Ocean tags.
|
|
1504
|
-
:param pulumi.Input[
|
|
1503
|
+
:param pulumi.Input[_builtins.int] root_volume_size: The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
1505
1504
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]] scheduled_tasks: Set scheduling object.
|
|
1506
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1507
|
-
:param pulumi.Input[
|
|
1508
|
-
:param pulumi.Input[
|
|
1505
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: One or more security group ids.
|
|
1506
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The desired percentage of Spot instances out of all running instances. Only available when the field is not set in any VNG directly (launchSpec.strategy.spotPercentage).
|
|
1507
|
+
:param pulumi.Input[_builtins.str] spread_nodes_by: Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
1509
1508
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanStartupTaintArgs', 'OceanStartupTaintArgsDict']]]] startup_taints: Temporary taints applied to a node during its initialization phase. For a startup taint to work, it must also be set as a regular taint in the userData for the cluster.
|
|
1510
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1509
|
+
: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.
|
|
1511
1510
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
1512
1511
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
1513
|
-
:param pulumi.Input[
|
|
1512
|
+
: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.
|
|
1514
1513
|
When set to true, on Ocean resource creation please make sure your custom VNG has an initial_nodes parameter to create nodes for your VNG.
|
|
1515
|
-
:param pulumi.Input[
|
|
1516
|
-
:param pulumi.Input[
|
|
1517
|
-
:param pulumi.Input[
|
|
1514
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
1515
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1516
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1518
1517
|
"""
|
|
1519
1518
|
...
|
|
1520
1519
|
@overload
|
|
@@ -1550,50 +1549,50 @@ class Ocean(pulumi.CustomResource):
|
|
|
1550
1549
|
def _internal_init(__self__,
|
|
1551
1550
|
resource_name: str,
|
|
1552
1551
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1553
|
-
associate_ipv6_address: Optional[pulumi.Input[
|
|
1554
|
-
associate_public_ip_address: Optional[pulumi.Input[
|
|
1552
|
+
associate_ipv6_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1553
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1555
1554
|
attach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]]] = None,
|
|
1556
1555
|
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1557
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1556
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1558
1557
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1559
1558
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1560
|
-
controller_id: Optional[pulumi.Input[
|
|
1561
|
-
desired_capacity: Optional[pulumi.Input[
|
|
1559
|
+
controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1560
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1562
1561
|
detach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanDetachLoadBalancerArgs', 'OceanDetachLoadBalancerArgsDict']]]]] = None,
|
|
1563
|
-
draining_timeout: Optional[pulumi.Input[
|
|
1564
|
-
ebs_optimized: Optional[pulumi.Input[
|
|
1565
|
-
fallback_to_ondemand: Optional[pulumi.Input[
|
|
1562
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1563
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1564
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1566
1565
|
filters: Optional[pulumi.Input[Union['OceanFiltersArgs', 'OceanFiltersArgsDict']]] = None,
|
|
1567
|
-
grace_period: Optional[pulumi.Input[
|
|
1568
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[
|
|
1569
|
-
iam_instance_profile: Optional[pulumi.Input[
|
|
1570
|
-
image_id: Optional[pulumi.Input[
|
|
1566
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1567
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1568
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1569
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1571
1570
|
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1572
1571
|
instance_store_policy: Optional[pulumi.Input[Union['OceanInstanceStorePolicyArgs', 'OceanInstanceStorePolicyArgsDict']]] = None,
|
|
1573
|
-
key_name: Optional[pulumi.Input[
|
|
1572
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1574
1573
|
load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]]] = None,
|
|
1575
1574
|
logging: Optional[pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']]] = None,
|
|
1576
|
-
max_size: Optional[pulumi.Input[
|
|
1577
|
-
min_size: Optional[pulumi.Input[
|
|
1578
|
-
monitoring: Optional[pulumi.Input[
|
|
1579
|
-
name: Optional[pulumi.Input[
|
|
1580
|
-
region: Optional[pulumi.Input[
|
|
1581
|
-
reserved_enis: Optional[pulumi.Input[
|
|
1575
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1576
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1577
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1578
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1579
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1580
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1582
1581
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanResourceTagSpecificationArgs', 'OceanResourceTagSpecificationArgsDict']]]]] = None,
|
|
1583
|
-
root_volume_size: Optional[pulumi.Input[
|
|
1582
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1584
1583
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]]] = None,
|
|
1585
|
-
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1586
|
-
spot_percentage: Optional[pulumi.Input[
|
|
1587
|
-
spread_nodes_by: Optional[pulumi.Input[
|
|
1584
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1585
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1586
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1588
1587
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanStartupTaintArgs', 'OceanStartupTaintArgsDict']]]]] = None,
|
|
1589
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1588
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1590
1589
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1591
1590
|
update_policy: Optional[pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']]] = None,
|
|
1592
|
-
use_as_template_only: Optional[pulumi.Input[
|
|
1593
|
-
user_data: Optional[pulumi.Input[
|
|
1594
|
-
utilize_commitments: Optional[pulumi.Input[
|
|
1595
|
-
utilize_reserved_instances: Optional[pulumi.Input[
|
|
1596
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1591
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1592
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1593
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1594
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1595
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1597
1596
|
__props__=None):
|
|
1598
1597
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1599
1598
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1663,50 +1662,50 @@ class Ocean(pulumi.CustomResource):
|
|
|
1663
1662
|
def get(resource_name: str,
|
|
1664
1663
|
id: pulumi.Input[str],
|
|
1665
1664
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1666
|
-
associate_ipv6_address: Optional[pulumi.Input[
|
|
1667
|
-
associate_public_ip_address: Optional[pulumi.Input[
|
|
1665
|
+
associate_ipv6_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1666
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1668
1667
|
attach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]]] = None,
|
|
1669
1668
|
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1670
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1669
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1671
1670
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1672
1671
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1673
|
-
controller_id: Optional[pulumi.Input[
|
|
1674
|
-
desired_capacity: Optional[pulumi.Input[
|
|
1672
|
+
controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1673
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1675
1674
|
detach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanDetachLoadBalancerArgs', 'OceanDetachLoadBalancerArgsDict']]]]] = None,
|
|
1676
|
-
draining_timeout: Optional[pulumi.Input[
|
|
1677
|
-
ebs_optimized: Optional[pulumi.Input[
|
|
1678
|
-
fallback_to_ondemand: Optional[pulumi.Input[
|
|
1675
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1676
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1677
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1679
1678
|
filters: Optional[pulumi.Input[Union['OceanFiltersArgs', 'OceanFiltersArgsDict']]] = None,
|
|
1680
|
-
grace_period: Optional[pulumi.Input[
|
|
1681
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[
|
|
1682
|
-
iam_instance_profile: Optional[pulumi.Input[
|
|
1683
|
-
image_id: Optional[pulumi.Input[
|
|
1679
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1680
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1681
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1682
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1684
1683
|
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1685
1684
|
instance_store_policy: Optional[pulumi.Input[Union['OceanInstanceStorePolicyArgs', 'OceanInstanceStorePolicyArgsDict']]] = None,
|
|
1686
|
-
key_name: Optional[pulumi.Input[
|
|
1685
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1687
1686
|
load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]]] = None,
|
|
1688
1687
|
logging: Optional[pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']]] = None,
|
|
1689
|
-
max_size: Optional[pulumi.Input[
|
|
1690
|
-
min_size: Optional[pulumi.Input[
|
|
1691
|
-
monitoring: Optional[pulumi.Input[
|
|
1692
|
-
name: Optional[pulumi.Input[
|
|
1693
|
-
region: Optional[pulumi.Input[
|
|
1694
|
-
reserved_enis: Optional[pulumi.Input[
|
|
1688
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1689
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1690
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1691
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1692
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1693
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1695
1694
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanResourceTagSpecificationArgs', 'OceanResourceTagSpecificationArgsDict']]]]] = None,
|
|
1696
|
-
root_volume_size: Optional[pulumi.Input[
|
|
1695
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1697
1696
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]]] = None,
|
|
1698
|
-
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1699
|
-
spot_percentage: Optional[pulumi.Input[
|
|
1700
|
-
spread_nodes_by: Optional[pulumi.Input[
|
|
1697
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1698
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1699
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1701
1700
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanStartupTaintArgs', 'OceanStartupTaintArgsDict']]]]] = None,
|
|
1702
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1701
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1703
1702
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1704
1703
|
update_policy: Optional[pulumi.Input[Union['OceanUpdatePolicyArgs', 'OceanUpdatePolicyArgsDict']]] = None,
|
|
1705
|
-
use_as_template_only: Optional[pulumi.Input[
|
|
1706
|
-
user_data: Optional[pulumi.Input[
|
|
1707
|
-
utilize_commitments: Optional[pulumi.Input[
|
|
1708
|
-
utilize_reserved_instances: Optional[pulumi.Input[
|
|
1709
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1704
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1705
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1706
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1707
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1708
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'Ocean':
|
|
1710
1709
|
"""
|
|
1711
1710
|
Get an existing Ocean resource's state with the given name, id, and optional extra
|
|
1712
1711
|
properties used to qualify the lookup.
|
|
@@ -1714,47 +1713,47 @@ class Ocean(pulumi.CustomResource):
|
|
|
1714
1713
|
:param str resource_name: The unique name of the resulting resource.
|
|
1715
1714
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1716
1715
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1717
|
-
:param pulumi.Input[
|
|
1718
|
-
:param pulumi.Input[
|
|
1716
|
+
:param pulumi.Input[_builtins.bool] associate_ipv6_address: Configure IPv6 address allocation.
|
|
1717
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1719
1718
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]] attach_load_balancers: Attach load balancers to the cluster.
|
|
1720
1719
|
:param pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']] autoscaler: Describes the Ocean Kubernetes Auto Scaler.
|
|
1721
1720
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]] block_device_mappings: Object. Array list of block devices that are exposed to the instance, specify either virtual devices and EBS volumes.
|
|
1722
|
-
:param pulumi.Input[
|
|
1723
|
-
:param pulumi.Input[
|
|
1721
|
+
:param pulumi.Input[_builtins.str] controller_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
1722
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1724
1723
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanDetachLoadBalancerArgs', 'OceanDetachLoadBalancerArgsDict']]]] detach_load_balancers: Detach load balancers from the cluster.
|
|
1725
|
-
:param pulumi.Input[
|
|
1726
|
-
:param pulumi.Input[
|
|
1727
|
-
:param pulumi.Input[
|
|
1728
|
-
:param pulumi.Input[
|
|
1729
|
-
:param pulumi.Input[
|
|
1730
|
-
:param pulumi.Input[
|
|
1731
|
-
:param pulumi.Input[
|
|
1724
|
+
: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.
|
|
1725
|
+
: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.
|
|
1726
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1727
|
+
:param pulumi.Input[_builtins.int] grace_period: The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
1728
|
+
:param pulumi.Input[_builtins.int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, an existing instance should remain active after becoming unhealthy. After the set time out the instance will be replaced. The minimum value allowed is 60, and it must be a multiple of 60.
|
|
1729
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
1730
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
1732
1731
|
:param pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
1733
1732
|
:param pulumi.Input[Union['OceanInstanceStorePolicyArgs', 'OceanInstanceStorePolicyArgsDict']] instance_store_policy: Determines the utilization of instance store volumes. If not defined, instance store volumes will not be used.
|
|
1734
|
-
:param pulumi.Input[
|
|
1733
|
+
:param pulumi.Input[_builtins.str] key_name: The key pair to attach the instances.
|
|
1735
1734
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]] load_balancers: Array of load balancer objects to add to ocean cluster
|
|
1736
1735
|
:param pulumi.Input[Union['OceanLoggingArgs', 'OceanLoggingArgsDict']] logging: Logging configuration.
|
|
1737
|
-
:param pulumi.Input[
|
|
1738
|
-
:param pulumi.Input[
|
|
1739
|
-
:param pulumi.Input[
|
|
1740
|
-
:param pulumi.Input[
|
|
1741
|
-
:param pulumi.Input[
|
|
1742
|
-
:param pulumi.Input[
|
|
1736
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
1737
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
1738
|
+
: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.
|
|
1739
|
+
:param pulumi.Input[_builtins.str] name: The cluster name.
|
|
1740
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
1741
|
+
:param pulumi.Input[_builtins.int] reserved_enis: Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
1743
1742
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanResourceTagSpecificationArgs', 'OceanResourceTagSpecificationArgsDict']]]] resource_tag_specifications: Specify which resources should be tagged with Virtual Node Group tags or Ocean tags. If tags are set on the VNG, the resources will be tagged with the VNG tags; otherwise, they will be tagged with the Ocean tags.
|
|
1744
|
-
:param pulumi.Input[
|
|
1743
|
+
:param pulumi.Input[_builtins.int] root_volume_size: The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
1745
1744
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanScheduledTaskArgs', 'OceanScheduledTaskArgsDict']]]] scheduled_tasks: Set scheduling object.
|
|
1746
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1747
|
-
:param pulumi.Input[
|
|
1748
|
-
:param pulumi.Input[
|
|
1745
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: One or more security group ids.
|
|
1746
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The desired percentage of Spot instances out of all running instances. Only available when the field is not set in any VNG directly (launchSpec.strategy.spotPercentage).
|
|
1747
|
+
:param pulumi.Input[_builtins.str] spread_nodes_by: Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
1749
1748
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanStartupTaintArgs', 'OceanStartupTaintArgsDict']]]] startup_taints: Temporary taints applied to a node during its initialization phase. For a startup taint to work, it must also be set as a regular taint in the userData for the cluster.
|
|
1750
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1749
|
+
: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.
|
|
1751
1750
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
1752
1751
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
1753
|
-
:param pulumi.Input[
|
|
1752
|
+
: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.
|
|
1754
1753
|
When set to true, on Ocean resource creation please make sure your custom VNG has an initial_nodes parameter to create nodes for your VNG.
|
|
1755
|
-
:param pulumi.Input[
|
|
1756
|
-
:param pulumi.Input[
|
|
1757
|
-
:param pulumi.Input[
|
|
1754
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
1755
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1756
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1758
1757
|
"""
|
|
1759
1758
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1760
1759
|
|
|
@@ -1806,23 +1805,23 @@ class Ocean(pulumi.CustomResource):
|
|
|
1806
1805
|
__props__.__dict__["whitelists"] = whitelists
|
|
1807
1806
|
return Ocean(resource_name, opts=opts, __props__=__props__)
|
|
1808
1807
|
|
|
1809
|
-
@property
|
|
1808
|
+
@_builtins.property
|
|
1810
1809
|
@pulumi.getter(name="associateIpv6Address")
|
|
1811
|
-
def associate_ipv6_address(self) -> pulumi.Output[Optional[
|
|
1810
|
+
def associate_ipv6_address(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1812
1811
|
"""
|
|
1813
1812
|
Configure IPv6 address allocation.
|
|
1814
1813
|
"""
|
|
1815
1814
|
return pulumi.get(self, "associate_ipv6_address")
|
|
1816
1815
|
|
|
1817
|
-
@property
|
|
1816
|
+
@_builtins.property
|
|
1818
1817
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
1819
|
-
def associate_public_ip_address(self) -> pulumi.Output[Optional[
|
|
1818
|
+
def associate_public_ip_address(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1820
1819
|
"""
|
|
1821
1820
|
Configure public IP address allocation.
|
|
1822
1821
|
"""
|
|
1823
1822
|
return pulumi.get(self, "associate_public_ip_address")
|
|
1824
1823
|
|
|
1825
|
-
@property
|
|
1824
|
+
@_builtins.property
|
|
1826
1825
|
@pulumi.getter(name="attachLoadBalancers")
|
|
1827
1826
|
def attach_load_balancers(self) -> pulumi.Output[Optional[Sequence['outputs.OceanAttachLoadBalancer']]]:
|
|
1828
1827
|
"""
|
|
@@ -1830,7 +1829,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1830
1829
|
"""
|
|
1831
1830
|
return pulumi.get(self, "attach_load_balancers")
|
|
1832
1831
|
|
|
1833
|
-
@property
|
|
1832
|
+
@_builtins.property
|
|
1834
1833
|
@pulumi.getter
|
|
1835
1834
|
def autoscaler(self) -> pulumi.Output[Optional['outputs.OceanAutoscaler']]:
|
|
1836
1835
|
"""
|
|
@@ -1838,12 +1837,12 @@ class Ocean(pulumi.CustomResource):
|
|
|
1838
1837
|
"""
|
|
1839
1838
|
return pulumi.get(self, "autoscaler")
|
|
1840
1839
|
|
|
1841
|
-
@property
|
|
1840
|
+
@_builtins.property
|
|
1842
1841
|
@pulumi.getter
|
|
1843
|
-
def blacklists(self) -> pulumi.Output[Optional[Sequence[
|
|
1842
|
+
def blacklists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1844
1843
|
return pulumi.get(self, "blacklists")
|
|
1845
1844
|
|
|
1846
|
-
@property
|
|
1845
|
+
@_builtins.property
|
|
1847
1846
|
@pulumi.getter(name="blockDeviceMappings")
|
|
1848
1847
|
def block_device_mappings(self) -> pulumi.Output[Optional[Sequence['outputs.OceanBlockDeviceMapping']]]:
|
|
1849
1848
|
"""
|
|
@@ -1851,28 +1850,28 @@ class Ocean(pulumi.CustomResource):
|
|
|
1851
1850
|
"""
|
|
1852
1851
|
return pulumi.get(self, "block_device_mappings")
|
|
1853
1852
|
|
|
1854
|
-
@property
|
|
1853
|
+
@_builtins.property
|
|
1855
1854
|
@pulumi.getter(name="clusterOrientations")
|
|
1856
1855
|
def cluster_orientations(self) -> pulumi.Output[Optional[Sequence['outputs.OceanClusterOrientation']]]:
|
|
1857
1856
|
return pulumi.get(self, "cluster_orientations")
|
|
1858
1857
|
|
|
1859
|
-
@property
|
|
1858
|
+
@_builtins.property
|
|
1860
1859
|
@pulumi.getter(name="controllerId")
|
|
1861
|
-
def controller_id(self) -> pulumi.Output[Optional[
|
|
1860
|
+
def controller_id(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1862
1861
|
"""
|
|
1863
1862
|
A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
1864
1863
|
"""
|
|
1865
1864
|
return pulumi.get(self, "controller_id")
|
|
1866
1865
|
|
|
1867
|
-
@property
|
|
1866
|
+
@_builtins.property
|
|
1868
1867
|
@pulumi.getter(name="desiredCapacity")
|
|
1869
|
-
def desired_capacity(self) -> pulumi.Output[
|
|
1868
|
+
def desired_capacity(self) -> pulumi.Output[_builtins.int]:
|
|
1870
1869
|
"""
|
|
1871
1870
|
The number of instances to launch and maintain in the cluster.
|
|
1872
1871
|
"""
|
|
1873
1872
|
return pulumi.get(self, "desired_capacity")
|
|
1874
1873
|
|
|
1875
|
-
@property
|
|
1874
|
+
@_builtins.property
|
|
1876
1875
|
@pulumi.getter(name="detachLoadBalancers")
|
|
1877
1876
|
def detach_load_balancers(self) -> pulumi.Output[Optional[Sequence['outputs.OceanDetachLoadBalancer']]]:
|
|
1878
1877
|
"""
|
|
@@ -1880,68 +1879,68 @@ class Ocean(pulumi.CustomResource):
|
|
|
1880
1879
|
"""
|
|
1881
1880
|
return pulumi.get(self, "detach_load_balancers")
|
|
1882
1881
|
|
|
1883
|
-
@property
|
|
1882
|
+
@_builtins.property
|
|
1884
1883
|
@pulumi.getter(name="drainingTimeout")
|
|
1885
|
-
def draining_timeout(self) -> pulumi.Output[Optional[
|
|
1884
|
+
def draining_timeout(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1886
1885
|
"""
|
|
1887
1886
|
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.
|
|
1888
1887
|
"""
|
|
1889
1888
|
return pulumi.get(self, "draining_timeout")
|
|
1890
1889
|
|
|
1891
|
-
@property
|
|
1890
|
+
@_builtins.property
|
|
1892
1891
|
@pulumi.getter(name="ebsOptimized")
|
|
1893
|
-
def ebs_optimized(self) -> pulumi.Output[Optional[
|
|
1892
|
+
def ebs_optimized(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1894
1893
|
"""
|
|
1895
1894
|
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.
|
|
1896
1895
|
"""
|
|
1897
1896
|
return pulumi.get(self, "ebs_optimized")
|
|
1898
1897
|
|
|
1899
|
-
@property
|
|
1898
|
+
@_builtins.property
|
|
1900
1899
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1901
|
-
def fallback_to_ondemand(self) -> pulumi.Output[Optional[
|
|
1900
|
+
def fallback_to_ondemand(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1902
1901
|
"""
|
|
1903
1902
|
If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1904
1903
|
"""
|
|
1905
1904
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1906
1905
|
|
|
1907
|
-
@property
|
|
1906
|
+
@_builtins.property
|
|
1908
1907
|
@pulumi.getter
|
|
1909
1908
|
def filters(self) -> pulumi.Output[Optional['outputs.OceanFilters']]:
|
|
1910
1909
|
return pulumi.get(self, "filters")
|
|
1911
1910
|
|
|
1912
|
-
@property
|
|
1911
|
+
@_builtins.property
|
|
1913
1912
|
@pulumi.getter(name="gracePeriod")
|
|
1914
|
-
def grace_period(self) -> pulumi.Output[Optional[
|
|
1913
|
+
def grace_period(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1915
1914
|
"""
|
|
1916
1915
|
The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
1917
1916
|
"""
|
|
1918
1917
|
return pulumi.get(self, "grace_period")
|
|
1919
1918
|
|
|
1920
|
-
@property
|
|
1919
|
+
@_builtins.property
|
|
1921
1920
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
1922
|
-
def health_check_unhealthy_duration_before_replacement(self) -> pulumi.Output[Optional[
|
|
1921
|
+
def health_check_unhealthy_duration_before_replacement(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1923
1922
|
"""
|
|
1924
1923
|
The amount of time, in seconds, an existing instance should remain active after becoming unhealthy. After the set time out the instance will be replaced. The minimum value allowed is 60, and it must be a multiple of 60.
|
|
1925
1924
|
"""
|
|
1926
1925
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
1927
1926
|
|
|
1928
|
-
@property
|
|
1927
|
+
@_builtins.property
|
|
1929
1928
|
@pulumi.getter(name="iamInstanceProfile")
|
|
1930
|
-
def iam_instance_profile(self) -> pulumi.Output[Optional[
|
|
1929
|
+
def iam_instance_profile(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1931
1930
|
"""
|
|
1932
1931
|
The instance profile iam role.
|
|
1933
1932
|
"""
|
|
1934
1933
|
return pulumi.get(self, "iam_instance_profile")
|
|
1935
1934
|
|
|
1936
|
-
@property
|
|
1935
|
+
@_builtins.property
|
|
1937
1936
|
@pulumi.getter(name="imageId")
|
|
1938
|
-
def image_id(self) -> pulumi.Output[
|
|
1937
|
+
def image_id(self) -> pulumi.Output[_builtins.str]:
|
|
1939
1938
|
"""
|
|
1940
1939
|
ID of the image used to launch the instances.
|
|
1941
1940
|
"""
|
|
1942
1941
|
return pulumi.get(self, "image_id")
|
|
1943
1942
|
|
|
1944
|
-
@property
|
|
1943
|
+
@_builtins.property
|
|
1945
1944
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
1946
1945
|
def instance_metadata_options(self) -> pulumi.Output[Optional['outputs.OceanInstanceMetadataOptions']]:
|
|
1947
1946
|
"""
|
|
@@ -1949,7 +1948,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1949
1948
|
"""
|
|
1950
1949
|
return pulumi.get(self, "instance_metadata_options")
|
|
1951
1950
|
|
|
1952
|
-
@property
|
|
1951
|
+
@_builtins.property
|
|
1953
1952
|
@pulumi.getter(name="instanceStorePolicy")
|
|
1954
1953
|
def instance_store_policy(self) -> pulumi.Output[Optional['outputs.OceanInstanceStorePolicy']]:
|
|
1955
1954
|
"""
|
|
@@ -1957,15 +1956,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
1957
1956
|
"""
|
|
1958
1957
|
return pulumi.get(self, "instance_store_policy")
|
|
1959
1958
|
|
|
1960
|
-
@property
|
|
1959
|
+
@_builtins.property
|
|
1961
1960
|
@pulumi.getter(name="keyName")
|
|
1962
|
-
def key_name(self) -> pulumi.Output[Optional[
|
|
1961
|
+
def key_name(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1963
1962
|
"""
|
|
1964
1963
|
The key pair to attach the instances.
|
|
1965
1964
|
"""
|
|
1966
1965
|
return pulumi.get(self, "key_name")
|
|
1967
1966
|
|
|
1968
|
-
@property
|
|
1967
|
+
@_builtins.property
|
|
1969
1968
|
@pulumi.getter(name="loadBalancers")
|
|
1970
1969
|
def load_balancers(self) -> pulumi.Output[Optional[Sequence['outputs.OceanLoadBalancer']]]:
|
|
1971
1970
|
"""
|
|
@@ -1973,7 +1972,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1973
1972
|
"""
|
|
1974
1973
|
return pulumi.get(self, "load_balancers")
|
|
1975
1974
|
|
|
1976
|
-
@property
|
|
1975
|
+
@_builtins.property
|
|
1977
1976
|
@pulumi.getter
|
|
1978
1977
|
def logging(self) -> pulumi.Output[Optional['outputs.OceanLogging']]:
|
|
1979
1978
|
"""
|
|
@@ -1981,55 +1980,55 @@ class Ocean(pulumi.CustomResource):
|
|
|
1981
1980
|
"""
|
|
1982
1981
|
return pulumi.get(self, "logging")
|
|
1983
1982
|
|
|
1984
|
-
@property
|
|
1983
|
+
@_builtins.property
|
|
1985
1984
|
@pulumi.getter(name="maxSize")
|
|
1986
|
-
def max_size(self) -> pulumi.Output[Optional[
|
|
1985
|
+
def max_size(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1987
1986
|
"""
|
|
1988
1987
|
The upper limit of instances the cluster can scale up to.
|
|
1989
1988
|
"""
|
|
1990
1989
|
return pulumi.get(self, "max_size")
|
|
1991
1990
|
|
|
1992
|
-
@property
|
|
1991
|
+
@_builtins.property
|
|
1993
1992
|
@pulumi.getter(name="minSize")
|
|
1994
|
-
def min_size(self) -> pulumi.Output[
|
|
1993
|
+
def min_size(self) -> pulumi.Output[_builtins.int]:
|
|
1995
1994
|
"""
|
|
1996
1995
|
The lower limit of instances the cluster can scale down to.
|
|
1997
1996
|
"""
|
|
1998
1997
|
return pulumi.get(self, "min_size")
|
|
1999
1998
|
|
|
2000
|
-
@property
|
|
1999
|
+
@_builtins.property
|
|
2001
2000
|
@pulumi.getter
|
|
2002
|
-
def monitoring(self) -> pulumi.Output[Optional[
|
|
2001
|
+
def monitoring(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2003
2002
|
"""
|
|
2004
2003
|
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.
|
|
2005
2004
|
"""
|
|
2006
2005
|
return pulumi.get(self, "monitoring")
|
|
2007
2006
|
|
|
2008
|
-
@property
|
|
2007
|
+
@_builtins.property
|
|
2009
2008
|
@pulumi.getter
|
|
2010
|
-
def name(self) -> pulumi.Output[
|
|
2009
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
2011
2010
|
"""
|
|
2012
2011
|
The cluster name.
|
|
2013
2012
|
"""
|
|
2014
2013
|
return pulumi.get(self, "name")
|
|
2015
2014
|
|
|
2016
|
-
@property
|
|
2015
|
+
@_builtins.property
|
|
2017
2016
|
@pulumi.getter
|
|
2018
|
-
def region(self) -> pulumi.Output[Optional[
|
|
2017
|
+
def region(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
2019
2018
|
"""
|
|
2020
2019
|
The region the cluster will run in.
|
|
2021
2020
|
"""
|
|
2022
2021
|
return pulumi.get(self, "region")
|
|
2023
2022
|
|
|
2024
|
-
@property
|
|
2023
|
+
@_builtins.property
|
|
2025
2024
|
@pulumi.getter(name="reservedEnis")
|
|
2026
|
-
def reserved_enis(self) -> pulumi.Output[Optional[
|
|
2025
|
+
def reserved_enis(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
2027
2026
|
"""
|
|
2028
2027
|
Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
2029
2028
|
"""
|
|
2030
2029
|
return pulumi.get(self, "reserved_enis")
|
|
2031
2030
|
|
|
2032
|
-
@property
|
|
2031
|
+
@_builtins.property
|
|
2033
2032
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
2034
2033
|
def resource_tag_specifications(self) -> pulumi.Output[Optional[Sequence['outputs.OceanResourceTagSpecification']]]:
|
|
2035
2034
|
"""
|
|
@@ -2037,15 +2036,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
2037
2036
|
"""
|
|
2038
2037
|
return pulumi.get(self, "resource_tag_specifications")
|
|
2039
2038
|
|
|
2040
|
-
@property
|
|
2039
|
+
@_builtins.property
|
|
2041
2040
|
@pulumi.getter(name="rootVolumeSize")
|
|
2042
|
-
def root_volume_size(self) -> pulumi.Output[Optional[
|
|
2041
|
+
def root_volume_size(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
2043
2042
|
"""
|
|
2044
2043
|
The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
2045
2044
|
"""
|
|
2046
2045
|
return pulumi.get(self, "root_volume_size")
|
|
2047
2046
|
|
|
2048
|
-
@property
|
|
2047
|
+
@_builtins.property
|
|
2049
2048
|
@pulumi.getter(name="scheduledTasks")
|
|
2050
2049
|
def scheduled_tasks(self) -> pulumi.Output[Optional[Sequence['outputs.OceanScheduledTask']]]:
|
|
2051
2050
|
"""
|
|
@@ -2053,31 +2052,31 @@ class Ocean(pulumi.CustomResource):
|
|
|
2053
2052
|
"""
|
|
2054
2053
|
return pulumi.get(self, "scheduled_tasks")
|
|
2055
2054
|
|
|
2056
|
-
@property
|
|
2055
|
+
@_builtins.property
|
|
2057
2056
|
@pulumi.getter(name="securityGroups")
|
|
2058
|
-
def security_groups(self) -> pulumi.Output[Sequence[
|
|
2057
|
+
def security_groups(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
2059
2058
|
"""
|
|
2060
2059
|
One or more security group ids.
|
|
2061
2060
|
"""
|
|
2062
2061
|
return pulumi.get(self, "security_groups")
|
|
2063
2062
|
|
|
2064
|
-
@property
|
|
2063
|
+
@_builtins.property
|
|
2065
2064
|
@pulumi.getter(name="spotPercentage")
|
|
2066
|
-
def spot_percentage(self) -> pulumi.Output[Optional[
|
|
2065
|
+
def spot_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
2067
2066
|
"""
|
|
2068
2067
|
The desired percentage of Spot instances out of all running instances. Only available when the field is not set in any VNG directly (launchSpec.strategy.spotPercentage).
|
|
2069
2068
|
"""
|
|
2070
2069
|
return pulumi.get(self, "spot_percentage")
|
|
2071
2070
|
|
|
2072
|
-
@property
|
|
2071
|
+
@_builtins.property
|
|
2073
2072
|
@pulumi.getter(name="spreadNodesBy")
|
|
2074
|
-
def spread_nodes_by(self) -> pulumi.Output[Optional[
|
|
2073
|
+
def spread_nodes_by(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
2075
2074
|
"""
|
|
2076
2075
|
Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
2077
2076
|
"""
|
|
2078
2077
|
return pulumi.get(self, "spread_nodes_by")
|
|
2079
2078
|
|
|
2080
|
-
@property
|
|
2079
|
+
@_builtins.property
|
|
2081
2080
|
@pulumi.getter(name="startupTaints")
|
|
2082
2081
|
def startup_taints(self) -> pulumi.Output[Optional[Sequence['outputs.OceanStartupTaint']]]:
|
|
2083
2082
|
"""
|
|
@@ -2085,16 +2084,16 @@ class Ocean(pulumi.CustomResource):
|
|
|
2085
2084
|
"""
|
|
2086
2085
|
return pulumi.get(self, "startup_taints")
|
|
2087
2086
|
|
|
2088
|
-
@property
|
|
2087
|
+
@_builtins.property
|
|
2089
2088
|
@pulumi.getter(name="subnetIds")
|
|
2090
|
-
def subnet_ids(self) -> pulumi.Output[Sequence[
|
|
2089
|
+
def subnet_ids(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
2091
2090
|
"""
|
|
2092
2091
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public IP.
|
|
2093
2092
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
2094
2093
|
"""
|
|
2095
2094
|
return pulumi.get(self, "subnet_ids")
|
|
2096
2095
|
|
|
2097
|
-
@property
|
|
2096
|
+
@_builtins.property
|
|
2098
2097
|
@pulumi.getter
|
|
2099
2098
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.OceanTag']]]:
|
|
2100
2099
|
"""
|
|
@@ -2102,46 +2101,46 @@ class Ocean(pulumi.CustomResource):
|
|
|
2102
2101
|
"""
|
|
2103
2102
|
return pulumi.get(self, "tags")
|
|
2104
2103
|
|
|
2105
|
-
@property
|
|
2104
|
+
@_builtins.property
|
|
2106
2105
|
@pulumi.getter(name="updatePolicy")
|
|
2107
2106
|
def update_policy(self) -> pulumi.Output[Optional['outputs.OceanUpdatePolicy']]:
|
|
2108
2107
|
return pulumi.get(self, "update_policy")
|
|
2109
2108
|
|
|
2110
|
-
@property
|
|
2109
|
+
@_builtins.property
|
|
2111
2110
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
2112
|
-
def use_as_template_only(self) -> pulumi.Output[Optional[
|
|
2111
|
+
def use_as_template_only(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2113
2112
|
"""
|
|
2114
2113
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
2115
2114
|
When set to true, on Ocean resource creation please make sure your custom VNG has an initial_nodes parameter to create nodes for your VNG.
|
|
2116
2115
|
"""
|
|
2117
2116
|
return pulumi.get(self, "use_as_template_only")
|
|
2118
2117
|
|
|
2119
|
-
@property
|
|
2118
|
+
@_builtins.property
|
|
2120
2119
|
@pulumi.getter(name="userData")
|
|
2121
|
-
def user_data(self) -> pulumi.Output[Optional[
|
|
2120
|
+
def user_data(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
2122
2121
|
"""
|
|
2123
2122
|
Base64-encoded MIME user data to make available to the instances.
|
|
2124
2123
|
"""
|
|
2125
2124
|
return pulumi.get(self, "user_data")
|
|
2126
2125
|
|
|
2127
|
-
@property
|
|
2126
|
+
@_builtins.property
|
|
2128
2127
|
@pulumi.getter(name="utilizeCommitments")
|
|
2129
|
-
def utilize_commitments(self) -> pulumi.Output[Optional[
|
|
2128
|
+
def utilize_commitments(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2130
2129
|
"""
|
|
2131
2130
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
2132
2131
|
"""
|
|
2133
2132
|
return pulumi.get(self, "utilize_commitments")
|
|
2134
2133
|
|
|
2135
|
-
@property
|
|
2134
|
+
@_builtins.property
|
|
2136
2135
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
2137
|
-
def utilize_reserved_instances(self) -> pulumi.Output[Optional[
|
|
2136
|
+
def utilize_reserved_instances(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2138
2137
|
"""
|
|
2139
2138
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
2140
2139
|
"""
|
|
2141
2140
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
2142
2141
|
|
|
2143
|
-
@property
|
|
2142
|
+
@_builtins.property
|
|
2144
2143
|
@pulumi.getter
|
|
2145
|
-
def whitelists(self) -> pulumi.Output[Optional[Sequence[
|
|
2144
|
+
def whitelists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
2146
2145
|
return pulumi.get(self, "whitelists")
|
|
2147
2146
|
|