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
|
@@ -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,42 +21,48 @@ __all__ = ['OceanImportArgs', 'OceanImport']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class OceanImportArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
cluster_name: pulumi.Input[str],
|
|
20
|
-
location: pulumi.Input[str],
|
|
24
|
+
cluster_name: pulumi.Input[_builtins.str],
|
|
25
|
+
location: pulumi.Input[_builtins.str],
|
|
26
|
+
auto_updates: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportAutoUpdateArgs']]]] = None,
|
|
21
27
|
autoscaler: Optional[pulumi.Input['OceanImportAutoscalerArgs']] = None,
|
|
22
28
|
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]]] = None,
|
|
23
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
24
|
-
controller_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
25
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
30
|
+
controller_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
32
|
+
filters: Optional[pulumi.Input['OceanImportFiltersArgs']] = None,
|
|
33
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
34
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
35
|
+
root_volume_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
29
36
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]]] = None,
|
|
30
37
|
shielded_instance_config: Optional[pulumi.Input['OceanImportShieldedInstanceConfigArgs']] = None,
|
|
31
38
|
strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]]] = None,
|
|
32
39
|
update_policy: Optional[pulumi.Input['OceanImportUpdatePolicyArgs']] = None,
|
|
33
|
-
use_as_template_only: Optional[pulumi.Input[bool]] = None,
|
|
34
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
40
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
41
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
35
42
|
"""
|
|
36
43
|
The set of arguments for constructing a OceanImport resource.
|
|
37
|
-
:param pulumi.Input[str] cluster_name: The GKE cluster name.
|
|
38
|
-
:param pulumi.Input[str] location: The zone the master cluster is located in.
|
|
44
|
+
:param pulumi.Input[_builtins.str] cluster_name: The GKE cluster name.
|
|
45
|
+
:param pulumi.Input[_builtins.str] location: The zone the master cluster is located in.
|
|
46
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanImportAutoUpdateArgs']]] auto_updates: The Ocean Kubernetes AutoUpdate object. If set to 'true', Ocean will ensure that your clusters have an up-to-date configuration according to the respective GKE cluster.
|
|
39
47
|
:param pulumi.Input['OceanImportAutoscalerArgs'] autoscaler: The Ocean Kubernetes Autoscaler object.
|
|
40
48
|
:param pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]] backend_services: Describes the backend service configurations.
|
|
41
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] blacklists: Instance types to avoid launching in the Ocean cluster. Cannot be configured if whitelist list is configured.
|
|
42
|
-
:param pulumi.Input[str] controller_cluster_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
43
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
44
|
-
:param pulumi.Input[
|
|
45
|
-
:param pulumi.Input[int]
|
|
46
|
-
:param pulumi.Input[
|
|
49
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] blacklists: Instance types to avoid launching in the Ocean cluster. Cannot be configured if whitelist list is configured.
|
|
50
|
+
:param pulumi.Input[_builtins.str] controller_cluster_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
51
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
52
|
+
:param pulumi.Input['OceanImportFiltersArgs'] filters: List of filters. The Instance types that match with all filters compose the Ocean's whitelist parameter. Cannot be configured together with whitelist/blacklist.
|
|
53
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
54
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
55
|
+
:param pulumi.Input[_builtins.str] root_volume_type: The root volume disk type.
|
|
47
56
|
:param pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]] scheduled_tasks: Set scheduling object.
|
|
48
57
|
:param pulumi.Input['OceanImportShieldedInstanceConfigArgs'] shielded_instance_config: The Ocean shielded instance configuration object.
|
|
49
58
|
:param pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]] strategies: Strategy object.
|
|
50
|
-
: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.
|
|
51
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
|
|
59
|
+
: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.
|
|
60
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
|
|
52
61
|
"""
|
|
53
62
|
pulumi.set(__self__, "cluster_name", cluster_name)
|
|
54
63
|
pulumi.set(__self__, "location", location)
|
|
64
|
+
if auto_updates is not None:
|
|
65
|
+
pulumi.set(__self__, "auto_updates", auto_updates)
|
|
55
66
|
if autoscaler is not None:
|
|
56
67
|
pulumi.set(__self__, "autoscaler", autoscaler)
|
|
57
68
|
if backend_services is not None:
|
|
@@ -62,6 +73,8 @@ class OceanImportArgs:
|
|
|
62
73
|
pulumi.set(__self__, "controller_cluster_id", controller_cluster_id)
|
|
63
74
|
if desired_capacity is not None:
|
|
64
75
|
pulumi.set(__self__, "desired_capacity", desired_capacity)
|
|
76
|
+
if filters is not None:
|
|
77
|
+
pulumi.set(__self__, "filters", filters)
|
|
65
78
|
if max_size is not None:
|
|
66
79
|
pulumi.set(__self__, "max_size", max_size)
|
|
67
80
|
if min_size is not None:
|
|
@@ -81,31 +94,43 @@ class OceanImportArgs:
|
|
|
81
94
|
if whitelists is not None:
|
|
82
95
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
83
96
|
|
|
84
|
-
@property
|
|
97
|
+
@_builtins.property
|
|
85
98
|
@pulumi.getter(name="clusterName")
|
|
86
|
-
def cluster_name(self) -> pulumi.Input[str]:
|
|
99
|
+
def cluster_name(self) -> pulumi.Input[_builtins.str]:
|
|
87
100
|
"""
|
|
88
101
|
The GKE cluster name.
|
|
89
102
|
"""
|
|
90
103
|
return pulumi.get(self, "cluster_name")
|
|
91
104
|
|
|
92
105
|
@cluster_name.setter
|
|
93
|
-
def cluster_name(self, value: pulumi.Input[str]):
|
|
106
|
+
def cluster_name(self, value: pulumi.Input[_builtins.str]):
|
|
94
107
|
pulumi.set(self, "cluster_name", value)
|
|
95
108
|
|
|
96
|
-
@property
|
|
109
|
+
@_builtins.property
|
|
97
110
|
@pulumi.getter
|
|
98
|
-
def location(self) -> pulumi.Input[str]:
|
|
111
|
+
def location(self) -> pulumi.Input[_builtins.str]:
|
|
99
112
|
"""
|
|
100
113
|
The zone the master cluster is located in.
|
|
101
114
|
"""
|
|
102
115
|
return pulumi.get(self, "location")
|
|
103
116
|
|
|
104
117
|
@location.setter
|
|
105
|
-
def location(self, value: pulumi.Input[str]):
|
|
118
|
+
def location(self, value: pulumi.Input[_builtins.str]):
|
|
106
119
|
pulumi.set(self, "location", value)
|
|
107
120
|
|
|
108
|
-
@property
|
|
121
|
+
@_builtins.property
|
|
122
|
+
@pulumi.getter(name="autoUpdates")
|
|
123
|
+
def auto_updates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportAutoUpdateArgs']]]]:
|
|
124
|
+
"""
|
|
125
|
+
The Ocean Kubernetes AutoUpdate object. If set to 'true', Ocean will ensure that your clusters have an up-to-date configuration according to the respective GKE cluster.
|
|
126
|
+
"""
|
|
127
|
+
return pulumi.get(self, "auto_updates")
|
|
128
|
+
|
|
129
|
+
@auto_updates.setter
|
|
130
|
+
def auto_updates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportAutoUpdateArgs']]]]):
|
|
131
|
+
pulumi.set(self, "auto_updates", value)
|
|
132
|
+
|
|
133
|
+
@_builtins.property
|
|
109
134
|
@pulumi.getter
|
|
110
135
|
def autoscaler(self) -> Optional[pulumi.Input['OceanImportAutoscalerArgs']]:
|
|
111
136
|
"""
|
|
@@ -117,7 +142,7 @@ class OceanImportArgs:
|
|
|
117
142
|
def autoscaler(self, value: Optional[pulumi.Input['OceanImportAutoscalerArgs']]):
|
|
118
143
|
pulumi.set(self, "autoscaler", value)
|
|
119
144
|
|
|
120
|
-
@property
|
|
145
|
+
@_builtins.property
|
|
121
146
|
@pulumi.getter(name="backendServices")
|
|
122
147
|
def backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]]]:
|
|
123
148
|
"""
|
|
@@ -129,79 +154,91 @@ class OceanImportArgs:
|
|
|
129
154
|
def backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]]]):
|
|
130
155
|
pulumi.set(self, "backend_services", value)
|
|
131
156
|
|
|
132
|
-
@property
|
|
157
|
+
@_builtins.property
|
|
133
158
|
@pulumi.getter
|
|
134
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
159
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
135
160
|
"""
|
|
136
161
|
Instance types to avoid launching in the Ocean cluster. Cannot be configured if whitelist list is configured.
|
|
137
162
|
"""
|
|
138
163
|
return pulumi.get(self, "blacklists")
|
|
139
164
|
|
|
140
165
|
@blacklists.setter
|
|
141
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
166
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
142
167
|
pulumi.set(self, "blacklists", value)
|
|
143
168
|
|
|
144
|
-
@property
|
|
169
|
+
@_builtins.property
|
|
145
170
|
@pulumi.getter(name="controllerClusterId")
|
|
146
|
-
def controller_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
171
|
+
def controller_cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
147
172
|
"""
|
|
148
173
|
A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
149
174
|
"""
|
|
150
175
|
return pulumi.get(self, "controller_cluster_id")
|
|
151
176
|
|
|
152
177
|
@controller_cluster_id.setter
|
|
153
|
-
def controller_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
178
|
+
def controller_cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
154
179
|
pulumi.set(self, "controller_cluster_id", value)
|
|
155
180
|
|
|
156
|
-
@property
|
|
181
|
+
@_builtins.property
|
|
157
182
|
@pulumi.getter(name="desiredCapacity")
|
|
158
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
183
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
159
184
|
"""
|
|
160
185
|
The number of instances to launch and maintain in the cluster.
|
|
161
186
|
"""
|
|
162
187
|
return pulumi.get(self, "desired_capacity")
|
|
163
188
|
|
|
164
189
|
@desired_capacity.setter
|
|
165
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
190
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
166
191
|
pulumi.set(self, "desired_capacity", value)
|
|
167
192
|
|
|
168
|
-
@property
|
|
193
|
+
@_builtins.property
|
|
194
|
+
@pulumi.getter
|
|
195
|
+
def filters(self) -> Optional[pulumi.Input['OceanImportFiltersArgs']]:
|
|
196
|
+
"""
|
|
197
|
+
List of filters. The Instance types that match with all filters compose the Ocean's whitelist parameter. Cannot be configured together with whitelist/blacklist.
|
|
198
|
+
"""
|
|
199
|
+
return pulumi.get(self, "filters")
|
|
200
|
+
|
|
201
|
+
@filters.setter
|
|
202
|
+
def filters(self, value: Optional[pulumi.Input['OceanImportFiltersArgs']]):
|
|
203
|
+
pulumi.set(self, "filters", value)
|
|
204
|
+
|
|
205
|
+
@_builtins.property
|
|
169
206
|
@pulumi.getter(name="maxSize")
|
|
170
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
207
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
171
208
|
"""
|
|
172
209
|
The upper limit of instances the cluster can scale up to.
|
|
173
210
|
"""
|
|
174
211
|
return pulumi.get(self, "max_size")
|
|
175
212
|
|
|
176
213
|
@max_size.setter
|
|
177
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
214
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
178
215
|
pulumi.set(self, "max_size", value)
|
|
179
216
|
|
|
180
|
-
@property
|
|
217
|
+
@_builtins.property
|
|
181
218
|
@pulumi.getter(name="minSize")
|
|
182
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
219
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
183
220
|
"""
|
|
184
221
|
The lower limit of instances the cluster can scale down to.
|
|
185
222
|
"""
|
|
186
223
|
return pulumi.get(self, "min_size")
|
|
187
224
|
|
|
188
225
|
@min_size.setter
|
|
189
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
226
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
190
227
|
pulumi.set(self, "min_size", value)
|
|
191
228
|
|
|
192
|
-
@property
|
|
229
|
+
@_builtins.property
|
|
193
230
|
@pulumi.getter(name="rootVolumeType")
|
|
194
|
-
def root_volume_type(self) -> Optional[pulumi.Input[str]]:
|
|
231
|
+
def root_volume_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
195
232
|
"""
|
|
196
233
|
The root volume disk type.
|
|
197
234
|
"""
|
|
198
235
|
return pulumi.get(self, "root_volume_type")
|
|
199
236
|
|
|
200
237
|
@root_volume_type.setter
|
|
201
|
-
def root_volume_type(self, value: Optional[pulumi.Input[str]]):
|
|
238
|
+
def root_volume_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
202
239
|
pulumi.set(self, "root_volume_type", value)
|
|
203
240
|
|
|
204
|
-
@property
|
|
241
|
+
@_builtins.property
|
|
205
242
|
@pulumi.getter(name="scheduledTasks")
|
|
206
243
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]]]:
|
|
207
244
|
"""
|
|
@@ -213,7 +250,7 @@ class OceanImportArgs:
|
|
|
213
250
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]]]):
|
|
214
251
|
pulumi.set(self, "scheduled_tasks", value)
|
|
215
252
|
|
|
216
|
-
@property
|
|
253
|
+
@_builtins.property
|
|
217
254
|
@pulumi.getter(name="shieldedInstanceConfig")
|
|
218
255
|
def shielded_instance_config(self) -> Optional[pulumi.Input['OceanImportShieldedInstanceConfigArgs']]:
|
|
219
256
|
"""
|
|
@@ -225,7 +262,7 @@ class OceanImportArgs:
|
|
|
225
262
|
def shielded_instance_config(self, value: Optional[pulumi.Input['OceanImportShieldedInstanceConfigArgs']]):
|
|
226
263
|
pulumi.set(self, "shielded_instance_config", value)
|
|
227
264
|
|
|
228
|
-
@property
|
|
265
|
+
@_builtins.property
|
|
229
266
|
@pulumi.getter
|
|
230
267
|
def strategies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]]]:
|
|
231
268
|
"""
|
|
@@ -237,7 +274,7 @@ class OceanImportArgs:
|
|
|
237
274
|
def strategies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]]]):
|
|
238
275
|
pulumi.set(self, "strategies", value)
|
|
239
276
|
|
|
240
|
-
@property
|
|
277
|
+
@_builtins.property
|
|
241
278
|
@pulumi.getter(name="updatePolicy")
|
|
242
279
|
def update_policy(self) -> Optional[pulumi.Input['OceanImportUpdatePolicyArgs']]:
|
|
243
280
|
return pulumi.get(self, "update_policy")
|
|
@@ -246,69 +283,75 @@ class OceanImportArgs:
|
|
|
246
283
|
def update_policy(self, value: Optional[pulumi.Input['OceanImportUpdatePolicyArgs']]):
|
|
247
284
|
pulumi.set(self, "update_policy", value)
|
|
248
285
|
|
|
249
|
-
@property
|
|
286
|
+
@_builtins.property
|
|
250
287
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
251
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[bool]]:
|
|
288
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
252
289
|
"""
|
|
253
290
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
254
291
|
"""
|
|
255
292
|
return pulumi.get(self, "use_as_template_only")
|
|
256
293
|
|
|
257
294
|
@use_as_template_only.setter
|
|
258
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[bool]]):
|
|
295
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
259
296
|
pulumi.set(self, "use_as_template_only", value)
|
|
260
297
|
|
|
261
|
-
@property
|
|
298
|
+
@_builtins.property
|
|
262
299
|
@pulumi.getter
|
|
263
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
300
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
264
301
|
"""
|
|
265
302
|
Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
|
|
266
303
|
"""
|
|
267
304
|
return pulumi.get(self, "whitelists")
|
|
268
305
|
|
|
269
306
|
@whitelists.setter
|
|
270
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
307
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
271
308
|
pulumi.set(self, "whitelists", value)
|
|
272
309
|
|
|
273
310
|
|
|
274
311
|
@pulumi.input_type
|
|
275
312
|
class _OceanImportState:
|
|
276
313
|
def __init__(__self__, *,
|
|
314
|
+
auto_updates: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportAutoUpdateArgs']]]] = None,
|
|
277
315
|
autoscaler: Optional[pulumi.Input['OceanImportAutoscalerArgs']] = None,
|
|
278
316
|
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]]] = None,
|
|
279
|
-
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
280
|
-
cluster_controller_id: Optional[pulumi.Input[str]] = None,
|
|
281
|
-
cluster_name: Optional[pulumi.Input[str]] = None,
|
|
282
|
-
controller_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
283
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
317
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
318
|
+
cluster_controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
319
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
320
|
+
controller_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
321
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
322
|
+
filters: Optional[pulumi.Input['OceanImportFiltersArgs']] = None,
|
|
323
|
+
location: Optional[pulumi.Input[_builtins.str]] = None,
|
|
324
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
325
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
326
|
+
root_volume_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
288
327
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]]] = None,
|
|
289
328
|
shielded_instance_config: Optional[pulumi.Input['OceanImportShieldedInstanceConfigArgs']] = None,
|
|
290
329
|
strategies: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]]] = None,
|
|
291
330
|
update_policy: Optional[pulumi.Input['OceanImportUpdatePolicyArgs']] = None,
|
|
292
|
-
use_as_template_only: Optional[pulumi.Input[bool]] = None,
|
|
293
|
-
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
331
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
332
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
294
333
|
"""
|
|
295
334
|
Input properties used for looking up and filtering OceanImport resources.
|
|
335
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanImportAutoUpdateArgs']]] auto_updates: The Ocean Kubernetes AutoUpdate object. If set to 'true', Ocean will ensure that your clusters have an up-to-date configuration according to the respective GKE cluster.
|
|
296
336
|
:param pulumi.Input['OceanImportAutoscalerArgs'] autoscaler: The Ocean Kubernetes Autoscaler object.
|
|
297
337
|
:param pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]] backend_services: Describes the backend service configurations.
|
|
298
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] blacklists: Instance types to avoid launching in the Ocean cluster. Cannot be configured if whitelist list is configured.
|
|
299
|
-
:param pulumi.Input[str] cluster_name: The GKE cluster name.
|
|
300
|
-
:param pulumi.Input[str] controller_cluster_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
301
|
-
:param pulumi.Input[int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
302
|
-
:param pulumi.Input[
|
|
303
|
-
:param pulumi.Input[
|
|
304
|
-
:param pulumi.Input[int]
|
|
305
|
-
:param pulumi.Input[
|
|
338
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] blacklists: Instance types to avoid launching in the Ocean cluster. Cannot be configured if whitelist list is configured.
|
|
339
|
+
:param pulumi.Input[_builtins.str] cluster_name: The GKE cluster name.
|
|
340
|
+
:param pulumi.Input[_builtins.str] controller_cluster_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
341
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
342
|
+
:param pulumi.Input['OceanImportFiltersArgs'] filters: List of filters. The Instance types that match with all filters compose the Ocean's whitelist parameter. Cannot be configured together with whitelist/blacklist.
|
|
343
|
+
:param pulumi.Input[_builtins.str] location: The zone the master cluster is located in.
|
|
344
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
345
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
346
|
+
:param pulumi.Input[_builtins.str] root_volume_type: The root volume disk type.
|
|
306
347
|
:param pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]] scheduled_tasks: Set scheduling object.
|
|
307
348
|
:param pulumi.Input['OceanImportShieldedInstanceConfigArgs'] shielded_instance_config: The Ocean shielded instance configuration object.
|
|
308
349
|
:param pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]] strategies: Strategy object.
|
|
309
|
-
: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.
|
|
310
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
|
|
350
|
+
: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.
|
|
351
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
|
|
311
352
|
"""
|
|
353
|
+
if auto_updates is not None:
|
|
354
|
+
pulumi.set(__self__, "auto_updates", auto_updates)
|
|
312
355
|
if autoscaler is not None:
|
|
313
356
|
pulumi.set(__self__, "autoscaler", autoscaler)
|
|
314
357
|
if backend_services is not None:
|
|
@@ -323,6 +366,8 @@ class _OceanImportState:
|
|
|
323
366
|
pulumi.set(__self__, "controller_cluster_id", controller_cluster_id)
|
|
324
367
|
if desired_capacity is not None:
|
|
325
368
|
pulumi.set(__self__, "desired_capacity", desired_capacity)
|
|
369
|
+
if filters is not None:
|
|
370
|
+
pulumi.set(__self__, "filters", filters)
|
|
326
371
|
if location is not None:
|
|
327
372
|
pulumi.set(__self__, "location", location)
|
|
328
373
|
if max_size is not None:
|
|
@@ -344,7 +389,19 @@ class _OceanImportState:
|
|
|
344
389
|
if whitelists is not None:
|
|
345
390
|
pulumi.set(__self__, "whitelists", whitelists)
|
|
346
391
|
|
|
347
|
-
@property
|
|
392
|
+
@_builtins.property
|
|
393
|
+
@pulumi.getter(name="autoUpdates")
|
|
394
|
+
def auto_updates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportAutoUpdateArgs']]]]:
|
|
395
|
+
"""
|
|
396
|
+
The Ocean Kubernetes AutoUpdate object. If set to 'true', Ocean will ensure that your clusters have an up-to-date configuration according to the respective GKE cluster.
|
|
397
|
+
"""
|
|
398
|
+
return pulumi.get(self, "auto_updates")
|
|
399
|
+
|
|
400
|
+
@auto_updates.setter
|
|
401
|
+
def auto_updates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportAutoUpdateArgs']]]]):
|
|
402
|
+
pulumi.set(self, "auto_updates", value)
|
|
403
|
+
|
|
404
|
+
@_builtins.property
|
|
348
405
|
@pulumi.getter
|
|
349
406
|
def autoscaler(self) -> Optional[pulumi.Input['OceanImportAutoscalerArgs']]:
|
|
350
407
|
"""
|
|
@@ -356,7 +413,7 @@ class _OceanImportState:
|
|
|
356
413
|
def autoscaler(self, value: Optional[pulumi.Input['OceanImportAutoscalerArgs']]):
|
|
357
414
|
pulumi.set(self, "autoscaler", value)
|
|
358
415
|
|
|
359
|
-
@property
|
|
416
|
+
@_builtins.property
|
|
360
417
|
@pulumi.getter(name="backendServices")
|
|
361
418
|
def backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]]]:
|
|
362
419
|
"""
|
|
@@ -368,112 +425,124 @@ class _OceanImportState:
|
|
|
368
425
|
def backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceArgs']]]]):
|
|
369
426
|
pulumi.set(self, "backend_services", value)
|
|
370
427
|
|
|
371
|
-
@property
|
|
428
|
+
@_builtins.property
|
|
372
429
|
@pulumi.getter
|
|
373
|
-
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
430
|
+
def blacklists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
374
431
|
"""
|
|
375
432
|
Instance types to avoid launching in the Ocean cluster. Cannot be configured if whitelist list is configured.
|
|
376
433
|
"""
|
|
377
434
|
return pulumi.get(self, "blacklists")
|
|
378
435
|
|
|
379
436
|
@blacklists.setter
|
|
380
|
-
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
437
|
+
def blacklists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
381
438
|
pulumi.set(self, "blacklists", value)
|
|
382
439
|
|
|
383
|
-
@property
|
|
440
|
+
@_builtins.property
|
|
384
441
|
@pulumi.getter(name="clusterControllerId")
|
|
385
|
-
def cluster_controller_id(self) -> Optional[pulumi.Input[str]]:
|
|
442
|
+
def cluster_controller_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
386
443
|
return pulumi.get(self, "cluster_controller_id")
|
|
387
444
|
|
|
388
445
|
@cluster_controller_id.setter
|
|
389
|
-
def cluster_controller_id(self, value: Optional[pulumi.Input[str]]):
|
|
446
|
+
def cluster_controller_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
390
447
|
pulumi.set(self, "cluster_controller_id", value)
|
|
391
448
|
|
|
392
|
-
@property
|
|
449
|
+
@_builtins.property
|
|
393
450
|
@pulumi.getter(name="clusterName")
|
|
394
|
-
def cluster_name(self) -> Optional[pulumi.Input[str]]:
|
|
451
|
+
def cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
395
452
|
"""
|
|
396
453
|
The GKE cluster name.
|
|
397
454
|
"""
|
|
398
455
|
return pulumi.get(self, "cluster_name")
|
|
399
456
|
|
|
400
457
|
@cluster_name.setter
|
|
401
|
-
def cluster_name(self, value: Optional[pulumi.Input[str]]):
|
|
458
|
+
def cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
402
459
|
pulumi.set(self, "cluster_name", value)
|
|
403
460
|
|
|
404
|
-
@property
|
|
461
|
+
@_builtins.property
|
|
405
462
|
@pulumi.getter(name="controllerClusterId")
|
|
406
|
-
def controller_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
463
|
+
def controller_cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
407
464
|
"""
|
|
408
465
|
A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
409
466
|
"""
|
|
410
467
|
return pulumi.get(self, "controller_cluster_id")
|
|
411
468
|
|
|
412
469
|
@controller_cluster_id.setter
|
|
413
|
-
def controller_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
470
|
+
def controller_cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
414
471
|
pulumi.set(self, "controller_cluster_id", value)
|
|
415
472
|
|
|
416
|
-
@property
|
|
473
|
+
@_builtins.property
|
|
417
474
|
@pulumi.getter(name="desiredCapacity")
|
|
418
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
475
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
419
476
|
"""
|
|
420
477
|
The number of instances to launch and maintain in the cluster.
|
|
421
478
|
"""
|
|
422
479
|
return pulumi.get(self, "desired_capacity")
|
|
423
480
|
|
|
424
481
|
@desired_capacity.setter
|
|
425
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
482
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
426
483
|
pulumi.set(self, "desired_capacity", value)
|
|
427
484
|
|
|
428
|
-
@property
|
|
485
|
+
@_builtins.property
|
|
429
486
|
@pulumi.getter
|
|
430
|
-
def
|
|
487
|
+
def filters(self) -> Optional[pulumi.Input['OceanImportFiltersArgs']]:
|
|
488
|
+
"""
|
|
489
|
+
List of filters. The Instance types that match with all filters compose the Ocean's whitelist parameter. Cannot be configured together with whitelist/blacklist.
|
|
490
|
+
"""
|
|
491
|
+
return pulumi.get(self, "filters")
|
|
492
|
+
|
|
493
|
+
@filters.setter
|
|
494
|
+
def filters(self, value: Optional[pulumi.Input['OceanImportFiltersArgs']]):
|
|
495
|
+
pulumi.set(self, "filters", value)
|
|
496
|
+
|
|
497
|
+
@_builtins.property
|
|
498
|
+
@pulumi.getter
|
|
499
|
+
def location(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
431
500
|
"""
|
|
432
501
|
The zone the master cluster is located in.
|
|
433
502
|
"""
|
|
434
503
|
return pulumi.get(self, "location")
|
|
435
504
|
|
|
436
505
|
@location.setter
|
|
437
|
-
def location(self, value: Optional[pulumi.Input[str]]):
|
|
506
|
+
def location(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
438
507
|
pulumi.set(self, "location", value)
|
|
439
508
|
|
|
440
|
-
@property
|
|
509
|
+
@_builtins.property
|
|
441
510
|
@pulumi.getter(name="maxSize")
|
|
442
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
511
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
443
512
|
"""
|
|
444
513
|
The upper limit of instances the cluster can scale up to.
|
|
445
514
|
"""
|
|
446
515
|
return pulumi.get(self, "max_size")
|
|
447
516
|
|
|
448
517
|
@max_size.setter
|
|
449
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
518
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
450
519
|
pulumi.set(self, "max_size", value)
|
|
451
520
|
|
|
452
|
-
@property
|
|
521
|
+
@_builtins.property
|
|
453
522
|
@pulumi.getter(name="minSize")
|
|
454
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
523
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
455
524
|
"""
|
|
456
525
|
The lower limit of instances the cluster can scale down to.
|
|
457
526
|
"""
|
|
458
527
|
return pulumi.get(self, "min_size")
|
|
459
528
|
|
|
460
529
|
@min_size.setter
|
|
461
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
530
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
462
531
|
pulumi.set(self, "min_size", value)
|
|
463
532
|
|
|
464
|
-
@property
|
|
533
|
+
@_builtins.property
|
|
465
534
|
@pulumi.getter(name="rootVolumeType")
|
|
466
|
-
def root_volume_type(self) -> Optional[pulumi.Input[str]]:
|
|
535
|
+
def root_volume_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
467
536
|
"""
|
|
468
537
|
The root volume disk type.
|
|
469
538
|
"""
|
|
470
539
|
return pulumi.get(self, "root_volume_type")
|
|
471
540
|
|
|
472
541
|
@root_volume_type.setter
|
|
473
|
-
def root_volume_type(self, value: Optional[pulumi.Input[str]]):
|
|
542
|
+
def root_volume_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
474
543
|
pulumi.set(self, "root_volume_type", value)
|
|
475
544
|
|
|
476
|
-
@property
|
|
545
|
+
@_builtins.property
|
|
477
546
|
@pulumi.getter(name="scheduledTasks")
|
|
478
547
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]]]:
|
|
479
548
|
"""
|
|
@@ -485,7 +554,7 @@ class _OceanImportState:
|
|
|
485
554
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskArgs']]]]):
|
|
486
555
|
pulumi.set(self, "scheduled_tasks", value)
|
|
487
556
|
|
|
488
|
-
@property
|
|
557
|
+
@_builtins.property
|
|
489
558
|
@pulumi.getter(name="shieldedInstanceConfig")
|
|
490
559
|
def shielded_instance_config(self) -> Optional[pulumi.Input['OceanImportShieldedInstanceConfigArgs']]:
|
|
491
560
|
"""
|
|
@@ -497,7 +566,7 @@ class _OceanImportState:
|
|
|
497
566
|
def shielded_instance_config(self, value: Optional[pulumi.Input['OceanImportShieldedInstanceConfigArgs']]):
|
|
498
567
|
pulumi.set(self, "shielded_instance_config", value)
|
|
499
568
|
|
|
500
|
-
@property
|
|
569
|
+
@_builtins.property
|
|
501
570
|
@pulumi.getter
|
|
502
571
|
def strategies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]]]:
|
|
503
572
|
"""
|
|
@@ -509,7 +578,7 @@ class _OceanImportState:
|
|
|
509
578
|
def strategies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportStrategyArgs']]]]):
|
|
510
579
|
pulumi.set(self, "strategies", value)
|
|
511
580
|
|
|
512
|
-
@property
|
|
581
|
+
@_builtins.property
|
|
513
582
|
@pulumi.getter(name="updatePolicy")
|
|
514
583
|
def update_policy(self) -> Optional[pulumi.Input['OceanImportUpdatePolicyArgs']]:
|
|
515
584
|
return pulumi.get(self, "update_policy")
|
|
@@ -518,56 +587,57 @@ class _OceanImportState:
|
|
|
518
587
|
def update_policy(self, value: Optional[pulumi.Input['OceanImportUpdatePolicyArgs']]):
|
|
519
588
|
pulumi.set(self, "update_policy", value)
|
|
520
589
|
|
|
521
|
-
@property
|
|
590
|
+
@_builtins.property
|
|
522
591
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
523
|
-
def use_as_template_only(self) -> Optional[pulumi.Input[bool]]:
|
|
592
|
+
def use_as_template_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
524
593
|
"""
|
|
525
594
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
526
595
|
"""
|
|
527
596
|
return pulumi.get(self, "use_as_template_only")
|
|
528
597
|
|
|
529
598
|
@use_as_template_only.setter
|
|
530
|
-
def use_as_template_only(self, value: Optional[pulumi.Input[bool]]):
|
|
599
|
+
def use_as_template_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
531
600
|
pulumi.set(self, "use_as_template_only", value)
|
|
532
601
|
|
|
533
|
-
@property
|
|
602
|
+
@_builtins.property
|
|
534
603
|
@pulumi.getter
|
|
535
|
-
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
604
|
+
def whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
536
605
|
"""
|
|
537
606
|
Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
|
|
538
607
|
"""
|
|
539
608
|
return pulumi.get(self, "whitelists")
|
|
540
609
|
|
|
541
610
|
@whitelists.setter
|
|
542
|
-
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
611
|
+
def whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
543
612
|
pulumi.set(self, "whitelists", value)
|
|
544
613
|
|
|
545
614
|
|
|
615
|
+
@pulumi.type_token("spotinst:gke/oceanImport:OceanImport")
|
|
546
616
|
class OceanImport(pulumi.CustomResource):
|
|
547
617
|
@overload
|
|
548
618
|
def __init__(__self__,
|
|
549
619
|
resource_name: str,
|
|
550
620
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
621
|
+
auto_updates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportAutoUpdateArgs', 'OceanImportAutoUpdateArgsDict']]]]] = None,
|
|
622
|
+
autoscaler: Optional[pulumi.Input[Union['OceanImportAutoscalerArgs', 'OceanImportAutoscalerArgsDict']]] = None,
|
|
623
|
+
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportBackendServiceArgs', 'OceanImportBackendServiceArgsDict']]]]] = None,
|
|
624
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
625
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
626
|
+
controller_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
627
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
628
|
+
filters: Optional[pulumi.Input[Union['OceanImportFiltersArgs', 'OceanImportFiltersArgsDict']]] = None,
|
|
629
|
+
location: Optional[pulumi.Input[_builtins.str]] = None,
|
|
630
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
631
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
632
|
+
root_volume_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
633
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportScheduledTaskArgs', 'OceanImportScheduledTaskArgsDict']]]]] = None,
|
|
634
|
+
shielded_instance_config: Optional[pulumi.Input[Union['OceanImportShieldedInstanceConfigArgs', 'OceanImportShieldedInstanceConfigArgsDict']]] = None,
|
|
635
|
+
strategies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportStrategyArgs', 'OceanImportStrategyArgsDict']]]]] = None,
|
|
636
|
+
update_policy: Optional[pulumi.Input[Union['OceanImportUpdatePolicyArgs', 'OceanImportUpdatePolicyArgsDict']]] = None,
|
|
637
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
638
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
567
639
|
__props__=None):
|
|
568
640
|
"""
|
|
569
|
-
Manages a Spotinst Ocean GKE resource.
|
|
570
|
-
|
|
571
641
|
## Example Usage
|
|
572
642
|
|
|
573
643
|
```python
|
|
@@ -581,47 +651,63 @@ class OceanImport(pulumi.CustomResource):
|
|
|
581
651
|
min_size=0,
|
|
582
652
|
max_size=2,
|
|
583
653
|
desired_capacity=0,
|
|
654
|
+
auto_updates=[{
|
|
655
|
+
"is_enabled": True,
|
|
656
|
+
}],
|
|
584
657
|
whitelists=[
|
|
585
658
|
"n1-standard-1",
|
|
586
659
|
"n1-standard-2",
|
|
587
660
|
],
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
661
|
+
filters={
|
|
662
|
+
"exclude_families": ["n2"],
|
|
663
|
+
"include_families": [
|
|
664
|
+
"c2",
|
|
665
|
+
"c3",
|
|
666
|
+
],
|
|
667
|
+
"min_memory_gib": 8,
|
|
668
|
+
"max_memory_gib": 16,
|
|
669
|
+
"min_vcpu": 2,
|
|
670
|
+
"max_vcpu": 16,
|
|
671
|
+
},
|
|
672
|
+
backend_services=[{
|
|
673
|
+
"service_name": "example-backend-service",
|
|
674
|
+
"location_type": "regional",
|
|
675
|
+
"scheme": "INTERNAL",
|
|
676
|
+
"named_ports": [{
|
|
677
|
+
"name": "http",
|
|
678
|
+
"ports": [
|
|
595
679
|
"80",
|
|
596
680
|
"8080",
|
|
597
681
|
],
|
|
598
|
-
|
|
599
|
-
|
|
682
|
+
}],
|
|
683
|
+
}],
|
|
600
684
|
root_volume_type="pd-ssd",
|
|
601
|
-
shielded_instance_config=
|
|
602
|
-
enable_secure_boot
|
|
603
|
-
enable_integrity_monitoring
|
|
604
|
-
|
|
685
|
+
shielded_instance_config={
|
|
686
|
+
"enable_secure_boot": True,
|
|
687
|
+
"enable_integrity_monitoring": True,
|
|
688
|
+
},
|
|
605
689
|
use_as_template_only=False)
|
|
606
690
|
```
|
|
607
691
|
|
|
608
692
|
:param str resource_name: The name of the resource.
|
|
609
693
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
610
|
-
:param pulumi.Input[pulumi.
|
|
611
|
-
:param pulumi.Input[
|
|
612
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
613
|
-
:param pulumi.Input[str]
|
|
614
|
-
:param pulumi.Input[str]
|
|
615
|
-
:param pulumi.Input[
|
|
616
|
-
:param pulumi.Input[
|
|
617
|
-
:param pulumi.Input[
|
|
618
|
-
:param pulumi.Input[
|
|
619
|
-
:param pulumi.Input[
|
|
620
|
-
:param pulumi.Input[
|
|
621
|
-
:param pulumi.Input[
|
|
622
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
623
|
-
:param pulumi.Input[
|
|
624
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
694
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanImportAutoUpdateArgs', 'OceanImportAutoUpdateArgsDict']]]] auto_updates: The Ocean Kubernetes AutoUpdate object. If set to 'true', Ocean will ensure that your clusters have an up-to-date configuration according to the respective GKE cluster.
|
|
695
|
+
:param pulumi.Input[Union['OceanImportAutoscalerArgs', 'OceanImportAutoscalerArgsDict']] autoscaler: The Ocean Kubernetes Autoscaler object.
|
|
696
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanImportBackendServiceArgs', 'OceanImportBackendServiceArgsDict']]]] backend_services: Describes the backend service configurations.
|
|
697
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] blacklists: Instance types to avoid launching in the Ocean cluster. Cannot be configured if whitelist list is configured.
|
|
698
|
+
:param pulumi.Input[_builtins.str] cluster_name: The GKE cluster name.
|
|
699
|
+
:param pulumi.Input[_builtins.str] controller_cluster_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
700
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
701
|
+
:param pulumi.Input[Union['OceanImportFiltersArgs', 'OceanImportFiltersArgsDict']] filters: List of filters. The Instance types that match with all filters compose the Ocean's whitelist parameter. Cannot be configured together with whitelist/blacklist.
|
|
702
|
+
:param pulumi.Input[_builtins.str] location: The zone the master cluster is located in.
|
|
703
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
704
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
705
|
+
:param pulumi.Input[_builtins.str] root_volume_type: The root volume disk type.
|
|
706
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanImportScheduledTaskArgs', 'OceanImportScheduledTaskArgsDict']]]] scheduled_tasks: Set scheduling object.
|
|
707
|
+
:param pulumi.Input[Union['OceanImportShieldedInstanceConfigArgs', 'OceanImportShieldedInstanceConfigArgsDict']] shielded_instance_config: The Ocean shielded instance configuration object.
|
|
708
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanImportStrategyArgs', 'OceanImportStrategyArgsDict']]]] strategies: Strategy object.
|
|
709
|
+
: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.
|
|
710
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
|
|
625
711
|
"""
|
|
626
712
|
...
|
|
627
713
|
@overload
|
|
@@ -630,8 +716,6 @@ class OceanImport(pulumi.CustomResource):
|
|
|
630
716
|
args: OceanImportArgs,
|
|
631
717
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
632
718
|
"""
|
|
633
|
-
Manages a Spotinst Ocean GKE resource.
|
|
634
|
-
|
|
635
719
|
## Example Usage
|
|
636
720
|
|
|
637
721
|
```python
|
|
@@ -645,27 +729,41 @@ class OceanImport(pulumi.CustomResource):
|
|
|
645
729
|
min_size=0,
|
|
646
730
|
max_size=2,
|
|
647
731
|
desired_capacity=0,
|
|
732
|
+
auto_updates=[{
|
|
733
|
+
"is_enabled": True,
|
|
734
|
+
}],
|
|
648
735
|
whitelists=[
|
|
649
736
|
"n1-standard-1",
|
|
650
737
|
"n1-standard-2",
|
|
651
738
|
],
|
|
652
|
-
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
739
|
+
filters={
|
|
740
|
+
"exclude_families": ["n2"],
|
|
741
|
+
"include_families": [
|
|
742
|
+
"c2",
|
|
743
|
+
"c3",
|
|
744
|
+
],
|
|
745
|
+
"min_memory_gib": 8,
|
|
746
|
+
"max_memory_gib": 16,
|
|
747
|
+
"min_vcpu": 2,
|
|
748
|
+
"max_vcpu": 16,
|
|
749
|
+
},
|
|
750
|
+
backend_services=[{
|
|
751
|
+
"service_name": "example-backend-service",
|
|
752
|
+
"location_type": "regional",
|
|
753
|
+
"scheme": "INTERNAL",
|
|
754
|
+
"named_ports": [{
|
|
755
|
+
"name": "http",
|
|
756
|
+
"ports": [
|
|
659
757
|
"80",
|
|
660
758
|
"8080",
|
|
661
759
|
],
|
|
662
|
-
|
|
663
|
-
|
|
760
|
+
}],
|
|
761
|
+
}],
|
|
664
762
|
root_volume_type="pd-ssd",
|
|
665
|
-
shielded_instance_config=
|
|
666
|
-
enable_secure_boot
|
|
667
|
-
enable_integrity_monitoring
|
|
668
|
-
|
|
763
|
+
shielded_instance_config={
|
|
764
|
+
"enable_secure_boot": True,
|
|
765
|
+
"enable_integrity_monitoring": True,
|
|
766
|
+
},
|
|
669
767
|
use_as_template_only=False)
|
|
670
768
|
```
|
|
671
769
|
|
|
@@ -684,22 +782,24 @@ class OceanImport(pulumi.CustomResource):
|
|
|
684
782
|
def _internal_init(__self__,
|
|
685
783
|
resource_name: str,
|
|
686
784
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
785
|
+
auto_updates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportAutoUpdateArgs', 'OceanImportAutoUpdateArgsDict']]]]] = None,
|
|
786
|
+
autoscaler: Optional[pulumi.Input[Union['OceanImportAutoscalerArgs', 'OceanImportAutoscalerArgsDict']]] = None,
|
|
787
|
+
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportBackendServiceArgs', 'OceanImportBackendServiceArgsDict']]]]] = None,
|
|
788
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
789
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
790
|
+
controller_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
791
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
792
|
+
filters: Optional[pulumi.Input[Union['OceanImportFiltersArgs', 'OceanImportFiltersArgsDict']]] = None,
|
|
793
|
+
location: Optional[pulumi.Input[_builtins.str]] = None,
|
|
794
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
795
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
796
|
+
root_volume_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
797
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportScheduledTaskArgs', 'OceanImportScheduledTaskArgsDict']]]]] = None,
|
|
798
|
+
shielded_instance_config: Optional[pulumi.Input[Union['OceanImportShieldedInstanceConfigArgs', 'OceanImportShieldedInstanceConfigArgsDict']]] = None,
|
|
799
|
+
strategies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportStrategyArgs', 'OceanImportStrategyArgsDict']]]]] = None,
|
|
800
|
+
update_policy: Optional[pulumi.Input[Union['OceanImportUpdatePolicyArgs', 'OceanImportUpdatePolicyArgsDict']]] = None,
|
|
801
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
802
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
703
803
|
__props__=None):
|
|
704
804
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
705
805
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -709,6 +809,7 @@ class OceanImport(pulumi.CustomResource):
|
|
|
709
809
|
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
710
810
|
__props__ = OceanImportArgs.__new__(OceanImportArgs)
|
|
711
811
|
|
|
812
|
+
__props__.__dict__["auto_updates"] = auto_updates
|
|
712
813
|
__props__.__dict__["autoscaler"] = autoscaler
|
|
713
814
|
__props__.__dict__["backend_services"] = backend_services
|
|
714
815
|
__props__.__dict__["blacklists"] = blacklists
|
|
@@ -717,6 +818,7 @@ class OceanImport(pulumi.CustomResource):
|
|
|
717
818
|
__props__.__dict__["cluster_name"] = cluster_name
|
|
718
819
|
__props__.__dict__["controller_cluster_id"] = controller_cluster_id
|
|
719
820
|
__props__.__dict__["desired_capacity"] = desired_capacity
|
|
821
|
+
__props__.__dict__["filters"] = filters
|
|
720
822
|
if location is None and not opts.urn:
|
|
721
823
|
raise TypeError("Missing required property 'location'")
|
|
722
824
|
__props__.__dict__["location"] = location
|
|
@@ -740,23 +842,25 @@ class OceanImport(pulumi.CustomResource):
|
|
|
740
842
|
def get(resource_name: str,
|
|
741
843
|
id: pulumi.Input[str],
|
|
742
844
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
845
|
+
auto_updates: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportAutoUpdateArgs', 'OceanImportAutoUpdateArgsDict']]]]] = None,
|
|
846
|
+
autoscaler: Optional[pulumi.Input[Union['OceanImportAutoscalerArgs', 'OceanImportAutoscalerArgsDict']]] = None,
|
|
847
|
+
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportBackendServiceArgs', 'OceanImportBackendServiceArgsDict']]]]] = None,
|
|
848
|
+
blacklists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
849
|
+
cluster_controller_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
850
|
+
cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
851
|
+
controller_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
852
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
853
|
+
filters: Optional[pulumi.Input[Union['OceanImportFiltersArgs', 'OceanImportFiltersArgsDict']]] = None,
|
|
854
|
+
location: Optional[pulumi.Input[_builtins.str]] = None,
|
|
855
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
856
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
857
|
+
root_volume_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
858
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportScheduledTaskArgs', 'OceanImportScheduledTaskArgsDict']]]]] = None,
|
|
859
|
+
shielded_instance_config: Optional[pulumi.Input[Union['OceanImportShieldedInstanceConfigArgs', 'OceanImportShieldedInstanceConfigArgsDict']]] = None,
|
|
860
|
+
strategies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanImportStrategyArgs', 'OceanImportStrategyArgsDict']]]]] = None,
|
|
861
|
+
update_policy: Optional[pulumi.Input[Union['OceanImportUpdatePolicyArgs', 'OceanImportUpdatePolicyArgsDict']]] = None,
|
|
862
|
+
use_as_template_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
863
|
+
whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'OceanImport':
|
|
760
864
|
"""
|
|
761
865
|
Get an existing OceanImport resource's state with the given name, id, and optional extra
|
|
762
866
|
properties used to qualify the lookup.
|
|
@@ -764,26 +868,29 @@ class OceanImport(pulumi.CustomResource):
|
|
|
764
868
|
:param str resource_name: The unique name of the resulting resource.
|
|
765
869
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
766
870
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
767
|
-
:param pulumi.Input[pulumi.
|
|
768
|
-
:param pulumi.Input[
|
|
769
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
770
|
-
:param pulumi.Input[str]
|
|
771
|
-
:param pulumi.Input[str]
|
|
772
|
-
:param pulumi.Input[
|
|
773
|
-
:param pulumi.Input[
|
|
774
|
-
:param pulumi.Input[
|
|
775
|
-
:param pulumi.Input[
|
|
776
|
-
:param pulumi.Input[
|
|
777
|
-
:param pulumi.Input[
|
|
778
|
-
:param pulumi.Input[
|
|
779
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
780
|
-
:param pulumi.Input[
|
|
781
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
871
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanImportAutoUpdateArgs', 'OceanImportAutoUpdateArgsDict']]]] auto_updates: The Ocean Kubernetes AutoUpdate object. If set to 'true', Ocean will ensure that your clusters have an up-to-date configuration according to the respective GKE cluster.
|
|
872
|
+
:param pulumi.Input[Union['OceanImportAutoscalerArgs', 'OceanImportAutoscalerArgsDict']] autoscaler: The Ocean Kubernetes Autoscaler object.
|
|
873
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanImportBackendServiceArgs', 'OceanImportBackendServiceArgsDict']]]] backend_services: Describes the backend service configurations.
|
|
874
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] blacklists: Instance types to avoid launching in the Ocean cluster. Cannot be configured if whitelist list is configured.
|
|
875
|
+
:param pulumi.Input[_builtins.str] cluster_name: The GKE cluster name.
|
|
876
|
+
:param pulumi.Input[_builtins.str] controller_cluster_id: A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
877
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The number of instances to launch and maintain in the cluster.
|
|
878
|
+
:param pulumi.Input[Union['OceanImportFiltersArgs', 'OceanImportFiltersArgsDict']] filters: List of filters. The Instance types that match with all filters compose the Ocean's whitelist parameter. Cannot be configured together with whitelist/blacklist.
|
|
879
|
+
:param pulumi.Input[_builtins.str] location: The zone the master cluster is located in.
|
|
880
|
+
:param pulumi.Input[_builtins.int] max_size: The upper limit of instances the cluster can scale up to.
|
|
881
|
+
:param pulumi.Input[_builtins.int] min_size: The lower limit of instances the cluster can scale down to.
|
|
882
|
+
:param pulumi.Input[_builtins.str] root_volume_type: The root volume disk type.
|
|
883
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanImportScheduledTaskArgs', 'OceanImportScheduledTaskArgsDict']]]] scheduled_tasks: Set scheduling object.
|
|
884
|
+
:param pulumi.Input[Union['OceanImportShieldedInstanceConfigArgs', 'OceanImportShieldedInstanceConfigArgsDict']] shielded_instance_config: The Ocean shielded instance configuration object.
|
|
885
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanImportStrategyArgs', 'OceanImportStrategyArgsDict']]]] strategies: Strategy object.
|
|
886
|
+
: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.
|
|
887
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] whitelists: Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
|
|
782
888
|
"""
|
|
783
889
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
784
890
|
|
|
785
891
|
__props__ = _OceanImportState.__new__(_OceanImportState)
|
|
786
892
|
|
|
893
|
+
__props__.__dict__["auto_updates"] = auto_updates
|
|
787
894
|
__props__.__dict__["autoscaler"] = autoscaler
|
|
788
895
|
__props__.__dict__["backend_services"] = backend_services
|
|
789
896
|
__props__.__dict__["blacklists"] = blacklists
|
|
@@ -791,6 +898,7 @@ class OceanImport(pulumi.CustomResource):
|
|
|
791
898
|
__props__.__dict__["cluster_name"] = cluster_name
|
|
792
899
|
__props__.__dict__["controller_cluster_id"] = controller_cluster_id
|
|
793
900
|
__props__.__dict__["desired_capacity"] = desired_capacity
|
|
901
|
+
__props__.__dict__["filters"] = filters
|
|
794
902
|
__props__.__dict__["location"] = location
|
|
795
903
|
__props__.__dict__["max_size"] = max_size
|
|
796
904
|
__props__.__dict__["min_size"] = min_size
|
|
@@ -803,7 +911,15 @@ class OceanImport(pulumi.CustomResource):
|
|
|
803
911
|
__props__.__dict__["whitelists"] = whitelists
|
|
804
912
|
return OceanImport(resource_name, opts=opts, __props__=__props__)
|
|
805
913
|
|
|
806
|
-
@property
|
|
914
|
+
@_builtins.property
|
|
915
|
+
@pulumi.getter(name="autoUpdates")
|
|
916
|
+
def auto_updates(self) -> pulumi.Output[Optional[Sequence['outputs.OceanImportAutoUpdate']]]:
|
|
917
|
+
"""
|
|
918
|
+
The Ocean Kubernetes AutoUpdate object. If set to 'true', Ocean will ensure that your clusters have an up-to-date configuration according to the respective GKE cluster.
|
|
919
|
+
"""
|
|
920
|
+
return pulumi.get(self, "auto_updates")
|
|
921
|
+
|
|
922
|
+
@_builtins.property
|
|
807
923
|
@pulumi.getter
|
|
808
924
|
def autoscaler(self) -> pulumi.Output['outputs.OceanImportAutoscaler']:
|
|
809
925
|
"""
|
|
@@ -811,7 +927,7 @@ class OceanImport(pulumi.CustomResource):
|
|
|
811
927
|
"""
|
|
812
928
|
return pulumi.get(self, "autoscaler")
|
|
813
929
|
|
|
814
|
-
@property
|
|
930
|
+
@_builtins.property
|
|
815
931
|
@pulumi.getter(name="backendServices")
|
|
816
932
|
def backend_services(self) -> pulumi.Output[Optional[Sequence['outputs.OceanImportBackendService']]]:
|
|
817
933
|
"""
|
|
@@ -819,76 +935,84 @@ class OceanImport(pulumi.CustomResource):
|
|
|
819
935
|
"""
|
|
820
936
|
return pulumi.get(self, "backend_services")
|
|
821
937
|
|
|
822
|
-
@property
|
|
938
|
+
@_builtins.property
|
|
823
939
|
@pulumi.getter
|
|
824
|
-
def blacklists(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
940
|
+
def blacklists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
825
941
|
"""
|
|
826
942
|
Instance types to avoid launching in the Ocean cluster. Cannot be configured if whitelist list is configured.
|
|
827
943
|
"""
|
|
828
944
|
return pulumi.get(self, "blacklists")
|
|
829
945
|
|
|
830
|
-
@property
|
|
946
|
+
@_builtins.property
|
|
831
947
|
@pulumi.getter(name="clusterControllerId")
|
|
832
|
-
def cluster_controller_id(self) -> pulumi.Output[str]:
|
|
948
|
+
def cluster_controller_id(self) -> pulumi.Output[_builtins.str]:
|
|
833
949
|
return pulumi.get(self, "cluster_controller_id")
|
|
834
950
|
|
|
835
|
-
@property
|
|
951
|
+
@_builtins.property
|
|
836
952
|
@pulumi.getter(name="clusterName")
|
|
837
|
-
def cluster_name(self) -> pulumi.Output[str]:
|
|
953
|
+
def cluster_name(self) -> pulumi.Output[_builtins.str]:
|
|
838
954
|
"""
|
|
839
955
|
The GKE cluster name.
|
|
840
956
|
"""
|
|
841
957
|
return pulumi.get(self, "cluster_name")
|
|
842
958
|
|
|
843
|
-
@property
|
|
959
|
+
@_builtins.property
|
|
844
960
|
@pulumi.getter(name="controllerClusterId")
|
|
845
|
-
def controller_cluster_id(self) -> pulumi.Output[str]:
|
|
961
|
+
def controller_cluster_id(self) -> pulumi.Output[_builtins.str]:
|
|
846
962
|
"""
|
|
847
963
|
A unique identifier used for connecting the Ocean SaaS platform and the Kubernetes cluster. Typically, the cluster name is used as its identifier.
|
|
848
964
|
"""
|
|
849
965
|
return pulumi.get(self, "controller_cluster_id")
|
|
850
966
|
|
|
851
|
-
@property
|
|
967
|
+
@_builtins.property
|
|
852
968
|
@pulumi.getter(name="desiredCapacity")
|
|
853
|
-
def desired_capacity(self) -> pulumi.Output[int]:
|
|
969
|
+
def desired_capacity(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
854
970
|
"""
|
|
855
971
|
The number of instances to launch and maintain in the cluster.
|
|
856
972
|
"""
|
|
857
973
|
return pulumi.get(self, "desired_capacity")
|
|
858
974
|
|
|
859
|
-
@property
|
|
975
|
+
@_builtins.property
|
|
976
|
+
@pulumi.getter
|
|
977
|
+
def filters(self) -> pulumi.Output[Optional['outputs.OceanImportFilters']]:
|
|
978
|
+
"""
|
|
979
|
+
List of filters. The Instance types that match with all filters compose the Ocean's whitelist parameter. Cannot be configured together with whitelist/blacklist.
|
|
980
|
+
"""
|
|
981
|
+
return pulumi.get(self, "filters")
|
|
982
|
+
|
|
983
|
+
@_builtins.property
|
|
860
984
|
@pulumi.getter
|
|
861
|
-
def location(self) -> pulumi.Output[str]:
|
|
985
|
+
def location(self) -> pulumi.Output[_builtins.str]:
|
|
862
986
|
"""
|
|
863
987
|
The zone the master cluster is located in.
|
|
864
988
|
"""
|
|
865
989
|
return pulumi.get(self, "location")
|
|
866
990
|
|
|
867
|
-
@property
|
|
991
|
+
@_builtins.property
|
|
868
992
|
@pulumi.getter(name="maxSize")
|
|
869
|
-
def max_size(self) -> pulumi.Output[int]:
|
|
993
|
+
def max_size(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
870
994
|
"""
|
|
871
995
|
The upper limit of instances the cluster can scale up to.
|
|
872
996
|
"""
|
|
873
997
|
return pulumi.get(self, "max_size")
|
|
874
998
|
|
|
875
|
-
@property
|
|
999
|
+
@_builtins.property
|
|
876
1000
|
@pulumi.getter(name="minSize")
|
|
877
|
-
def min_size(self) -> pulumi.Output[int]:
|
|
1001
|
+
def min_size(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
878
1002
|
"""
|
|
879
1003
|
The lower limit of instances the cluster can scale down to.
|
|
880
1004
|
"""
|
|
881
1005
|
return pulumi.get(self, "min_size")
|
|
882
1006
|
|
|
883
|
-
@property
|
|
1007
|
+
@_builtins.property
|
|
884
1008
|
@pulumi.getter(name="rootVolumeType")
|
|
885
|
-
def root_volume_type(self) -> pulumi.Output[Optional[str]]:
|
|
1009
|
+
def root_volume_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
886
1010
|
"""
|
|
887
1011
|
The root volume disk type.
|
|
888
1012
|
"""
|
|
889
1013
|
return pulumi.get(self, "root_volume_type")
|
|
890
1014
|
|
|
891
|
-
@property
|
|
1015
|
+
@_builtins.property
|
|
892
1016
|
@pulumi.getter(name="scheduledTasks")
|
|
893
1017
|
def scheduled_tasks(self) -> pulumi.Output[Optional[Sequence['outputs.OceanImportScheduledTask']]]:
|
|
894
1018
|
"""
|
|
@@ -896,7 +1020,7 @@ class OceanImport(pulumi.CustomResource):
|
|
|
896
1020
|
"""
|
|
897
1021
|
return pulumi.get(self, "scheduled_tasks")
|
|
898
1022
|
|
|
899
|
-
@property
|
|
1023
|
+
@_builtins.property
|
|
900
1024
|
@pulumi.getter(name="shieldedInstanceConfig")
|
|
901
1025
|
def shielded_instance_config(self) -> pulumi.Output['outputs.OceanImportShieldedInstanceConfig']:
|
|
902
1026
|
"""
|
|
@@ -904,7 +1028,7 @@ class OceanImport(pulumi.CustomResource):
|
|
|
904
1028
|
"""
|
|
905
1029
|
return pulumi.get(self, "shielded_instance_config")
|
|
906
1030
|
|
|
907
|
-
@property
|
|
1031
|
+
@_builtins.property
|
|
908
1032
|
@pulumi.getter
|
|
909
1033
|
def strategies(self) -> pulumi.Output[Optional[Sequence['outputs.OceanImportStrategy']]]:
|
|
910
1034
|
"""
|
|
@@ -912,22 +1036,22 @@ class OceanImport(pulumi.CustomResource):
|
|
|
912
1036
|
"""
|
|
913
1037
|
return pulumi.get(self, "strategies")
|
|
914
1038
|
|
|
915
|
-
@property
|
|
1039
|
+
@_builtins.property
|
|
916
1040
|
@pulumi.getter(name="updatePolicy")
|
|
917
1041
|
def update_policy(self) -> pulumi.Output[Optional['outputs.OceanImportUpdatePolicy']]:
|
|
918
1042
|
return pulumi.get(self, "update_policy")
|
|
919
1043
|
|
|
920
|
-
@property
|
|
1044
|
+
@_builtins.property
|
|
921
1045
|
@pulumi.getter(name="useAsTemplateOnly")
|
|
922
|
-
def use_as_template_only(self) -> pulumi.Output[Optional[bool]]:
|
|
1046
|
+
def use_as_template_only(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
923
1047
|
"""
|
|
924
1048
|
launch specification defined on the Ocean object will function only as a template for virtual node groups.
|
|
925
1049
|
"""
|
|
926
1050
|
return pulumi.get(self, "use_as_template_only")
|
|
927
1051
|
|
|
928
|
-
@property
|
|
1052
|
+
@_builtins.property
|
|
929
1053
|
@pulumi.getter
|
|
930
|
-
def whitelists(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1054
|
+
def whitelists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
931
1055
|
"""
|
|
932
1056
|
Instance types allowed in the Ocean cluster. Cannot be configured if blacklist list is configured.
|
|
933
1057
|
"""
|