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