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