pulumi-spotinst 3.123.1a1753328543__py3-none-any.whl → 3.124.0__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 +578 -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.123.1a1753328543.dist-info → pulumi_spotinst-3.124.0.dist-info}/METADATA +1 -1
- pulumi_spotinst-3.124.0.dist-info/RECORD +77 -0
- pulumi_spotinst-3.123.1a1753328543.dist-info/RECORD +0 -77
- {pulumi_spotinst-3.123.1a1753328543.dist-info → pulumi_spotinst-3.124.0.dist-info}/WHEEL +0 -0
- {pulumi_spotinst-3.123.1a1753328543.dist-info → pulumi_spotinst-3.124.0.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,95 @@ __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
|
-
|
|
55
|
-
|
|
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
|
+
primary_ipv6: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
54
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
55
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
56
56
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]] = None,
|
|
57
|
-
root_volume_size: Optional[pulumi.Input[
|
|
57
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
58
58
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]] = None,
|
|
59
|
-
spot_percentage: Optional[pulumi.Input[
|
|
60
|
-
spread_nodes_by: Optional[pulumi.Input[
|
|
59
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
60
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
61
61
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]] = None,
|
|
62
62
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
|
|
63
63
|
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[
|
|
64
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
65
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
66
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
67
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
68
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
69
69
|
"""
|
|
70
70
|
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[
|
|
71
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
72
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: One or more security group ids.
|
|
73
|
+
: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
74
|
* `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[
|
|
75
|
+
:param pulumi.Input[_builtins.bool] associate_ipv6_address: Configure IPv6 address allocation.
|
|
76
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
77
77
|
:param pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]] attach_load_balancers: Attach load balancers to the cluster.
|
|
78
78
|
:param pulumi.Input['OceanAutoscalerArgs'] autoscaler: Describes the Ocean Kubernetes Auto Scaler.
|
|
79
79
|
: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[
|
|
80
|
+
: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.
|
|
81
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
82
82
|
: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[
|
|
83
|
+
: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.
|
|
84
|
+
: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.
|
|
85
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
86
|
+
:param pulumi.Input[_builtins.int] grace_period: The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
87
|
+
: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.
|
|
88
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
89
89
|
:param pulumi.Input['OceanInstanceMetadataOptionsArgs'] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
90
90
|
: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[
|
|
91
|
+
:param pulumi.Input[_builtins.str] key_name: The key pair to attach the instances.
|
|
92
92
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]] load_balancers: Array of load balancer objects to add to ocean cluster
|
|
93
93
|
: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[
|
|
94
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
95
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
96
|
+
: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.
|
|
97
|
+
:param pulumi.Input[_builtins.str] name: The cluster name.
|
|
98
|
+
:param pulumi.Input[_builtins.bool] primary_ipv6: Enables assignment of a primary IPv6 address to the cluster. This feature is only available when `associate_ipv6_address` is explicitly set to true. Additionally, the cluster must have been initially created as an EKS cluster in IPv6 mode.
|
|
99
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
100
|
+
:param pulumi.Input[_builtins.int] reserved_enis: Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
100
101
|
: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[
|
|
102
|
+
:param pulumi.Input[_builtins.int] root_volume_size: The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
102
103
|
:param pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]] scheduled_tasks: Set scheduling object.
|
|
103
|
-
:param pulumi.Input[
|
|
104
|
-
:param pulumi.Input[
|
|
104
|
+
: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).
|
|
105
|
+
:param pulumi.Input[_builtins.str] spread_nodes_by: Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
105
106
|
: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
107
|
:param pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
107
|
-
:param pulumi.Input[
|
|
108
|
+
: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
109
|
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[
|
|
110
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
111
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
112
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
112
113
|
"""
|
|
113
114
|
pulumi.set(__self__, "image_id", image_id)
|
|
114
115
|
pulumi.set(__self__, "security_groups", security_groups)
|
|
@@ -165,6 +166,8 @@ class OceanArgs:
|
|
|
165
166
|
pulumi.set(__self__, "monitoring", monitoring)
|
|
166
167
|
if name is not None:
|
|
167
168
|
pulumi.set(__self__, "name", name)
|
|
169
|
+
if primary_ipv6 is not None:
|
|
170
|
+
pulumi.set(__self__, "primary_ipv6", primary_ipv6)
|
|
168
171
|
if region is not None:
|
|
169
172
|
pulumi.set(__self__, "region", region)
|
|
170
173
|
if reserved_enis is not None:
|
|
@@ -196,33 +199,33 @@ class OceanArgs:
|
|
|
196
199
|
if whitelists is not None:
|
|
197
200
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
198
201
|
|
|
199
|
-
@property
|
|
202
|
+
@_builtins.property
|
|
200
203
|
@pulumi.getter(name="imageId")
|
|
201
|
-
def image_id(self) -> pulumi.Input[
|
|
204
|
+
def image_id(self) -> pulumi.Input[_builtins.str]:
|
|
202
205
|
"""
|
|
203
206
|
ID of the image used to launch the instances.
|
|
204
207
|
"""
|
|
205
208
|
return pulumi.get(self, "image_id")
|
|
206
209
|
|
|
207
210
|
@image_id.setter
|
|
208
|
-
def image_id(self, value: pulumi.Input[
|
|
211
|
+
def image_id(self, value: pulumi.Input[_builtins.str]):
|
|
209
212
|
pulumi.set(self, "image_id", value)
|
|
210
213
|
|
|
211
|
-
@property
|
|
214
|
+
@_builtins.property
|
|
212
215
|
@pulumi.getter(name="securityGroups")
|
|
213
|
-
def security_groups(self) -> pulumi.Input[Sequence[pulumi.Input[
|
|
216
|
+
def security_groups(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
214
217
|
"""
|
|
215
218
|
One or more security group ids.
|
|
216
219
|
"""
|
|
217
220
|
return pulumi.get(self, "security_groups")
|
|
218
221
|
|
|
219
222
|
@security_groups.setter
|
|
220
|
-
def security_groups(self, value: pulumi.Input[Sequence[pulumi.Input[
|
|
223
|
+
def security_groups(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
221
224
|
pulumi.set(self, "security_groups", value)
|
|
222
225
|
|
|
223
|
-
@property
|
|
226
|
+
@_builtins.property
|
|
224
227
|
@pulumi.getter(name="subnetIds")
|
|
225
|
-
def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[
|
|
228
|
+
def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
226
229
|
"""
|
|
227
230
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public IP.
|
|
228
231
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
@@ -230,34 +233,34 @@ class OceanArgs:
|
|
|
230
233
|
return pulumi.get(self, "subnet_ids")
|
|
231
234
|
|
|
232
235
|
@subnet_ids.setter
|
|
233
|
-
def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[
|
|
236
|
+
def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
234
237
|
pulumi.set(self, "subnet_ids", value)
|
|
235
238
|
|
|
236
|
-
@property
|
|
239
|
+
@_builtins.property
|
|
237
240
|
@pulumi.getter(name="associateIpv6Address")
|
|
238
|
-
def associate_ipv6_address(self) -> Optional[pulumi.Input[
|
|
241
|
+
def associate_ipv6_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
239
242
|
"""
|
|
240
243
|
Configure IPv6 address allocation.
|
|
241
244
|
"""
|
|
242
245
|
return pulumi.get(self, "associate_ipv6_address")
|
|
243
246
|
|
|
244
247
|
@associate_ipv6_address.setter
|
|
245
|
-
def associate_ipv6_address(self, value: Optional[pulumi.Input[
|
|
248
|
+
def associate_ipv6_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
246
249
|
pulumi.set(self, "associate_ipv6_address", value)
|
|
247
250
|
|
|
248
|
-
@property
|
|
251
|
+
@_builtins.property
|
|
249
252
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
250
|
-
def associate_public_ip_address(self) -> Optional[pulumi.Input[
|
|
253
|
+
def associate_public_ip_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
251
254
|
"""
|
|
252
255
|
Configure public IP address allocation.
|
|
253
256
|
"""
|
|
254
257
|
return pulumi.get(self, "associate_public_ip_address")
|
|
255
258
|
|
|
256
259
|
@associate_public_ip_address.setter
|
|
257
|
-
def associate_public_ip_address(self, value: Optional[pulumi.Input[
|
|
260
|
+
def associate_public_ip_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
258
261
|
pulumi.set(self, "associate_public_ip_address", value)
|
|
259
262
|
|
|
260
|
-
@property
|
|
263
|
+
@_builtins.property
|
|
261
264
|
@pulumi.getter(name="attachLoadBalancers")
|
|
262
265
|
def attach_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]]:
|
|
263
266
|
"""
|
|
@@ -269,7 +272,7 @@ class OceanArgs:
|
|
|
269
272
|
def attach_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]]):
|
|
270
273
|
pulumi.set(self, "attach_load_balancers", value)
|
|
271
274
|
|
|
272
|
-
@property
|
|
275
|
+
@_builtins.property
|
|
273
276
|
@pulumi.getter
|
|
274
277
|
def autoscaler(self) -> Optional[pulumi.Input['OceanAutoscalerArgs']]:
|
|
275
278
|
"""
|
|
@@ -281,16 +284,16 @@ class OceanArgs:
|
|
|
281
284
|
def autoscaler(self, value: Optional[pulumi.Input['OceanAutoscalerArgs']]):
|
|
282
285
|
pulumi.set(self, "autoscaler", value)
|
|
283
286
|
|
|
284
|
-
@property
|
|
287
|
+
@_builtins.property
|
|
285
288
|
@pulumi.getter
|
|
286
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
289
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
287
290
|
return pulumi.get(self, "blacklists")
|
|
288
291
|
|
|
289
292
|
@blacklists.setter
|
|
290
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
293
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
291
294
|
pulumi.set(self, "blacklists", value)
|
|
292
295
|
|
|
293
|
-
@property
|
|
296
|
+
@_builtins.property
|
|
294
297
|
@pulumi.getter(name="blockDeviceMappings")
|
|
295
298
|
def block_device_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]:
|
|
296
299
|
"""
|
|
@@ -302,7 +305,7 @@ class OceanArgs:
|
|
|
302
305
|
def block_device_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]):
|
|
303
306
|
pulumi.set(self, "block_device_mappings", value)
|
|
304
307
|
|
|
305
|
-
@property
|
|
308
|
+
@_builtins.property
|
|
306
309
|
@pulumi.getter(name="clusterOrientations")
|
|
307
310
|
def cluster_orientations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]:
|
|
308
311
|
return pulumi.get(self, "cluster_orientations")
|
|
@@ -311,31 +314,31 @@ class OceanArgs:
|
|
|
311
314
|
def cluster_orientations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]):
|
|
312
315
|
pulumi.set(self, "cluster_orientations", value)
|
|
313
316
|
|
|
314
|
-
@property
|
|
317
|
+
@_builtins.property
|
|
315
318
|
@pulumi.getter(name="controllerId")
|
|
316
|
-
def controller_id(self) -> Optional[pulumi.Input[
|
|
319
|
+
def controller_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
317
320
|
"""
|
|
318
321
|
A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
319
322
|
"""
|
|
320
323
|
return pulumi.get(self, "controller_id")
|
|
321
324
|
|
|
322
325
|
@controller_id.setter
|
|
323
|
-
def controller_id(self, value: Optional[pulumi.Input[
|
|
326
|
+
def controller_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
324
327
|
pulumi.set(self, "controller_id", value)
|
|
325
328
|
|
|
326
|
-
@property
|
|
329
|
+
@_builtins.property
|
|
327
330
|
@pulumi.getter(name="desiredCapacity")
|
|
328
|
-
def desired_capacity(self) -> Optional[pulumi.Input[
|
|
331
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
329
332
|
"""
|
|
330
333
|
The number of instances to launch and maintain in the cluster.
|
|
331
334
|
"""
|
|
332
335
|
return pulumi.get(self, "desired_capacity")
|
|
333
336
|
|
|
334
337
|
@desired_capacity.setter
|
|
335
|
-
def desired_capacity(self, value: Optional[pulumi.Input[
|
|
338
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
336
339
|
pulumi.set(self, "desired_capacity", value)
|
|
337
340
|
|
|
338
|
-
@property
|
|
341
|
+
@_builtins.property
|
|
339
342
|
@pulumi.getter(name="detachLoadBalancers")
|
|
340
343
|
def detach_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]]:
|
|
341
344
|
"""
|
|
@@ -347,43 +350,43 @@ class OceanArgs:
|
|
|
347
350
|
def detach_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]]):
|
|
348
351
|
pulumi.set(self, "detach_load_balancers", value)
|
|
349
352
|
|
|
350
|
-
@property
|
|
353
|
+
@_builtins.property
|
|
351
354
|
@pulumi.getter(name="drainingTimeout")
|
|
352
|
-
def draining_timeout(self) -> Optional[pulumi.Input[
|
|
355
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
353
356
|
"""
|
|
354
357
|
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
358
|
"""
|
|
356
359
|
return pulumi.get(self, "draining_timeout")
|
|
357
360
|
|
|
358
361
|
@draining_timeout.setter
|
|
359
|
-
def draining_timeout(self, value: Optional[pulumi.Input[
|
|
362
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
360
363
|
pulumi.set(self, "draining_timeout", value)
|
|
361
364
|
|
|
362
|
-
@property
|
|
365
|
+
@_builtins.property
|
|
363
366
|
@pulumi.getter(name="ebsOptimized")
|
|
364
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[
|
|
367
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
365
368
|
"""
|
|
366
369
|
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
370
|
"""
|
|
368
371
|
return pulumi.get(self, "ebs_optimized")
|
|
369
372
|
|
|
370
373
|
@ebs_optimized.setter
|
|
371
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[
|
|
374
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
372
375
|
pulumi.set(self, "ebs_optimized", value)
|
|
373
376
|
|
|
374
|
-
@property
|
|
377
|
+
@_builtins.property
|
|
375
378
|
@pulumi.getter(name="fallbackToOndemand")
|
|
376
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[
|
|
379
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
377
380
|
"""
|
|
378
381
|
If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
379
382
|
"""
|
|
380
383
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
381
384
|
|
|
382
385
|
@fallback_to_ondemand.setter
|
|
383
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[
|
|
386
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
384
387
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
385
388
|
|
|
386
|
-
@property
|
|
389
|
+
@_builtins.property
|
|
387
390
|
@pulumi.getter
|
|
388
391
|
def filters(self) -> Optional[pulumi.Input['OceanFiltersArgs']]:
|
|
389
392
|
return pulumi.get(self, "filters")
|
|
@@ -392,43 +395,43 @@ class OceanArgs:
|
|
|
392
395
|
def filters(self, value: Optional[pulumi.Input['OceanFiltersArgs']]):
|
|
393
396
|
pulumi.set(self, "filters", value)
|
|
394
397
|
|
|
395
|
-
@property
|
|
398
|
+
@_builtins.property
|
|
396
399
|
@pulumi.getter(name="gracePeriod")
|
|
397
|
-
def grace_period(self) -> Optional[pulumi.Input[
|
|
400
|
+
def grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
398
401
|
"""
|
|
399
402
|
The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
400
403
|
"""
|
|
401
404
|
return pulumi.get(self, "grace_period")
|
|
402
405
|
|
|
403
406
|
@grace_period.setter
|
|
404
|
-
def grace_period(self, value: Optional[pulumi.Input[
|
|
407
|
+
def grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
405
408
|
pulumi.set(self, "grace_period", value)
|
|
406
409
|
|
|
407
|
-
@property
|
|
410
|
+
@_builtins.property
|
|
408
411
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
409
|
-
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[
|
|
412
|
+
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
410
413
|
"""
|
|
411
414
|
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
415
|
"""
|
|
413
416
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
414
417
|
|
|
415
418
|
@health_check_unhealthy_duration_before_replacement.setter
|
|
416
|
-
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[
|
|
419
|
+
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
417
420
|
pulumi.set(self, "health_check_unhealthy_duration_before_replacement", value)
|
|
418
421
|
|
|
419
|
-
@property
|
|
422
|
+
@_builtins.property
|
|
420
423
|
@pulumi.getter(name="iamInstanceProfile")
|
|
421
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[
|
|
424
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
422
425
|
"""
|
|
423
426
|
The instance profile iam role.
|
|
424
427
|
"""
|
|
425
428
|
return pulumi.get(self, "iam_instance_profile")
|
|
426
429
|
|
|
427
430
|
@iam_instance_profile.setter
|
|
428
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[
|
|
431
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
429
432
|
pulumi.set(self, "iam_instance_profile", value)
|
|
430
433
|
|
|
431
|
-
@property
|
|
434
|
+
@_builtins.property
|
|
432
435
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
433
436
|
def instance_metadata_options(self) -> Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]:
|
|
434
437
|
"""
|
|
@@ -440,7 +443,7 @@ class OceanArgs:
|
|
|
440
443
|
def instance_metadata_options(self, value: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]):
|
|
441
444
|
pulumi.set(self, "instance_metadata_options", value)
|
|
442
445
|
|
|
443
|
-
@property
|
|
446
|
+
@_builtins.property
|
|
444
447
|
@pulumi.getter(name="instanceStorePolicy")
|
|
445
448
|
def instance_store_policy(self) -> Optional[pulumi.Input['OceanInstanceStorePolicyArgs']]:
|
|
446
449
|
"""
|
|
@@ -452,19 +455,19 @@ class OceanArgs:
|
|
|
452
455
|
def instance_store_policy(self, value: Optional[pulumi.Input['OceanInstanceStorePolicyArgs']]):
|
|
453
456
|
pulumi.set(self, "instance_store_policy", value)
|
|
454
457
|
|
|
455
|
-
@property
|
|
458
|
+
@_builtins.property
|
|
456
459
|
@pulumi.getter(name="keyName")
|
|
457
|
-
def key_name(self) -> Optional[pulumi.Input[
|
|
460
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
458
461
|
"""
|
|
459
462
|
The key pair to attach the instances.
|
|
460
463
|
"""
|
|
461
464
|
return pulumi.get(self, "key_name")
|
|
462
465
|
|
|
463
466
|
@key_name.setter
|
|
464
|
-
def key_name(self, value: Optional[pulumi.Input[
|
|
467
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
465
468
|
pulumi.set(self, "key_name", value)
|
|
466
469
|
|
|
467
|
-
@property
|
|
470
|
+
@_builtins.property
|
|
468
471
|
@pulumi.getter(name="loadBalancers")
|
|
469
472
|
def load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]]:
|
|
470
473
|
"""
|
|
@@ -476,7 +479,7 @@ class OceanArgs:
|
|
|
476
479
|
def load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]]):
|
|
477
480
|
pulumi.set(self, "load_balancers", value)
|
|
478
481
|
|
|
479
|
-
@property
|
|
482
|
+
@_builtins.property
|
|
480
483
|
@pulumi.getter
|
|
481
484
|
def logging(self) -> Optional[pulumi.Input['OceanLoggingArgs']]:
|
|
482
485
|
"""
|
|
@@ -488,79 +491,91 @@ class OceanArgs:
|
|
|
488
491
|
def logging(self, value: Optional[pulumi.Input['OceanLoggingArgs']]):
|
|
489
492
|
pulumi.set(self, "logging", value)
|
|
490
493
|
|
|
491
|
-
@property
|
|
494
|
+
@_builtins.property
|
|
492
495
|
@pulumi.getter(name="maxSize")
|
|
493
|
-
def max_size(self) -> Optional[pulumi.Input[
|
|
496
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
494
497
|
"""
|
|
495
498
|
The upper limit of instances the cluster can scale up to.
|
|
496
499
|
"""
|
|
497
500
|
return pulumi.get(self, "max_size")
|
|
498
501
|
|
|
499
502
|
@max_size.setter
|
|
500
|
-
def max_size(self, value: Optional[pulumi.Input[
|
|
503
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
501
504
|
pulumi.set(self, "max_size", value)
|
|
502
505
|
|
|
503
|
-
@property
|
|
506
|
+
@_builtins.property
|
|
504
507
|
@pulumi.getter(name="minSize")
|
|
505
|
-
def min_size(self) -> Optional[pulumi.Input[
|
|
508
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
506
509
|
"""
|
|
507
510
|
The lower limit of instances the cluster can scale down to.
|
|
508
511
|
"""
|
|
509
512
|
return pulumi.get(self, "min_size")
|
|
510
513
|
|
|
511
514
|
@min_size.setter
|
|
512
|
-
def min_size(self, value: Optional[pulumi.Input[
|
|
515
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
513
516
|
pulumi.set(self, "min_size", value)
|
|
514
517
|
|
|
515
|
-
@property
|
|
518
|
+
@_builtins.property
|
|
516
519
|
@pulumi.getter
|
|
517
|
-
def monitoring(self) -> Optional[pulumi.Input[
|
|
520
|
+
def monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
518
521
|
"""
|
|
519
522
|
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
523
|
"""
|
|
521
524
|
return pulumi.get(self, "monitoring")
|
|
522
525
|
|
|
523
526
|
@monitoring.setter
|
|
524
|
-
def monitoring(self, value: Optional[pulumi.Input[
|
|
527
|
+
def monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
525
528
|
pulumi.set(self, "monitoring", value)
|
|
526
529
|
|
|
527
|
-
@property
|
|
530
|
+
@_builtins.property
|
|
528
531
|
@pulumi.getter
|
|
529
|
-
def name(self) -> Optional[pulumi.Input[
|
|
532
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
530
533
|
"""
|
|
531
534
|
The cluster name.
|
|
532
535
|
"""
|
|
533
536
|
return pulumi.get(self, "name")
|
|
534
537
|
|
|
535
538
|
@name.setter
|
|
536
|
-
def name(self, value: Optional[pulumi.Input[
|
|
539
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
537
540
|
pulumi.set(self, "name", value)
|
|
538
541
|
|
|
539
|
-
@property
|
|
542
|
+
@_builtins.property
|
|
543
|
+
@pulumi.getter(name="primaryIpv6")
|
|
544
|
+
def primary_ipv6(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
545
|
+
"""
|
|
546
|
+
Enables assignment of a primary IPv6 address to the cluster. This feature is only available when `associate_ipv6_address` is explicitly set to true. Additionally, the cluster must have been initially created as an EKS cluster in IPv6 mode.
|
|
547
|
+
"""
|
|
548
|
+
return pulumi.get(self, "primary_ipv6")
|
|
549
|
+
|
|
550
|
+
@primary_ipv6.setter
|
|
551
|
+
def primary_ipv6(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
552
|
+
pulumi.set(self, "primary_ipv6", value)
|
|
553
|
+
|
|
554
|
+
@_builtins.property
|
|
540
555
|
@pulumi.getter
|
|
541
|
-
def region(self) -> Optional[pulumi.Input[
|
|
556
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
542
557
|
"""
|
|
543
558
|
The region the cluster will run in.
|
|
544
559
|
"""
|
|
545
560
|
return pulumi.get(self, "region")
|
|
546
561
|
|
|
547
562
|
@region.setter
|
|
548
|
-
def region(self, value: Optional[pulumi.Input[
|
|
563
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
549
564
|
pulumi.set(self, "region", value)
|
|
550
565
|
|
|
551
|
-
@property
|
|
566
|
+
@_builtins.property
|
|
552
567
|
@pulumi.getter(name="reservedEnis")
|
|
553
|
-
def reserved_enis(self) -> Optional[pulumi.Input[
|
|
568
|
+
def reserved_enis(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
554
569
|
"""
|
|
555
570
|
Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
556
571
|
"""
|
|
557
572
|
return pulumi.get(self, "reserved_enis")
|
|
558
573
|
|
|
559
574
|
@reserved_enis.setter
|
|
560
|
-
def reserved_enis(self, value: Optional[pulumi.Input[
|
|
575
|
+
def reserved_enis(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
561
576
|
pulumi.set(self, "reserved_enis", value)
|
|
562
577
|
|
|
563
|
-
@property
|
|
578
|
+
@_builtins.property
|
|
564
579
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
565
580
|
def resource_tag_specifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]]:
|
|
566
581
|
"""
|
|
@@ -572,19 +587,19 @@ class OceanArgs:
|
|
|
572
587
|
def resource_tag_specifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]]):
|
|
573
588
|
pulumi.set(self, "resource_tag_specifications", value)
|
|
574
589
|
|
|
575
|
-
@property
|
|
590
|
+
@_builtins.property
|
|
576
591
|
@pulumi.getter(name="rootVolumeSize")
|
|
577
|
-
def root_volume_size(self) -> Optional[pulumi.Input[
|
|
592
|
+
def root_volume_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
578
593
|
"""
|
|
579
594
|
The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
580
595
|
"""
|
|
581
596
|
return pulumi.get(self, "root_volume_size")
|
|
582
597
|
|
|
583
598
|
@root_volume_size.setter
|
|
584
|
-
def root_volume_size(self, value: Optional[pulumi.Input[
|
|
599
|
+
def root_volume_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
585
600
|
pulumi.set(self, "root_volume_size", value)
|
|
586
601
|
|
|
587
|
-
@property
|
|
602
|
+
@_builtins.property
|
|
588
603
|
@pulumi.getter(name="scheduledTasks")
|
|
589
604
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]:
|
|
590
605
|
"""
|
|
@@ -596,31 +611,31 @@ class OceanArgs:
|
|
|
596
611
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]):
|
|
597
612
|
pulumi.set(self, "scheduled_tasks", value)
|
|
598
613
|
|
|
599
|
-
@property
|
|
614
|
+
@_builtins.property
|
|
600
615
|
@pulumi.getter(name="spotPercentage")
|
|
601
|
-
def spot_percentage(self) -> Optional[pulumi.Input[
|
|
616
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
602
617
|
"""
|
|
603
618
|
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
619
|
"""
|
|
605
620
|
return pulumi.get(self, "spot_percentage")
|
|
606
621
|
|
|
607
622
|
@spot_percentage.setter
|
|
608
|
-
def spot_percentage(self, value: Optional[pulumi.Input[
|
|
623
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
609
624
|
pulumi.set(self, "spot_percentage", value)
|
|
610
625
|
|
|
611
|
-
@property
|
|
626
|
+
@_builtins.property
|
|
612
627
|
@pulumi.getter(name="spreadNodesBy")
|
|
613
|
-
def spread_nodes_by(self) -> Optional[pulumi.Input[
|
|
628
|
+
def spread_nodes_by(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
614
629
|
"""
|
|
615
630
|
Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
616
631
|
"""
|
|
617
632
|
return pulumi.get(self, "spread_nodes_by")
|
|
618
633
|
|
|
619
634
|
@spread_nodes_by.setter
|
|
620
|
-
def spread_nodes_by(self, value: Optional[pulumi.Input[
|
|
635
|
+
def spread_nodes_by(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
621
636
|
pulumi.set(self, "spread_nodes_by", value)
|
|
622
637
|
|
|
623
|
-
@property
|
|
638
|
+
@_builtins.property
|
|
624
639
|
@pulumi.getter(name="startupTaints")
|
|
625
640
|
def startup_taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]]:
|
|
626
641
|
"""
|
|
@@ -632,7 +647,7 @@ class OceanArgs:
|
|
|
632
647
|
def startup_taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]]):
|
|
633
648
|
pulumi.set(self, "startup_taints", value)
|
|
634
649
|
|
|
635
|
-
@property
|
|
650
|
+
@_builtins.property
|
|
636
651
|
@pulumi.getter
|
|
637
652
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]:
|
|
638
653
|
"""
|
|
@@ -644,7 +659,7 @@ class OceanArgs:
|
|
|
644
659
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]):
|
|
645
660
|
pulumi.set(self, "tags", value)
|
|
646
661
|
|
|
647
|
-
@property
|
|
662
|
+
@_builtins.property
|
|
648
663
|
@pulumi.getter(name="updatePolicy")
|
|
649
664
|
def update_policy(self) -> Optional[pulumi.Input['OceanUpdatePolicyArgs']]:
|
|
650
665
|
return pulumi.get(self, "update_policy")
|
|
@@ -653,9 +668,9 @@ class OceanArgs:
|
|
|
653
668
|
def update_policy(self, value: Optional[pulumi.Input['OceanUpdatePolicyArgs']]):
|
|
654
669
|
pulumi.set(self, "update_policy", value)
|
|
655
670
|
|
|
656
|
-
@property
|
|
671
|
+
@_builtins.property
|
|
657
672
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
658
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[
|
|
673
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
659
674
|
"""
|
|
660
675
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
661
676
|
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 +678,147 @@ class OceanArgs:
|
|
|
663
678
|
return pulumi.get(self, "use_as_template_only")
|
|
664
679
|
|
|
665
680
|
@use_as_template_only.setter
|
|
666
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[
|
|
681
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
667
682
|
pulumi.set(self, "use_as_template_only", value)
|
|
668
683
|
|
|
669
|
-
@property
|
|
684
|
+
@_builtins.property
|
|
670
685
|
@pulumi.getter(name="userData")
|
|
671
|
-
def user_data(self) -> Optional[pulumi.Input[
|
|
686
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
672
687
|
"""
|
|
673
688
|
Base64-encoded MIME user data to make available to the instances.
|
|
674
689
|
"""
|
|
675
690
|
return pulumi.get(self, "user_data")
|
|
676
691
|
|
|
677
692
|
@user_data.setter
|
|
678
|
-
def user_data(self, value: Optional[pulumi.Input[
|
|
693
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
679
694
|
pulumi.set(self, "user_data", value)
|
|
680
695
|
|
|
681
|
-
@property
|
|
696
|
+
@_builtins.property
|
|
682
697
|
@pulumi.getter(name="utilizeCommitments")
|
|
683
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[
|
|
698
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
684
699
|
"""
|
|
685
700
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
686
701
|
"""
|
|
687
702
|
return pulumi.get(self, "utilize_commitments")
|
|
688
703
|
|
|
689
704
|
@utilize_commitments.setter
|
|
690
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[
|
|
705
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
691
706
|
pulumi.set(self, "utilize_commitments", value)
|
|
692
707
|
|
|
693
|
-
@property
|
|
708
|
+
@_builtins.property
|
|
694
709
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
695
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[
|
|
710
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
696
711
|
"""
|
|
697
712
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
698
713
|
"""
|
|
699
714
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
700
715
|
|
|
701
716
|
@utilize_reserved_instances.setter
|
|
702
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[
|
|
717
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
703
718
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
704
719
|
|
|
705
|
-
@property
|
|
720
|
+
@_builtins.property
|
|
706
721
|
@pulumi.getter
|
|
707
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
722
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
708
723
|
return pulumi.get(self, "whitelists")
|
|
709
724
|
|
|
710
725
|
@whitelists.setter
|
|
711
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
726
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
712
727
|
pulumi.set(self, "whitelists", value)
|
|
713
728
|
|
|
714
729
|
|
|
715
730
|
@pulumi.input_type
|
|
716
731
|
class _OceanState:
|
|
717
732
|
def __init__(__self__, *,
|
|
718
|
-
associate_ipv6_address: Optional[pulumi.Input[
|
|
719
|
-
associate_public_ip_address: Optional[pulumi.Input[
|
|
733
|
+
associate_ipv6_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
734
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
720
735
|
attach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]] = None,
|
|
721
736
|
autoscaler: Optional[pulumi.Input['OceanAutoscalerArgs']] = None,
|
|
722
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
737
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
723
738
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]] = None,
|
|
724
739
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]] = None,
|
|
725
|
-
controller_id: Optional[pulumi.Input[
|
|
726
|
-
desired_capacity: Optional[pulumi.Input[
|
|
740
|
+
controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
741
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
727
742
|
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[
|
|
743
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
744
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
745
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
731
746
|
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[
|
|
747
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
748
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
749
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
750
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
736
751
|
instance_metadata_options: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']] = None,
|
|
737
752
|
instance_store_policy: Optional[pulumi.Input['OceanInstanceStorePolicyArgs']] = None,
|
|
738
|
-
key_name: Optional[pulumi.Input[
|
|
753
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
739
754
|
load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]] = None,
|
|
740
755
|
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
|
-
|
|
746
|
-
|
|
756
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
757
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
758
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
759
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
760
|
+
primary_ipv6: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
761
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
762
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
747
763
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]] = None,
|
|
748
|
-
root_volume_size: Optional[pulumi.Input[
|
|
764
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
749
765
|
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[
|
|
766
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
767
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
768
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
753
769
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]] = None,
|
|
754
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
770
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
755
771
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]] = None,
|
|
756
772
|
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[
|
|
773
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
774
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
775
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
776
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
777
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
762
778
|
"""
|
|
763
779
|
Input properties used for looking up and filtering Ocean resources.
|
|
764
|
-
:param pulumi.Input[
|
|
765
|
-
:param pulumi.Input[
|
|
780
|
+
:param pulumi.Input[_builtins.bool] associate_ipv6_address: Configure IPv6 address allocation.
|
|
781
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
766
782
|
:param pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]] attach_load_balancers: Attach load balancers to the cluster.
|
|
767
783
|
:param pulumi.Input['OceanAutoscalerArgs'] autoscaler: Describes the Ocean Kubernetes Auto Scaler.
|
|
768
784
|
: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[
|
|
785
|
+
: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.
|
|
786
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
771
787
|
: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[
|
|
788
|
+
: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.
|
|
789
|
+
: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.
|
|
790
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
791
|
+
:param pulumi.Input[_builtins.int] grace_period: The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
792
|
+
: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.
|
|
793
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
794
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
779
795
|
:param pulumi.Input['OceanInstanceMetadataOptionsArgs'] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
780
796
|
: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[
|
|
797
|
+
:param pulumi.Input[_builtins.str] key_name: The key pair to attach the instances.
|
|
782
798
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]] load_balancers: Array of load balancer objects to add to ocean cluster
|
|
783
799
|
: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[
|
|
800
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
801
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
802
|
+
: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.
|
|
803
|
+
:param pulumi.Input[_builtins.str] name: The cluster name.
|
|
804
|
+
:param pulumi.Input[_builtins.bool] primary_ipv6: Enables assignment of a primary IPv6 address to the cluster. This feature is only available when `associate_ipv6_address` is explicitly set to true. Additionally, the cluster must have been initially created as an EKS cluster in IPv6 mode.
|
|
805
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
806
|
+
:param pulumi.Input[_builtins.int] reserved_enis: Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
790
807
|
: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[
|
|
808
|
+
:param pulumi.Input[_builtins.int] root_volume_size: The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
792
809
|
: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[
|
|
810
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: One or more security group ids.
|
|
811
|
+
: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).
|
|
812
|
+
:param pulumi.Input[_builtins.str] spread_nodes_by: Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
796
813
|
: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[
|
|
814
|
+
: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
815
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
799
816
|
:param pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
800
|
-
:param pulumi.Input[
|
|
817
|
+
: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
818
|
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[
|
|
819
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
820
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
821
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
805
822
|
"""
|
|
806
823
|
if associate_ipv6_address is not None:
|
|
807
824
|
pulumi.set(__self__, "associate_ipv6_address", associate_ipv6_address)
|
|
@@ -857,6 +874,8 @@ class _OceanState:
|
|
|
857
874
|
pulumi.set(__self__, "monitoring", monitoring)
|
|
858
875
|
if name is not None:
|
|
859
876
|
pulumi.set(__self__, "name", name)
|
|
877
|
+
if primary_ipv6 is not None:
|
|
878
|
+
pulumi.set(__self__, "primary_ipv6", primary_ipv6)
|
|
860
879
|
if region is not None:
|
|
861
880
|
pulumi.set(__self__, "region", region)
|
|
862
881
|
if reserved_enis is not None:
|
|
@@ -892,31 +911,31 @@ class _OceanState:
|
|
|
892
911
|
if whitelists is not None:
|
|
893
912
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
894
913
|
|
|
895
|
-
@property
|
|
914
|
+
@_builtins.property
|
|
896
915
|
@pulumi.getter(name="associateIpv6Address")
|
|
897
|
-
def associate_ipv6_address(self) -> Optional[pulumi.Input[
|
|
916
|
+
def associate_ipv6_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
898
917
|
"""
|
|
899
918
|
Configure IPv6 address allocation.
|
|
900
919
|
"""
|
|
901
920
|
return pulumi.get(self, "associate_ipv6_address")
|
|
902
921
|
|
|
903
922
|
@associate_ipv6_address.setter
|
|
904
|
-
def associate_ipv6_address(self, value: Optional[pulumi.Input[
|
|
923
|
+
def associate_ipv6_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
905
924
|
pulumi.set(self, "associate_ipv6_address", value)
|
|
906
925
|
|
|
907
|
-
@property
|
|
926
|
+
@_builtins.property
|
|
908
927
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
909
|
-
def associate_public_ip_address(self) -> Optional[pulumi.Input[
|
|
928
|
+
def associate_public_ip_address(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
910
929
|
"""
|
|
911
930
|
Configure public IP address allocation.
|
|
912
931
|
"""
|
|
913
932
|
return pulumi.get(self, "associate_public_ip_address")
|
|
914
933
|
|
|
915
934
|
@associate_public_ip_address.setter
|
|
916
|
-
def associate_public_ip_address(self, value: Optional[pulumi.Input[
|
|
935
|
+
def associate_public_ip_address(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
917
936
|
pulumi.set(self, "associate_public_ip_address", value)
|
|
918
937
|
|
|
919
|
-
@property
|
|
938
|
+
@_builtins.property
|
|
920
939
|
@pulumi.getter(name="attachLoadBalancers")
|
|
921
940
|
def attach_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]]:
|
|
922
941
|
"""
|
|
@@ -928,7 +947,7 @@ class _OceanState:
|
|
|
928
947
|
def attach_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanAttachLoadBalancerArgs']]]]):
|
|
929
948
|
pulumi.set(self, "attach_load_balancers", value)
|
|
930
949
|
|
|
931
|
-
@property
|
|
950
|
+
@_builtins.property
|
|
932
951
|
@pulumi.getter
|
|
933
952
|
def autoscaler(self) -> Optional[pulumi.Input['OceanAutoscalerArgs']]:
|
|
934
953
|
"""
|
|
@@ -940,16 +959,16 @@ class _OceanState:
|
|
|
940
959
|
def autoscaler(self, value: Optional[pulumi.Input['OceanAutoscalerArgs']]):
|
|
941
960
|
pulumi.set(self, "autoscaler", value)
|
|
942
961
|
|
|
943
|
-
@property
|
|
962
|
+
@_builtins.property
|
|
944
963
|
@pulumi.getter
|
|
945
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
964
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
946
965
|
return pulumi.get(self, "blacklists")
|
|
947
966
|
|
|
948
967
|
@blacklists.setter
|
|
949
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
968
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
950
969
|
pulumi.set(self, "blacklists", value)
|
|
951
970
|
|
|
952
|
-
@property
|
|
971
|
+
@_builtins.property
|
|
953
972
|
@pulumi.getter(name="blockDeviceMappings")
|
|
954
973
|
def block_device_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]:
|
|
955
974
|
"""
|
|
@@ -961,7 +980,7 @@ class _OceanState:
|
|
|
961
980
|
def block_device_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanBlockDeviceMappingArgs']]]]):
|
|
962
981
|
pulumi.set(self, "block_device_mappings", value)
|
|
963
982
|
|
|
964
|
-
@property
|
|
983
|
+
@_builtins.property
|
|
965
984
|
@pulumi.getter(name="clusterOrientations")
|
|
966
985
|
def cluster_orientations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]:
|
|
967
986
|
return pulumi.get(self, "cluster_orientations")
|
|
@@ -970,31 +989,31 @@ class _OceanState:
|
|
|
970
989
|
def cluster_orientations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanClusterOrientationArgs']]]]):
|
|
971
990
|
pulumi.set(self, "cluster_orientations", value)
|
|
972
991
|
|
|
973
|
-
@property
|
|
992
|
+
@_builtins.property
|
|
974
993
|
@pulumi.getter(name="controllerId")
|
|
975
|
-
def controller_id(self) -> Optional[pulumi.Input[
|
|
994
|
+
def controller_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
976
995
|
"""
|
|
977
996
|
A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
978
997
|
"""
|
|
979
998
|
return pulumi.get(self, "controller_id")
|
|
980
999
|
|
|
981
1000
|
@controller_id.setter
|
|
982
|
-
def controller_id(self, value: Optional[pulumi.Input[
|
|
1001
|
+
def controller_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
983
1002
|
pulumi.set(self, "controller_id", value)
|
|
984
1003
|
|
|
985
|
-
@property
|
|
1004
|
+
@_builtins.property
|
|
986
1005
|
@pulumi.getter(name="desiredCapacity")
|
|
987
|
-
def desired_capacity(self) -> Optional[pulumi.Input[
|
|
1006
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
988
1007
|
"""
|
|
989
1008
|
The number of instances to launch and maintain in the cluster.
|
|
990
1009
|
"""
|
|
991
1010
|
return pulumi.get(self, "desired_capacity")
|
|
992
1011
|
|
|
993
1012
|
@desired_capacity.setter
|
|
994
|
-
def desired_capacity(self, value: Optional[pulumi.Input[
|
|
1013
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
995
1014
|
pulumi.set(self, "desired_capacity", value)
|
|
996
1015
|
|
|
997
|
-
@property
|
|
1016
|
+
@_builtins.property
|
|
998
1017
|
@pulumi.getter(name="detachLoadBalancers")
|
|
999
1018
|
def detach_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]]:
|
|
1000
1019
|
"""
|
|
@@ -1006,43 +1025,43 @@ class _OceanState:
|
|
|
1006
1025
|
def detach_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanDetachLoadBalancerArgs']]]]):
|
|
1007
1026
|
pulumi.set(self, "detach_load_balancers", value)
|
|
1008
1027
|
|
|
1009
|
-
@property
|
|
1028
|
+
@_builtins.property
|
|
1010
1029
|
@pulumi.getter(name="drainingTimeout")
|
|
1011
|
-
def draining_timeout(self) -> Optional[pulumi.Input[
|
|
1030
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1012
1031
|
"""
|
|
1013
1032
|
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
1033
|
"""
|
|
1015
1034
|
return pulumi.get(self, "draining_timeout")
|
|
1016
1035
|
|
|
1017
1036
|
@draining_timeout.setter
|
|
1018
|
-
def draining_timeout(self, value: Optional[pulumi.Input[
|
|
1037
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1019
1038
|
pulumi.set(self, "draining_timeout", value)
|
|
1020
1039
|
|
|
1021
|
-
@property
|
|
1040
|
+
@_builtins.property
|
|
1022
1041
|
@pulumi.getter(name="ebsOptimized")
|
|
1023
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[
|
|
1042
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1024
1043
|
"""
|
|
1025
1044
|
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
1045
|
"""
|
|
1027
1046
|
return pulumi.get(self, "ebs_optimized")
|
|
1028
1047
|
|
|
1029
1048
|
@ebs_optimized.setter
|
|
1030
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[
|
|
1049
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1031
1050
|
pulumi.set(self, "ebs_optimized", value)
|
|
1032
1051
|
|
|
1033
|
-
@property
|
|
1052
|
+
@_builtins.property
|
|
1034
1053
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1035
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[
|
|
1054
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1036
1055
|
"""
|
|
1037
1056
|
If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1038
1057
|
"""
|
|
1039
1058
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1040
1059
|
|
|
1041
1060
|
@fallback_to_ondemand.setter
|
|
1042
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[
|
|
1061
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1043
1062
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
1044
1063
|
|
|
1045
|
-
@property
|
|
1064
|
+
@_builtins.property
|
|
1046
1065
|
@pulumi.getter
|
|
1047
1066
|
def filters(self) -> Optional[pulumi.Input['OceanFiltersArgs']]:
|
|
1048
1067
|
return pulumi.get(self, "filters")
|
|
@@ -1051,55 +1070,55 @@ class _OceanState:
|
|
|
1051
1070
|
def filters(self, value: Optional[pulumi.Input['OceanFiltersArgs']]):
|
|
1052
1071
|
pulumi.set(self, "filters", value)
|
|
1053
1072
|
|
|
1054
|
-
@property
|
|
1073
|
+
@_builtins.property
|
|
1055
1074
|
@pulumi.getter(name="gracePeriod")
|
|
1056
|
-
def grace_period(self) -> Optional[pulumi.Input[
|
|
1075
|
+
def grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1057
1076
|
"""
|
|
1058
1077
|
The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
1059
1078
|
"""
|
|
1060
1079
|
return pulumi.get(self, "grace_period")
|
|
1061
1080
|
|
|
1062
1081
|
@grace_period.setter
|
|
1063
|
-
def grace_period(self, value: Optional[pulumi.Input[
|
|
1082
|
+
def grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1064
1083
|
pulumi.set(self, "grace_period", value)
|
|
1065
1084
|
|
|
1066
|
-
@property
|
|
1085
|
+
@_builtins.property
|
|
1067
1086
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
1068
|
-
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[
|
|
1087
|
+
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1069
1088
|
"""
|
|
1070
1089
|
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
1090
|
"""
|
|
1072
1091
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
1073
1092
|
|
|
1074
1093
|
@health_check_unhealthy_duration_before_replacement.setter
|
|
1075
|
-
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[
|
|
1094
|
+
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1076
1095
|
pulumi.set(self, "health_check_unhealthy_duration_before_replacement", value)
|
|
1077
1096
|
|
|
1078
|
-
@property
|
|
1097
|
+
@_builtins.property
|
|
1079
1098
|
@pulumi.getter(name="iamInstanceProfile")
|
|
1080
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[
|
|
1099
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1081
1100
|
"""
|
|
1082
1101
|
The instance profile iam role.
|
|
1083
1102
|
"""
|
|
1084
1103
|
return pulumi.get(self, "iam_instance_profile")
|
|
1085
1104
|
|
|
1086
1105
|
@iam_instance_profile.setter
|
|
1087
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[
|
|
1106
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1088
1107
|
pulumi.set(self, "iam_instance_profile", value)
|
|
1089
1108
|
|
|
1090
|
-
@property
|
|
1109
|
+
@_builtins.property
|
|
1091
1110
|
@pulumi.getter(name="imageId")
|
|
1092
|
-
def image_id(self) -> Optional[pulumi.Input[
|
|
1111
|
+
def image_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1093
1112
|
"""
|
|
1094
1113
|
ID of the image used to launch the instances.
|
|
1095
1114
|
"""
|
|
1096
1115
|
return pulumi.get(self, "image_id")
|
|
1097
1116
|
|
|
1098
1117
|
@image_id.setter
|
|
1099
|
-
def image_id(self, value: Optional[pulumi.Input[
|
|
1118
|
+
def image_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1100
1119
|
pulumi.set(self, "image_id", value)
|
|
1101
1120
|
|
|
1102
|
-
@property
|
|
1121
|
+
@_builtins.property
|
|
1103
1122
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
1104
1123
|
def instance_metadata_options(self) -> Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]:
|
|
1105
1124
|
"""
|
|
@@ -1111,7 +1130,7 @@ class _OceanState:
|
|
|
1111
1130
|
def instance_metadata_options(self, value: Optional[pulumi.Input['OceanInstanceMetadataOptionsArgs']]):
|
|
1112
1131
|
pulumi.set(self, "instance_metadata_options", value)
|
|
1113
1132
|
|
|
1114
|
-
@property
|
|
1133
|
+
@_builtins.property
|
|
1115
1134
|
@pulumi.getter(name="instanceStorePolicy")
|
|
1116
1135
|
def instance_store_policy(self) -> Optional[pulumi.Input['OceanInstanceStorePolicyArgs']]:
|
|
1117
1136
|
"""
|
|
@@ -1123,19 +1142,19 @@ class _OceanState:
|
|
|
1123
1142
|
def instance_store_policy(self, value: Optional[pulumi.Input['OceanInstanceStorePolicyArgs']]):
|
|
1124
1143
|
pulumi.set(self, "instance_store_policy", value)
|
|
1125
1144
|
|
|
1126
|
-
@property
|
|
1145
|
+
@_builtins.property
|
|
1127
1146
|
@pulumi.getter(name="keyName")
|
|
1128
|
-
def key_name(self) -> Optional[pulumi.Input[
|
|
1147
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1129
1148
|
"""
|
|
1130
1149
|
The key pair to attach the instances.
|
|
1131
1150
|
"""
|
|
1132
1151
|
return pulumi.get(self, "key_name")
|
|
1133
1152
|
|
|
1134
1153
|
@key_name.setter
|
|
1135
|
-
def key_name(self, value: Optional[pulumi.Input[
|
|
1154
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1136
1155
|
pulumi.set(self, "key_name", value)
|
|
1137
1156
|
|
|
1138
|
-
@property
|
|
1157
|
+
@_builtins.property
|
|
1139
1158
|
@pulumi.getter(name="loadBalancers")
|
|
1140
1159
|
def load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]]:
|
|
1141
1160
|
"""
|
|
@@ -1147,7 +1166,7 @@ class _OceanState:
|
|
|
1147
1166
|
def load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLoadBalancerArgs']]]]):
|
|
1148
1167
|
pulumi.set(self, "load_balancers", value)
|
|
1149
1168
|
|
|
1150
|
-
@property
|
|
1169
|
+
@_builtins.property
|
|
1151
1170
|
@pulumi.getter
|
|
1152
1171
|
def logging(self) -> Optional[pulumi.Input['OceanLoggingArgs']]:
|
|
1153
1172
|
"""
|
|
@@ -1159,79 +1178,91 @@ class _OceanState:
|
|
|
1159
1178
|
def logging(self, value: Optional[pulumi.Input['OceanLoggingArgs']]):
|
|
1160
1179
|
pulumi.set(self, "logging", value)
|
|
1161
1180
|
|
|
1162
|
-
@property
|
|
1181
|
+
@_builtins.property
|
|
1163
1182
|
@pulumi.getter(name="maxSize")
|
|
1164
|
-
def max_size(self) -> Optional[pulumi.Input[
|
|
1183
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1165
1184
|
"""
|
|
1166
1185
|
The upper limit of instances the cluster can scale up to.
|
|
1167
1186
|
"""
|
|
1168
1187
|
return pulumi.get(self, "max_size")
|
|
1169
1188
|
|
|
1170
1189
|
@max_size.setter
|
|
1171
|
-
def max_size(self, value: Optional[pulumi.Input[
|
|
1190
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1172
1191
|
pulumi.set(self, "max_size", value)
|
|
1173
1192
|
|
|
1174
|
-
@property
|
|
1193
|
+
@_builtins.property
|
|
1175
1194
|
@pulumi.getter(name="minSize")
|
|
1176
|
-
def min_size(self) -> Optional[pulumi.Input[
|
|
1195
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1177
1196
|
"""
|
|
1178
1197
|
The lower limit of instances the cluster can scale down to.
|
|
1179
1198
|
"""
|
|
1180
1199
|
return pulumi.get(self, "min_size")
|
|
1181
1200
|
|
|
1182
1201
|
@min_size.setter
|
|
1183
|
-
def min_size(self, value: Optional[pulumi.Input[
|
|
1202
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1184
1203
|
pulumi.set(self, "min_size", value)
|
|
1185
1204
|
|
|
1186
|
-
@property
|
|
1205
|
+
@_builtins.property
|
|
1187
1206
|
@pulumi.getter
|
|
1188
|
-
def monitoring(self) -> Optional[pulumi.Input[
|
|
1207
|
+
def monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1189
1208
|
"""
|
|
1190
1209
|
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
1210
|
"""
|
|
1192
1211
|
return pulumi.get(self, "monitoring")
|
|
1193
1212
|
|
|
1194
1213
|
@monitoring.setter
|
|
1195
|
-
def monitoring(self, value: Optional[pulumi.Input[
|
|
1214
|
+
def monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1196
1215
|
pulumi.set(self, "monitoring", value)
|
|
1197
1216
|
|
|
1198
|
-
@property
|
|
1217
|
+
@_builtins.property
|
|
1199
1218
|
@pulumi.getter
|
|
1200
|
-
def name(self) -> Optional[pulumi.Input[
|
|
1219
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1201
1220
|
"""
|
|
1202
1221
|
The cluster name.
|
|
1203
1222
|
"""
|
|
1204
1223
|
return pulumi.get(self, "name")
|
|
1205
1224
|
|
|
1206
1225
|
@name.setter
|
|
1207
|
-
def name(self, value: Optional[pulumi.Input[
|
|
1226
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1208
1227
|
pulumi.set(self, "name", value)
|
|
1209
1228
|
|
|
1210
|
-
@property
|
|
1229
|
+
@_builtins.property
|
|
1230
|
+
@pulumi.getter(name="primaryIpv6")
|
|
1231
|
+
def primary_ipv6(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1232
|
+
"""
|
|
1233
|
+
Enables assignment of a primary IPv6 address to the cluster. This feature is only available when `associate_ipv6_address` is explicitly set to true. Additionally, the cluster must have been initially created as an EKS cluster in IPv6 mode.
|
|
1234
|
+
"""
|
|
1235
|
+
return pulumi.get(self, "primary_ipv6")
|
|
1236
|
+
|
|
1237
|
+
@primary_ipv6.setter
|
|
1238
|
+
def primary_ipv6(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1239
|
+
pulumi.set(self, "primary_ipv6", value)
|
|
1240
|
+
|
|
1241
|
+
@_builtins.property
|
|
1211
1242
|
@pulumi.getter
|
|
1212
|
-
def region(self) -> Optional[pulumi.Input[
|
|
1243
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1213
1244
|
"""
|
|
1214
1245
|
The region the cluster will run in.
|
|
1215
1246
|
"""
|
|
1216
1247
|
return pulumi.get(self, "region")
|
|
1217
1248
|
|
|
1218
1249
|
@region.setter
|
|
1219
|
-
def region(self, value: Optional[pulumi.Input[
|
|
1250
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1220
1251
|
pulumi.set(self, "region", value)
|
|
1221
1252
|
|
|
1222
|
-
@property
|
|
1253
|
+
@_builtins.property
|
|
1223
1254
|
@pulumi.getter(name="reservedEnis")
|
|
1224
|
-
def reserved_enis(self) -> Optional[pulumi.Input[
|
|
1255
|
+
def reserved_enis(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1225
1256
|
"""
|
|
1226
1257
|
Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
1227
1258
|
"""
|
|
1228
1259
|
return pulumi.get(self, "reserved_enis")
|
|
1229
1260
|
|
|
1230
1261
|
@reserved_enis.setter
|
|
1231
|
-
def reserved_enis(self, value: Optional[pulumi.Input[
|
|
1262
|
+
def reserved_enis(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1232
1263
|
pulumi.set(self, "reserved_enis", value)
|
|
1233
1264
|
|
|
1234
|
-
@property
|
|
1265
|
+
@_builtins.property
|
|
1235
1266
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
1236
1267
|
def resource_tag_specifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]]:
|
|
1237
1268
|
"""
|
|
@@ -1243,19 +1274,19 @@ class _OceanState:
|
|
|
1243
1274
|
def resource_tag_specifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanResourceTagSpecificationArgs']]]]):
|
|
1244
1275
|
pulumi.set(self, "resource_tag_specifications", value)
|
|
1245
1276
|
|
|
1246
|
-
@property
|
|
1277
|
+
@_builtins.property
|
|
1247
1278
|
@pulumi.getter(name="rootVolumeSize")
|
|
1248
|
-
def root_volume_size(self) -> Optional[pulumi.Input[
|
|
1279
|
+
def root_volume_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1249
1280
|
"""
|
|
1250
1281
|
The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
1251
1282
|
"""
|
|
1252
1283
|
return pulumi.get(self, "root_volume_size")
|
|
1253
1284
|
|
|
1254
1285
|
@root_volume_size.setter
|
|
1255
|
-
def root_volume_size(self, value: Optional[pulumi.Input[
|
|
1286
|
+
def root_volume_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1256
1287
|
pulumi.set(self, "root_volume_size", value)
|
|
1257
1288
|
|
|
1258
|
-
@property
|
|
1289
|
+
@_builtins.property
|
|
1259
1290
|
@pulumi.getter(name="scheduledTasks")
|
|
1260
1291
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]:
|
|
1261
1292
|
"""
|
|
@@ -1267,43 +1298,43 @@ class _OceanState:
|
|
|
1267
1298
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanScheduledTaskArgs']]]]):
|
|
1268
1299
|
pulumi.set(self, "scheduled_tasks", value)
|
|
1269
1300
|
|
|
1270
|
-
@property
|
|
1301
|
+
@_builtins.property
|
|
1271
1302
|
@pulumi.getter(name="securityGroups")
|
|
1272
|
-
def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1303
|
+
def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1273
1304
|
"""
|
|
1274
1305
|
One or more security group ids.
|
|
1275
1306
|
"""
|
|
1276
1307
|
return pulumi.get(self, "security_groups")
|
|
1277
1308
|
|
|
1278
1309
|
@security_groups.setter
|
|
1279
|
-
def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1310
|
+
def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1280
1311
|
pulumi.set(self, "security_groups", value)
|
|
1281
1312
|
|
|
1282
|
-
@property
|
|
1313
|
+
@_builtins.property
|
|
1283
1314
|
@pulumi.getter(name="spotPercentage")
|
|
1284
|
-
def spot_percentage(self) -> Optional[pulumi.Input[
|
|
1315
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1285
1316
|
"""
|
|
1286
1317
|
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
1318
|
"""
|
|
1288
1319
|
return pulumi.get(self, "spot_percentage")
|
|
1289
1320
|
|
|
1290
1321
|
@spot_percentage.setter
|
|
1291
|
-
def spot_percentage(self, value: Optional[pulumi.Input[
|
|
1322
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1292
1323
|
pulumi.set(self, "spot_percentage", value)
|
|
1293
1324
|
|
|
1294
|
-
@property
|
|
1325
|
+
@_builtins.property
|
|
1295
1326
|
@pulumi.getter(name="spreadNodesBy")
|
|
1296
|
-
def spread_nodes_by(self) -> Optional[pulumi.Input[
|
|
1327
|
+
def spread_nodes_by(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1297
1328
|
"""
|
|
1298
1329
|
Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
1299
1330
|
"""
|
|
1300
1331
|
return pulumi.get(self, "spread_nodes_by")
|
|
1301
1332
|
|
|
1302
1333
|
@spread_nodes_by.setter
|
|
1303
|
-
def spread_nodes_by(self, value: Optional[pulumi.Input[
|
|
1334
|
+
def spread_nodes_by(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1304
1335
|
pulumi.set(self, "spread_nodes_by", value)
|
|
1305
1336
|
|
|
1306
|
-
@property
|
|
1337
|
+
@_builtins.property
|
|
1307
1338
|
@pulumi.getter(name="startupTaints")
|
|
1308
1339
|
def startup_taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]]:
|
|
1309
1340
|
"""
|
|
@@ -1315,9 +1346,9 @@ class _OceanState:
|
|
|
1315
1346
|
def startup_taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanStartupTaintArgs']]]]):
|
|
1316
1347
|
pulumi.set(self, "startup_taints", value)
|
|
1317
1348
|
|
|
1318
|
-
@property
|
|
1349
|
+
@_builtins.property
|
|
1319
1350
|
@pulumi.getter(name="subnetIds")
|
|
1320
|
-
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1351
|
+
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1321
1352
|
"""
|
|
1322
1353
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public IP.
|
|
1323
1354
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
@@ -1325,10 +1356,10 @@ class _OceanState:
|
|
|
1325
1356
|
return pulumi.get(self, "subnet_ids")
|
|
1326
1357
|
|
|
1327
1358
|
@subnet_ids.setter
|
|
1328
|
-
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1359
|
+
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1329
1360
|
pulumi.set(self, "subnet_ids", value)
|
|
1330
1361
|
|
|
1331
|
-
@property
|
|
1362
|
+
@_builtins.property
|
|
1332
1363
|
@pulumi.getter
|
|
1333
1364
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]:
|
|
1334
1365
|
"""
|
|
@@ -1340,7 +1371,7 @@ class _OceanState:
|
|
|
1340
1371
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanTagArgs']]]]):
|
|
1341
1372
|
pulumi.set(self, "tags", value)
|
|
1342
1373
|
|
|
1343
|
-
@property
|
|
1374
|
+
@_builtins.property
|
|
1344
1375
|
@pulumi.getter(name="updatePolicy")
|
|
1345
1376
|
def update_policy(self) -> Optional[pulumi.Input['OceanUpdatePolicyArgs']]:
|
|
1346
1377
|
return pulumi.get(self, "update_policy")
|
|
@@ -1349,9 +1380,9 @@ class _OceanState:
|
|
|
1349
1380
|
def update_policy(self, value: Optional[pulumi.Input['OceanUpdatePolicyArgs']]):
|
|
1350
1381
|
pulumi.set(self, "update_policy", value)
|
|
1351
1382
|
|
|
1352
|
-
@property
|
|
1383
|
+
@_builtins.property
|
|
1353
1384
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
1354
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[
|
|
1385
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1355
1386
|
"""
|
|
1356
1387
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
1357
1388
|
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 +1390,52 @@ class _OceanState:
|
|
|
1359
1390
|
return pulumi.get(self, "use_as_template_only")
|
|
1360
1391
|
|
|
1361
1392
|
@use_as_template_only.setter
|
|
1362
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[
|
|
1393
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1363
1394
|
pulumi.set(self, "use_as_template_only", value)
|
|
1364
1395
|
|
|
1365
|
-
@property
|
|
1396
|
+
@_builtins.property
|
|
1366
1397
|
@pulumi.getter(name="userData")
|
|
1367
|
-
def user_data(self) -> Optional[pulumi.Input[
|
|
1398
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1368
1399
|
"""
|
|
1369
1400
|
Base64-encoded MIME user data to make available to the instances.
|
|
1370
1401
|
"""
|
|
1371
1402
|
return pulumi.get(self, "user_data")
|
|
1372
1403
|
|
|
1373
1404
|
@user_data.setter
|
|
1374
|
-
def user_data(self, value: Optional[pulumi.Input[
|
|
1405
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1375
1406
|
pulumi.set(self, "user_data", value)
|
|
1376
1407
|
|
|
1377
|
-
@property
|
|
1408
|
+
@_builtins.property
|
|
1378
1409
|
@pulumi.getter(name="utilizeCommitments")
|
|
1379
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[
|
|
1410
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1380
1411
|
"""
|
|
1381
1412
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1382
1413
|
"""
|
|
1383
1414
|
return pulumi.get(self, "utilize_commitments")
|
|
1384
1415
|
|
|
1385
1416
|
@utilize_commitments.setter
|
|
1386
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[
|
|
1417
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1387
1418
|
pulumi.set(self, "utilize_commitments", value)
|
|
1388
1419
|
|
|
1389
|
-
@property
|
|
1420
|
+
@_builtins.property
|
|
1390
1421
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
1391
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[
|
|
1422
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1392
1423
|
"""
|
|
1393
1424
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1394
1425
|
"""
|
|
1395
1426
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
1396
1427
|
|
|
1397
1428
|
@utilize_reserved_instances.setter
|
|
1398
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[
|
|
1429
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1399
1430
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
1400
1431
|
|
|
1401
|
-
@property
|
|
1432
|
+
@_builtins.property
|
|
1402
1433
|
@pulumi.getter
|
|
1403
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1434
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1404
1435
|
return pulumi.get(self, "whitelists")
|
|
1405
1436
|
|
|
1406
1437
|
@whitelists.setter
|
|
1407
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1438
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1408
1439
|
pulumi.set(self, "whitelists", value)
|
|
1409
1440
|
|
|
1410
1441
|
|
|
@@ -1414,50 +1445,51 @@ class Ocean(pulumi.CustomResource):
|
|
|
1414
1445
|
def __init__(__self__,
|
|
1415
1446
|
resource_name: str,
|
|
1416
1447
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1417
|
-
associate_ipv6_address: Optional[pulumi.Input[
|
|
1418
|
-
associate_public_ip_address: Optional[pulumi.Input[
|
|
1448
|
+
associate_ipv6_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1449
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1419
1450
|
attach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]]] = None,
|
|
1420
1451
|
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1421
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1452
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1422
1453
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1423
1454
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1424
|
-
controller_id: Optional[pulumi.Input[
|
|
1425
|
-
desired_capacity: Optional[pulumi.Input[
|
|
1455
|
+
controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1456
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1426
1457
|
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[
|
|
1458
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1459
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1460
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1430
1461
|
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[
|
|
1462
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1463
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1464
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1465
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1435
1466
|
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1436
1467
|
instance_store_policy: Optional[pulumi.Input[Union['OceanInstanceStorePolicyArgs', 'OceanInstanceStorePolicyArgsDict']]] = None,
|
|
1437
|
-
key_name: Optional[pulumi.Input[
|
|
1468
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1438
1469
|
load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]]] = None,
|
|
1439
1470
|
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
|
-
|
|
1445
|
-
|
|
1471
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1472
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1473
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1474
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1475
|
+
primary_ipv6: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1476
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1477
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1446
1478
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanResourceTagSpecificationArgs', 'OceanResourceTagSpecificationArgsDict']]]]] = None,
|
|
1447
|
-
root_volume_size: Optional[pulumi.Input[
|
|
1479
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1448
1480
|
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[
|
|
1481
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1482
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1483
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1452
1484
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanStartupTaintArgs', 'OceanStartupTaintArgsDict']]]]] = None,
|
|
1453
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1485
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1454
1486
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1455
1487
|
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[
|
|
1488
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1489
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1490
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1491
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1492
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1461
1493
|
__props__=None):
|
|
1462
1494
|
"""
|
|
1463
1495
|
## Example Usage
|
|
@@ -1474,47 +1506,48 @@ class Ocean(pulumi.CustomResource):
|
|
|
1474
1506
|
|
|
1475
1507
|
:param str resource_name: The name of the resource.
|
|
1476
1508
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1477
|
-
:param pulumi.Input[
|
|
1478
|
-
:param pulumi.Input[
|
|
1509
|
+
:param pulumi.Input[_builtins.bool] associate_ipv6_address: Configure IPv6 address allocation.
|
|
1510
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1479
1511
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]] attach_load_balancers: Attach load balancers to the cluster.
|
|
1480
1512
|
:param pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']] autoscaler: Describes the Ocean Kubernetes Auto Scaler.
|
|
1481
1513
|
: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[
|
|
1514
|
+
: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.
|
|
1515
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1484
1516
|
: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[
|
|
1517
|
+
: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.
|
|
1518
|
+
: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.
|
|
1519
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1520
|
+
:param pulumi.Input[_builtins.int] grace_period: The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
1521
|
+
: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.
|
|
1522
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
1523
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
1492
1524
|
:param pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
1493
1525
|
: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[
|
|
1526
|
+
:param pulumi.Input[_builtins.str] key_name: The key pair to attach the instances.
|
|
1495
1527
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]] load_balancers: Array of load balancer objects to add to ocean cluster
|
|
1496
1528
|
: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[
|
|
1529
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
1530
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
1531
|
+
: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.
|
|
1532
|
+
:param pulumi.Input[_builtins.str] name: The cluster name.
|
|
1533
|
+
:param pulumi.Input[_builtins.bool] primary_ipv6: Enables assignment of a primary IPv6 address to the cluster. This feature is only available when `associate_ipv6_address` is explicitly set to true. Additionally, the cluster must have been initially created as an EKS cluster in IPv6 mode.
|
|
1534
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
1535
|
+
:param pulumi.Input[_builtins.int] reserved_enis: Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
1503
1536
|
: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[
|
|
1537
|
+
:param pulumi.Input[_builtins.int] root_volume_size: The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
1505
1538
|
: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[
|
|
1539
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: One or more security group ids.
|
|
1540
|
+
: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).
|
|
1541
|
+
:param pulumi.Input[_builtins.str] spread_nodes_by: Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
1509
1542
|
: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[
|
|
1543
|
+
: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
1544
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
1512
1545
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
1513
|
-
:param pulumi.Input[
|
|
1546
|
+
: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
1547
|
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[
|
|
1548
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
1549
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1550
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1518
1551
|
"""
|
|
1519
1552
|
...
|
|
1520
1553
|
@overload
|
|
@@ -1550,50 +1583,51 @@ class Ocean(pulumi.CustomResource):
|
|
|
1550
1583
|
def _internal_init(__self__,
|
|
1551
1584
|
resource_name: str,
|
|
1552
1585
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1553
|
-
associate_ipv6_address: Optional[pulumi.Input[
|
|
1554
|
-
associate_public_ip_address: Optional[pulumi.Input[
|
|
1586
|
+
associate_ipv6_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1587
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1555
1588
|
attach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]]] = None,
|
|
1556
1589
|
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1557
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1590
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1558
1591
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1559
1592
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1560
|
-
controller_id: Optional[pulumi.Input[
|
|
1561
|
-
desired_capacity: Optional[pulumi.Input[
|
|
1593
|
+
controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1594
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1562
1595
|
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[
|
|
1596
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1597
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1598
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1566
1599
|
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[
|
|
1600
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1601
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1602
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1603
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1571
1604
|
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1572
1605
|
instance_store_policy: Optional[pulumi.Input[Union['OceanInstanceStorePolicyArgs', 'OceanInstanceStorePolicyArgsDict']]] = None,
|
|
1573
|
-
key_name: Optional[pulumi.Input[
|
|
1606
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1574
1607
|
load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]]] = None,
|
|
1575
1608
|
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
|
-
|
|
1581
|
-
|
|
1609
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1610
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1611
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1612
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1613
|
+
primary_ipv6: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1614
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1615
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1582
1616
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanResourceTagSpecificationArgs', 'OceanResourceTagSpecificationArgsDict']]]]] = None,
|
|
1583
|
-
root_volume_size: Optional[pulumi.Input[
|
|
1617
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1584
1618
|
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[
|
|
1619
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1620
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1621
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1588
1622
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanStartupTaintArgs', 'OceanStartupTaintArgsDict']]]]] = None,
|
|
1589
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1623
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1590
1624
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1591
1625
|
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[
|
|
1626
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1627
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1628
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1629
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1630
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1597
1631
|
__props__=None):
|
|
1598
1632
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1599
1633
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1632,6 +1666,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1632
1666
|
__props__.__dict__["min_size"] = min_size
|
|
1633
1667
|
__props__.__dict__["monitoring"] = monitoring
|
|
1634
1668
|
__props__.__dict__["name"] = name
|
|
1669
|
+
__props__.__dict__["primary_ipv6"] = primary_ipv6
|
|
1635
1670
|
__props__.__dict__["region"] = region
|
|
1636
1671
|
__props__.__dict__["reserved_enis"] = reserved_enis
|
|
1637
1672
|
__props__.__dict__["resource_tag_specifications"] = resource_tag_specifications
|
|
@@ -1663,50 +1698,51 @@ class Ocean(pulumi.CustomResource):
|
|
|
1663
1698
|
def get(resource_name: str,
|
|
1664
1699
|
id: pulumi.Input[str],
|
|
1665
1700
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1666
|
-
associate_ipv6_address: Optional[pulumi.Input[
|
|
1667
|
-
associate_public_ip_address: Optional[pulumi.Input[
|
|
1701
|
+
associate_ipv6_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1702
|
+
associate_public_ip_address: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1668
1703
|
attach_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]]] = None,
|
|
1669
1704
|
autoscaler: Optional[pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']]] = None,
|
|
1670
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1705
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1671
1706
|
block_device_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanBlockDeviceMappingArgs', 'OceanBlockDeviceMappingArgsDict']]]]] = None,
|
|
1672
1707
|
cluster_orientations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanClusterOrientationArgs', 'OceanClusterOrientationArgsDict']]]]] = None,
|
|
1673
|
-
controller_id: Optional[pulumi.Input[
|
|
1674
|
-
desired_capacity: Optional[pulumi.Input[
|
|
1708
|
+
controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1709
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1675
1710
|
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[
|
|
1711
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1712
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1713
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1679
1714
|
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[
|
|
1715
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1716
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1717
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1718
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1684
1719
|
instance_metadata_options: Optional[pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']]] = None,
|
|
1685
1720
|
instance_store_policy: Optional[pulumi.Input[Union['OceanInstanceStorePolicyArgs', 'OceanInstanceStorePolicyArgsDict']]] = None,
|
|
1686
|
-
key_name: Optional[pulumi.Input[
|
|
1721
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1687
1722
|
load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]]] = None,
|
|
1688
1723
|
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
|
-
|
|
1694
|
-
|
|
1724
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1725
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1726
|
+
monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1727
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1728
|
+
primary_ipv6: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1729
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1730
|
+
reserved_enis: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1695
1731
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanResourceTagSpecificationArgs', 'OceanResourceTagSpecificationArgsDict']]]]] = None,
|
|
1696
|
-
root_volume_size: Optional[pulumi.Input[
|
|
1732
|
+
root_volume_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1697
1733
|
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[
|
|
1734
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1735
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1736
|
+
spread_nodes_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1701
1737
|
startup_taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanStartupTaintArgs', 'OceanStartupTaintArgsDict']]]]] = None,
|
|
1702
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1738
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1703
1739
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]]] = None,
|
|
1704
1740
|
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[
|
|
1741
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1742
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1743
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1744
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1745
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'Ocean':
|
|
1710
1746
|
"""
|
|
1711
1747
|
Get an existing Ocean resource's state with the given name, id, and optional extra
|
|
1712
1748
|
properties used to qualify the lookup.
|
|
@@ -1714,47 +1750,48 @@ class Ocean(pulumi.CustomResource):
|
|
|
1714
1750
|
:param str resource_name: The unique name of the resulting resource.
|
|
1715
1751
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1716
1752
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1717
|
-
:param pulumi.Input[
|
|
1718
|
-
:param pulumi.Input[
|
|
1753
|
+
:param pulumi.Input[_builtins.bool] associate_ipv6_address: Configure IPv6 address allocation.
|
|
1754
|
+
:param pulumi.Input[_builtins.bool] associate_public_ip_address: Configure public IP address allocation.
|
|
1719
1755
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanAttachLoadBalancerArgs', 'OceanAttachLoadBalancerArgsDict']]]] attach_load_balancers: Attach load balancers to the cluster.
|
|
1720
1756
|
:param pulumi.Input[Union['OceanAutoscalerArgs', 'OceanAutoscalerArgsDict']] autoscaler: Describes the Ocean Kubernetes Auto Scaler.
|
|
1721
1757
|
: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[
|
|
1758
|
+
: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.
|
|
1759
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
1724
1760
|
: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[
|
|
1761
|
+
: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.
|
|
1762
|
+
: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.
|
|
1763
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1764
|
+
:param pulumi.Input[_builtins.int] grace_period: The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
1765
|
+
: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.
|
|
1766
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The instance profile iam role.
|
|
1767
|
+
:param pulumi.Input[_builtins.str] image_id: ID of the image used to launch the instances.
|
|
1732
1768
|
:param pulumi.Input[Union['OceanInstanceMetadataOptionsArgs', 'OceanInstanceMetadataOptionsArgsDict']] instance_metadata_options: Ocean instance metadata options object for IMDSv2.
|
|
1733
1769
|
: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[
|
|
1770
|
+
:param pulumi.Input[_builtins.str] key_name: The key pair to attach the instances.
|
|
1735
1771
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanLoadBalancerArgs', 'OceanLoadBalancerArgsDict']]]] load_balancers: Array of load balancer objects to add to ocean cluster
|
|
1736
1772
|
: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[
|
|
1773
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
1774
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
1775
|
+
: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.
|
|
1776
|
+
:param pulumi.Input[_builtins.str] name: The cluster name.
|
|
1777
|
+
:param pulumi.Input[_builtins.bool] primary_ipv6: Enables assignment of a primary IPv6 address to the cluster. This feature is only available when `associate_ipv6_address` is explicitly set to true. Additionally, the cluster must have been initially created as an EKS cluster in IPv6 mode.
|
|
1778
|
+
:param pulumi.Input[_builtins.str] region: The region the cluster will run in.
|
|
1779
|
+
:param pulumi.Input[_builtins.int] reserved_enis: Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
1743
1780
|
: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[
|
|
1781
|
+
:param pulumi.Input[_builtins.int] root_volume_size: The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
1745
1782
|
: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[
|
|
1783
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: One or more security group ids.
|
|
1784
|
+
: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).
|
|
1785
|
+
:param pulumi.Input[_builtins.str] spread_nodes_by: Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
1749
1786
|
: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[
|
|
1787
|
+
: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
1788
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
1752
1789
|
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanTagArgs', 'OceanTagArgsDict']]]] tags: Optionally adds tags to instances launched in an Ocean cluster.
|
|
1753
|
-
:param pulumi.Input[
|
|
1790
|
+
: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
1791
|
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[
|
|
1792
|
+
:param pulumi.Input[_builtins.str] user_data: Base64-encoded MIME user data to make available to the instances.
|
|
1793
|
+
:param pulumi.Input[_builtins.bool] utilize_commitments: If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
1794
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
1758
1795
|
"""
|
|
1759
1796
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1760
1797
|
|
|
@@ -1787,6 +1824,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1787
1824
|
__props__.__dict__["min_size"] = min_size
|
|
1788
1825
|
__props__.__dict__["monitoring"] = monitoring
|
|
1789
1826
|
__props__.__dict__["name"] = name
|
|
1827
|
+
__props__.__dict__["primary_ipv6"] = primary_ipv6
|
|
1790
1828
|
__props__.__dict__["region"] = region
|
|
1791
1829
|
__props__.__dict__["reserved_enis"] = reserved_enis
|
|
1792
1830
|
__props__.__dict__["resource_tag_specifications"] = resource_tag_specifications
|
|
@@ -1806,23 +1844,23 @@ class Ocean(pulumi.CustomResource):
|
|
|
1806
1844
|
__props__.__dict__["whitelists"] = whitelists
|
|
1807
1845
|
return Ocean(resource_name, opts=opts, __props__=__props__)
|
|
1808
1846
|
|
|
1809
|
-
@property
|
|
1847
|
+
@_builtins.property
|
|
1810
1848
|
@pulumi.getter(name="associateIpv6Address")
|
|
1811
|
-
def associate_ipv6_address(self) -> pulumi.Output[Optional[
|
|
1849
|
+
def associate_ipv6_address(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1812
1850
|
"""
|
|
1813
1851
|
Configure IPv6 address allocation.
|
|
1814
1852
|
"""
|
|
1815
1853
|
return pulumi.get(self, "associate_ipv6_address")
|
|
1816
1854
|
|
|
1817
|
-
@property
|
|
1855
|
+
@_builtins.property
|
|
1818
1856
|
@pulumi.getter(name="associatePublicIpAddress")
|
|
1819
|
-
def associate_public_ip_address(self) -> pulumi.Output[Optional[
|
|
1857
|
+
def associate_public_ip_address(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1820
1858
|
"""
|
|
1821
1859
|
Configure public IP address allocation.
|
|
1822
1860
|
"""
|
|
1823
1861
|
return pulumi.get(self, "associate_public_ip_address")
|
|
1824
1862
|
|
|
1825
|
-
@property
|
|
1863
|
+
@_builtins.property
|
|
1826
1864
|
@pulumi.getter(name="attachLoadBalancers")
|
|
1827
1865
|
def attach_load_balancers(self) -> pulumi.Output[Optional[Sequence['outputs.OceanAttachLoadBalancer']]]:
|
|
1828
1866
|
"""
|
|
@@ -1830,7 +1868,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1830
1868
|
"""
|
|
1831
1869
|
return pulumi.get(self, "attach_load_balancers")
|
|
1832
1870
|
|
|
1833
|
-
@property
|
|
1871
|
+
@_builtins.property
|
|
1834
1872
|
@pulumi.getter
|
|
1835
1873
|
def autoscaler(self) -> pulumi.Output[Optional['outputs.OceanAutoscaler']]:
|
|
1836
1874
|
"""
|
|
@@ -1838,12 +1876,12 @@ class Ocean(pulumi.CustomResource):
|
|
|
1838
1876
|
"""
|
|
1839
1877
|
return pulumi.get(self, "autoscaler")
|
|
1840
1878
|
|
|
1841
|
-
@property
|
|
1879
|
+
@_builtins.property
|
|
1842
1880
|
@pulumi.getter
|
|
1843
|
-
def blacklists(self) -> pulumi.Output[Optional[Sequence[
|
|
1881
|
+
def blacklists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1844
1882
|
return pulumi.get(self, "blacklists")
|
|
1845
1883
|
|
|
1846
|
-
@property
|
|
1884
|
+
@_builtins.property
|
|
1847
1885
|
@pulumi.getter(name="blockDeviceMappings")
|
|
1848
1886
|
def block_device_mappings(self) -> pulumi.Output[Optional[Sequence['outputs.OceanBlockDeviceMapping']]]:
|
|
1849
1887
|
"""
|
|
@@ -1851,28 +1889,28 @@ class Ocean(pulumi.CustomResource):
|
|
|
1851
1889
|
"""
|
|
1852
1890
|
return pulumi.get(self, "block_device_mappings")
|
|
1853
1891
|
|
|
1854
|
-
@property
|
|
1892
|
+
@_builtins.property
|
|
1855
1893
|
@pulumi.getter(name="clusterOrientations")
|
|
1856
1894
|
def cluster_orientations(self) -> pulumi.Output[Optional[Sequence['outputs.OceanClusterOrientation']]]:
|
|
1857
1895
|
return pulumi.get(self, "cluster_orientations")
|
|
1858
1896
|
|
|
1859
|
-
@property
|
|
1897
|
+
@_builtins.property
|
|
1860
1898
|
@pulumi.getter(name="controllerId")
|
|
1861
|
-
def controller_id(self) -> pulumi.Output[Optional[
|
|
1899
|
+
def controller_id(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1862
1900
|
"""
|
|
1863
1901
|
A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
1864
1902
|
"""
|
|
1865
1903
|
return pulumi.get(self, "controller_id")
|
|
1866
1904
|
|
|
1867
|
-
@property
|
|
1905
|
+
@_builtins.property
|
|
1868
1906
|
@pulumi.getter(name="desiredCapacity")
|
|
1869
|
-
def desired_capacity(self) -> pulumi.Output[
|
|
1907
|
+
def desired_capacity(self) -> pulumi.Output[_builtins.int]:
|
|
1870
1908
|
"""
|
|
1871
1909
|
The number of instances to launch and maintain in the cluster.
|
|
1872
1910
|
"""
|
|
1873
1911
|
return pulumi.get(self, "desired_capacity")
|
|
1874
1912
|
|
|
1875
|
-
@property
|
|
1913
|
+
@_builtins.property
|
|
1876
1914
|
@pulumi.getter(name="detachLoadBalancers")
|
|
1877
1915
|
def detach_load_balancers(self) -> pulumi.Output[Optional[Sequence['outputs.OceanDetachLoadBalancer']]]:
|
|
1878
1916
|
"""
|
|
@@ -1880,68 +1918,68 @@ class Ocean(pulumi.CustomResource):
|
|
|
1880
1918
|
"""
|
|
1881
1919
|
return pulumi.get(self, "detach_load_balancers")
|
|
1882
1920
|
|
|
1883
|
-
@property
|
|
1921
|
+
@_builtins.property
|
|
1884
1922
|
@pulumi.getter(name="drainingTimeout")
|
|
1885
|
-
def draining_timeout(self) -> pulumi.Output[Optional[
|
|
1923
|
+
def draining_timeout(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1886
1924
|
"""
|
|
1887
1925
|
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
1926
|
"""
|
|
1889
1927
|
return pulumi.get(self, "draining_timeout")
|
|
1890
1928
|
|
|
1891
|
-
@property
|
|
1929
|
+
@_builtins.property
|
|
1892
1930
|
@pulumi.getter(name="ebsOptimized")
|
|
1893
|
-
def ebs_optimized(self) -> pulumi.Output[Optional[
|
|
1931
|
+
def ebs_optimized(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1894
1932
|
"""
|
|
1895
1933
|
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
1934
|
"""
|
|
1897
1935
|
return pulumi.get(self, "ebs_optimized")
|
|
1898
1936
|
|
|
1899
|
-
@property
|
|
1937
|
+
@_builtins.property
|
|
1900
1938
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1901
|
-
def fallback_to_ondemand(self) -> pulumi.Output[Optional[
|
|
1939
|
+
def fallback_to_ondemand(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1902
1940
|
"""
|
|
1903
1941
|
If not Spot instance markets are available, enable Ocean to launch On-Demand instances instead.
|
|
1904
1942
|
"""
|
|
1905
1943
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1906
1944
|
|
|
1907
|
-
@property
|
|
1945
|
+
@_builtins.property
|
|
1908
1946
|
@pulumi.getter
|
|
1909
1947
|
def filters(self) -> pulumi.Output[Optional['outputs.OceanFilters']]:
|
|
1910
1948
|
return pulumi.get(self, "filters")
|
|
1911
1949
|
|
|
1912
|
-
@property
|
|
1950
|
+
@_builtins.property
|
|
1913
1951
|
@pulumi.getter(name="gracePeriod")
|
|
1914
|
-
def grace_period(self) -> pulumi.Output[Optional[
|
|
1952
|
+
def grace_period(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1915
1953
|
"""
|
|
1916
1954
|
The amount of time, in seconds, after the instance has launched to start checking its health.
|
|
1917
1955
|
"""
|
|
1918
1956
|
return pulumi.get(self, "grace_period")
|
|
1919
1957
|
|
|
1920
|
-
@property
|
|
1958
|
+
@_builtins.property
|
|
1921
1959
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
1922
|
-
def health_check_unhealthy_duration_before_replacement(self) -> pulumi.Output[Optional[
|
|
1960
|
+
def health_check_unhealthy_duration_before_replacement(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1923
1961
|
"""
|
|
1924
1962
|
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
1963
|
"""
|
|
1926
1964
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
1927
1965
|
|
|
1928
|
-
@property
|
|
1966
|
+
@_builtins.property
|
|
1929
1967
|
@pulumi.getter(name="iamInstanceProfile")
|
|
1930
|
-
def iam_instance_profile(self) -> pulumi.Output[Optional[
|
|
1968
|
+
def iam_instance_profile(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1931
1969
|
"""
|
|
1932
1970
|
The instance profile iam role.
|
|
1933
1971
|
"""
|
|
1934
1972
|
return pulumi.get(self, "iam_instance_profile")
|
|
1935
1973
|
|
|
1936
|
-
@property
|
|
1974
|
+
@_builtins.property
|
|
1937
1975
|
@pulumi.getter(name="imageId")
|
|
1938
|
-
def image_id(self) -> pulumi.Output[
|
|
1976
|
+
def image_id(self) -> pulumi.Output[_builtins.str]:
|
|
1939
1977
|
"""
|
|
1940
1978
|
ID of the image used to launch the instances.
|
|
1941
1979
|
"""
|
|
1942
1980
|
return pulumi.get(self, "image_id")
|
|
1943
1981
|
|
|
1944
|
-
@property
|
|
1982
|
+
@_builtins.property
|
|
1945
1983
|
@pulumi.getter(name="instanceMetadataOptions")
|
|
1946
1984
|
def instance_metadata_options(self) -> pulumi.Output[Optional['outputs.OceanInstanceMetadataOptions']]:
|
|
1947
1985
|
"""
|
|
@@ -1949,7 +1987,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1949
1987
|
"""
|
|
1950
1988
|
return pulumi.get(self, "instance_metadata_options")
|
|
1951
1989
|
|
|
1952
|
-
@property
|
|
1990
|
+
@_builtins.property
|
|
1953
1991
|
@pulumi.getter(name="instanceStorePolicy")
|
|
1954
1992
|
def instance_store_policy(self) -> pulumi.Output[Optional['outputs.OceanInstanceStorePolicy']]:
|
|
1955
1993
|
"""
|
|
@@ -1957,15 +1995,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
1957
1995
|
"""
|
|
1958
1996
|
return pulumi.get(self, "instance_store_policy")
|
|
1959
1997
|
|
|
1960
|
-
@property
|
|
1998
|
+
@_builtins.property
|
|
1961
1999
|
@pulumi.getter(name="keyName")
|
|
1962
|
-
def key_name(self) -> pulumi.Output[Optional[
|
|
2000
|
+
def key_name(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1963
2001
|
"""
|
|
1964
2002
|
The key pair to attach the instances.
|
|
1965
2003
|
"""
|
|
1966
2004
|
return pulumi.get(self, "key_name")
|
|
1967
2005
|
|
|
1968
|
-
@property
|
|
2006
|
+
@_builtins.property
|
|
1969
2007
|
@pulumi.getter(name="loadBalancers")
|
|
1970
2008
|
def load_balancers(self) -> pulumi.Output[Optional[Sequence['outputs.OceanLoadBalancer']]]:
|
|
1971
2009
|
"""
|
|
@@ -1973,7 +2011,7 @@ class Ocean(pulumi.CustomResource):
|
|
|
1973
2011
|
"""
|
|
1974
2012
|
return pulumi.get(self, "load_balancers")
|
|
1975
2013
|
|
|
1976
|
-
@property
|
|
2014
|
+
@_builtins.property
|
|
1977
2015
|
@pulumi.getter
|
|
1978
2016
|
def logging(self) -> pulumi.Output[Optional['outputs.OceanLogging']]:
|
|
1979
2017
|
"""
|
|
@@ -1981,55 +2019,63 @@ class Ocean(pulumi.CustomResource):
|
|
|
1981
2019
|
"""
|
|
1982
2020
|
return pulumi.get(self, "logging")
|
|
1983
2021
|
|
|
1984
|
-
@property
|
|
2022
|
+
@_builtins.property
|
|
1985
2023
|
@pulumi.getter(name="maxSize")
|
|
1986
|
-
def max_size(self) -> pulumi.Output[Optional[
|
|
2024
|
+
def max_size(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1987
2025
|
"""
|
|
1988
2026
|
The upper limit of instances the cluster can scale up to.
|
|
1989
2027
|
"""
|
|
1990
2028
|
return pulumi.get(self, "max_size")
|
|
1991
2029
|
|
|
1992
|
-
@property
|
|
2030
|
+
@_builtins.property
|
|
1993
2031
|
@pulumi.getter(name="minSize")
|
|
1994
|
-
def min_size(self) -> pulumi.Output[
|
|
2032
|
+
def min_size(self) -> pulumi.Output[_builtins.int]:
|
|
1995
2033
|
"""
|
|
1996
2034
|
The lower limit of instances the cluster can scale down to.
|
|
1997
2035
|
"""
|
|
1998
2036
|
return pulumi.get(self, "min_size")
|
|
1999
2037
|
|
|
2000
|
-
@property
|
|
2038
|
+
@_builtins.property
|
|
2001
2039
|
@pulumi.getter
|
|
2002
|
-
def monitoring(self) -> pulumi.Output[Optional[
|
|
2040
|
+
def monitoring(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2003
2041
|
"""
|
|
2004
2042
|
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
2043
|
"""
|
|
2006
2044
|
return pulumi.get(self, "monitoring")
|
|
2007
2045
|
|
|
2008
|
-
@property
|
|
2046
|
+
@_builtins.property
|
|
2009
2047
|
@pulumi.getter
|
|
2010
|
-
def name(self) -> pulumi.Output[
|
|
2048
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
2011
2049
|
"""
|
|
2012
2050
|
The cluster name.
|
|
2013
2051
|
"""
|
|
2014
2052
|
return pulumi.get(self, "name")
|
|
2015
2053
|
|
|
2016
|
-
@property
|
|
2054
|
+
@_builtins.property
|
|
2055
|
+
@pulumi.getter(name="primaryIpv6")
|
|
2056
|
+
def primary_ipv6(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2057
|
+
"""
|
|
2058
|
+
Enables assignment of a primary IPv6 address to the cluster. This feature is only available when `associate_ipv6_address` is explicitly set to true. Additionally, the cluster must have been initially created as an EKS cluster in IPv6 mode.
|
|
2059
|
+
"""
|
|
2060
|
+
return pulumi.get(self, "primary_ipv6")
|
|
2061
|
+
|
|
2062
|
+
@_builtins.property
|
|
2017
2063
|
@pulumi.getter
|
|
2018
|
-
def region(self) -> pulumi.Output[Optional[
|
|
2064
|
+
def region(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
2019
2065
|
"""
|
|
2020
2066
|
The region the cluster will run in.
|
|
2021
2067
|
"""
|
|
2022
2068
|
return pulumi.get(self, "region")
|
|
2023
2069
|
|
|
2024
|
-
@property
|
|
2070
|
+
@_builtins.property
|
|
2025
2071
|
@pulumi.getter(name="reservedEnis")
|
|
2026
|
-
def reserved_enis(self) -> pulumi.Output[Optional[
|
|
2072
|
+
def reserved_enis(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
2027
2073
|
"""
|
|
2028
2074
|
Specifies the count of ENIs to reserve per instance type for scaling purposes.
|
|
2029
2075
|
"""
|
|
2030
2076
|
return pulumi.get(self, "reserved_enis")
|
|
2031
2077
|
|
|
2032
|
-
@property
|
|
2078
|
+
@_builtins.property
|
|
2033
2079
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
2034
2080
|
def resource_tag_specifications(self) -> pulumi.Output[Optional[Sequence['outputs.OceanResourceTagSpecification']]]:
|
|
2035
2081
|
"""
|
|
@@ -2037,15 +2083,15 @@ class Ocean(pulumi.CustomResource):
|
|
|
2037
2083
|
"""
|
|
2038
2084
|
return pulumi.get(self, "resource_tag_specifications")
|
|
2039
2085
|
|
|
2040
|
-
@property
|
|
2086
|
+
@_builtins.property
|
|
2041
2087
|
@pulumi.getter(name="rootVolumeSize")
|
|
2042
|
-
def root_volume_size(self) -> pulumi.Output[Optional[
|
|
2088
|
+
def root_volume_size(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
2043
2089
|
"""
|
|
2044
2090
|
The size (in Gb) to allocate for the root volume. Minimum `20`.
|
|
2045
2091
|
"""
|
|
2046
2092
|
return pulumi.get(self, "root_volume_size")
|
|
2047
2093
|
|
|
2048
|
-
@property
|
|
2094
|
+
@_builtins.property
|
|
2049
2095
|
@pulumi.getter(name="scheduledTasks")
|
|
2050
2096
|
def scheduled_tasks(self) -> pulumi.Output[Optional[Sequence['outputs.OceanScheduledTask']]]:
|
|
2051
2097
|
"""
|
|
@@ -2053,31 +2099,31 @@ class Ocean(pulumi.CustomResource):
|
|
|
2053
2099
|
"""
|
|
2054
2100
|
return pulumi.get(self, "scheduled_tasks")
|
|
2055
2101
|
|
|
2056
|
-
@property
|
|
2102
|
+
@_builtins.property
|
|
2057
2103
|
@pulumi.getter(name="securityGroups")
|
|
2058
|
-
def security_groups(self) -> pulumi.Output[Sequence[
|
|
2104
|
+
def security_groups(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
2059
2105
|
"""
|
|
2060
2106
|
One or more security group ids.
|
|
2061
2107
|
"""
|
|
2062
2108
|
return pulumi.get(self, "security_groups")
|
|
2063
2109
|
|
|
2064
|
-
@property
|
|
2110
|
+
@_builtins.property
|
|
2065
2111
|
@pulumi.getter(name="spotPercentage")
|
|
2066
|
-
def spot_percentage(self) -> pulumi.Output[Optional[
|
|
2112
|
+
def spot_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
2067
2113
|
"""
|
|
2068
2114
|
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
2115
|
"""
|
|
2070
2116
|
return pulumi.get(self, "spot_percentage")
|
|
2071
2117
|
|
|
2072
|
-
@property
|
|
2118
|
+
@_builtins.property
|
|
2073
2119
|
@pulumi.getter(name="spreadNodesBy")
|
|
2074
|
-
def spread_nodes_by(self) -> pulumi.Output[Optional[
|
|
2120
|
+
def spread_nodes_by(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
2075
2121
|
"""
|
|
2076
2122
|
Ocean will spread the nodes across markets by this value. Possible values: `vcpu` or `count`.
|
|
2077
2123
|
"""
|
|
2078
2124
|
return pulumi.get(self, "spread_nodes_by")
|
|
2079
2125
|
|
|
2080
|
-
@property
|
|
2126
|
+
@_builtins.property
|
|
2081
2127
|
@pulumi.getter(name="startupTaints")
|
|
2082
2128
|
def startup_taints(self) -> pulumi.Output[Optional[Sequence['outputs.OceanStartupTaint']]]:
|
|
2083
2129
|
"""
|
|
@@ -2085,16 +2131,16 @@ class Ocean(pulumi.CustomResource):
|
|
|
2085
2131
|
"""
|
|
2086
2132
|
return pulumi.get(self, "startup_taints")
|
|
2087
2133
|
|
|
2088
|
-
@property
|
|
2134
|
+
@_builtins.property
|
|
2089
2135
|
@pulumi.getter(name="subnetIds")
|
|
2090
|
-
def subnet_ids(self) -> pulumi.Output[Sequence[
|
|
2136
|
+
def subnet_ids(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
2091
2137
|
"""
|
|
2092
2138
|
A comma-separated list of subnet identifiers for the Ocean cluster. Subnet IDs should be configured with auto assign public IP.
|
|
2093
2139
|
* `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
|
|
2094
2140
|
"""
|
|
2095
2141
|
return pulumi.get(self, "subnet_ids")
|
|
2096
2142
|
|
|
2097
|
-
@property
|
|
2143
|
+
@_builtins.property
|
|
2098
2144
|
@pulumi.getter
|
|
2099
2145
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.OceanTag']]]:
|
|
2100
2146
|
"""
|
|
@@ -2102,46 +2148,46 @@ class Ocean(pulumi.CustomResource):
|
|
|
2102
2148
|
"""
|
|
2103
2149
|
return pulumi.get(self, "tags")
|
|
2104
2150
|
|
|
2105
|
-
@property
|
|
2151
|
+
@_builtins.property
|
|
2106
2152
|
@pulumi.getter(name="updatePolicy")
|
|
2107
2153
|
def update_policy(self) -> pulumi.Output[Optional['outputs.OceanUpdatePolicy']]:
|
|
2108
2154
|
return pulumi.get(self, "update_policy")
|
|
2109
2155
|
|
|
2110
|
-
@property
|
|
2156
|
+
@_builtins.property
|
|
2111
2157
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
2112
|
-
def use_as_template_only(self) -> pulumi.Output[Optional[
|
|
2158
|
+
def use_as_template_only(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2113
2159
|
"""
|
|
2114
2160
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
2115
2161
|
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
2162
|
"""
|
|
2117
2163
|
return pulumi.get(self, "use_as_template_only")
|
|
2118
2164
|
|
|
2119
|
-
@property
|
|
2165
|
+
@_builtins.property
|
|
2120
2166
|
@pulumi.getter(name="userData")
|
|
2121
|
-
def user_data(self) -> pulumi.Output[Optional[
|
|
2167
|
+
def user_data(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
2122
2168
|
"""
|
|
2123
2169
|
Base64-encoded MIME user data to make available to the instances.
|
|
2124
2170
|
"""
|
|
2125
2171
|
return pulumi.get(self, "user_data")
|
|
2126
2172
|
|
|
2127
|
-
@property
|
|
2173
|
+
@_builtins.property
|
|
2128
2174
|
@pulumi.getter(name="utilizeCommitments")
|
|
2129
|
-
def utilize_commitments(self) -> pulumi.Output[Optional[
|
|
2175
|
+
def utilize_commitments(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2130
2176
|
"""
|
|
2131
2177
|
If savings plans exist, Ocean will utilize them before launching Spot instances.
|
|
2132
2178
|
"""
|
|
2133
2179
|
return pulumi.get(self, "utilize_commitments")
|
|
2134
2180
|
|
|
2135
|
-
@property
|
|
2181
|
+
@_builtins.property
|
|
2136
2182
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
2137
|
-
def utilize_reserved_instances(self) -> pulumi.Output[Optional[
|
|
2183
|
+
def utilize_reserved_instances(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2138
2184
|
"""
|
|
2139
2185
|
If Reserved instances exist, Ocean will utilize them before launching Spot instances.
|
|
2140
2186
|
"""
|
|
2141
2187
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
2142
2188
|
|
|
2143
|
-
@property
|
|
2189
|
+
@_builtins.property
|
|
2144
2190
|
@pulumi.getter
|
|
2145
|
-
def whitelists(self) -> pulumi.Output[Optional[Sequence[
|
|
2191
|
+
def whitelists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
2146
2192
|
return pulumi.get(self, "whitelists")
|
|
2147
2193
|
|