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