pulumi-spotinst 3.112.0a1741317810__py3-none-any.whl → 3.128.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-spotinst might be problematic. Click here for more details.
- pulumi_spotinst/__init__.py +11 -1
- pulumi_spotinst/_inputs.py +2283 -1519
- pulumi_spotinst/_utilities.py +1 -1
- pulumi_spotinst/account.py +20 -19
- pulumi_spotinst/aws/__init__.py +2 -1
- pulumi_spotinst/aws/_inputs.py +4047 -3607
- pulumi_spotinst/aws/account.py +20 -19
- pulumi_spotinst/aws/beanstalk.py +254 -177
- pulumi_spotinst/aws/credentials.py +37 -36
- pulumi_spotinst/aws/elastigroup.py +970 -924
- pulumi_spotinst/aws/managed_instance.py +507 -506
- pulumi_spotinst/aws/mr_scalar.py +658 -653
- pulumi_spotinst/aws/ocean.py +668 -526
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +37 -36
- pulumi_spotinst/aws/ocean_launch_spec.py +439 -297
- pulumi_spotinst/aws/outputs.py +2697 -2363
- pulumi_spotinst/aws/suspension.py +23 -22
- pulumi_spotinst/azure/__init__.py +2 -1
- pulumi_spotinst/azure/_inputs.py +607 -607
- pulumi_spotinst/azure/ocean_np.py +387 -386
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +323 -322
- pulumi_spotinst/azure/outputs.py +411 -411
- pulumi_spotinst/config/__init__.py +2 -1
- pulumi_spotinst/config/__init__.pyi +2 -2
- pulumi_spotinst/config/vars.py +6 -6
- pulumi_spotinst/credentials_azure.py +139 -89
- pulumi_spotinst/credentials_gcp.py +190 -189
- pulumi_spotinst/data_integration.py +40 -39
- pulumi_spotinst/ecs/__init__.py +2 -1
- pulumi_spotinst/ecs/_inputs.py +584 -584
- pulumi_spotinst/ecs/ocean.py +628 -415
- pulumi_spotinst/ecs/ocean_launch_spec.py +197 -196
- pulumi_spotinst/ecs/outputs.py +394 -394
- pulumi_spotinst/elastigroup_azure_v3.py +326 -325
- pulumi_spotinst/gcp/__init__.py +2 -1
- pulumi_spotinst/gcp/_inputs.py +573 -499
- pulumi_spotinst/gcp/elastigroup.py +491 -482
- pulumi_spotinst/gcp/outputs.py +395 -330
- pulumi_spotinst/gke/__init__.py +2 -1
- pulumi_spotinst/gke/_inputs.py +1120 -895
- pulumi_spotinst/gke/elastigroup.py +341 -340
- pulumi_spotinst/gke/ocean_import.py +204 -203
- pulumi_spotinst/gke/ocean_launch_spec.py +288 -216
- pulumi_spotinst/gke/ocean_launch_spec_import.py +37 -36
- pulumi_spotinst/gke/outputs.py +769 -583
- pulumi_spotinst/health_check.py +106 -65
- pulumi_spotinst/notification_center.py +344 -0
- pulumi_spotinst/ocean_right_sizing_rule.py +424 -77
- pulumi_spotinst/oceancd/__init__.py +2 -1
- pulumi_spotinst/oceancd/_inputs.py +764 -764
- pulumi_spotinst/oceancd/outputs.py +526 -526
- pulumi_spotinst/oceancd/rollout_spec.py +35 -34
- pulumi_spotinst/oceancd/strategy.py +22 -21
- pulumi_spotinst/oceancd/verification_provider.py +52 -51
- pulumi_spotinst/oceancd/verification_template.py +26 -25
- pulumi_spotinst/organization/__init__.py +2 -1
- pulumi_spotinst/organization/_inputs.py +68 -68
- pulumi_spotinst/organization/outputs.py +46 -46
- pulumi_spotinst/organization/policy.py +40 -39
- pulumi_spotinst/organization/programmatic_user.py +60 -59
- pulumi_spotinst/organization/user.py +108 -107
- pulumi_spotinst/organization/user_group.py +57 -56
- pulumi_spotinst/outputs.py +1539 -932
- pulumi_spotinst/provider.py +61 -40
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +2 -1
- pulumi_spotinst/spark/_inputs.py +104 -104
- pulumi_spotinst/spark/ocean.py +38 -37
- pulumi_spotinst/spark/ocean_virtual_node_group.py +29 -28
- pulumi_spotinst/spark/outputs.py +72 -72
- pulumi_spotinst/stateful_node_azure.py +340 -343
- pulumi_spotinst/subscription.py +88 -87
- {pulumi_spotinst-3.112.0a1741317810.dist-info → pulumi_spotinst-3.128.0.dist-info}/METADATA +4 -4
- pulumi_spotinst-3.128.0.dist-info/RECORD +77 -0
- {pulumi_spotinst-3.112.0a1741317810.dist-info → pulumi_spotinst-3.128.0.dist-info}/WHEEL +1 -1
- pulumi_spotinst-3.112.0a1741317810.dist-info/RECORD +0 -76
- {pulumi_spotinst-3.112.0a1741317810.dist-info → pulumi_spotinst-3.128.0.dist-info}/top_level.txt +0 -0
pulumi_spotinst/gke/_inputs.py
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
7
|
import sys
|
|
8
8
|
import pulumi
|
|
@@ -17,6 +17,8 @@ from .. import _utilities
|
|
|
17
17
|
__all__ = [
|
|
18
18
|
'ElastigroupBackendServiceArgs',
|
|
19
19
|
'ElastigroupBackendServiceArgsDict',
|
|
20
|
+
'ElastigroupBackendServiceBackendBalancingArgs',
|
|
21
|
+
'ElastigroupBackendServiceBackendBalancingArgsDict',
|
|
20
22
|
'ElastigroupBackendServiceNamedPortArgs',
|
|
21
23
|
'ElastigroupBackendServiceNamedPortArgsDict',
|
|
22
24
|
'ElastigroupDiskArgs',
|
|
@@ -99,6 +101,8 @@ __all__ = [
|
|
|
99
101
|
'OceanLaunchSpecAutoscaleHeadroomsAutomaticArgsDict',
|
|
100
102
|
'OceanLaunchSpecCreateOptionsArgs',
|
|
101
103
|
'OceanLaunchSpecCreateOptionsArgsDict',
|
|
104
|
+
'OceanLaunchSpecFiltersArgs',
|
|
105
|
+
'OceanLaunchSpecFiltersArgsDict',
|
|
102
106
|
'OceanLaunchSpecLabelArgs',
|
|
103
107
|
'OceanLaunchSpecLabelArgsDict',
|
|
104
108
|
'OceanLaunchSpecMetadataArgs',
|
|
@@ -133,21 +137,25 @@ MYPY = False
|
|
|
133
137
|
|
|
134
138
|
if not MYPY:
|
|
135
139
|
class ElastigroupBackendServiceArgsDict(TypedDict):
|
|
136
|
-
service_name: pulumi.Input[str]
|
|
137
|
-
|
|
140
|
+
service_name: pulumi.Input[_builtins.str]
|
|
141
|
+
backend_balancing: NotRequired[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgsDict']]
|
|
142
|
+
location_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
138
143
|
named_ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgsDict']]]]
|
|
139
|
-
scheme: NotRequired[pulumi.Input[str]]
|
|
144
|
+
scheme: NotRequired[pulumi.Input[_builtins.str]]
|
|
140
145
|
elif False:
|
|
141
146
|
ElastigroupBackendServiceArgsDict: TypeAlias = Mapping[str, Any]
|
|
142
147
|
|
|
143
148
|
@pulumi.input_type
|
|
144
149
|
class ElastigroupBackendServiceArgs:
|
|
145
150
|
def __init__(__self__, *,
|
|
146
|
-
service_name: pulumi.Input[str],
|
|
147
|
-
|
|
151
|
+
service_name: pulumi.Input[_builtins.str],
|
|
152
|
+
backend_balancing: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']] = None,
|
|
153
|
+
location_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
148
154
|
named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]] = None,
|
|
149
|
-
scheme: Optional[pulumi.Input[str]] = None):
|
|
155
|
+
scheme: Optional[pulumi.Input[_builtins.str]] = None):
|
|
150
156
|
pulumi.set(__self__, "service_name", service_name)
|
|
157
|
+
if backend_balancing is not None:
|
|
158
|
+
pulumi.set(__self__, "backend_balancing", backend_balancing)
|
|
151
159
|
if location_type is not None:
|
|
152
160
|
pulumi.set(__self__, "location_type", location_type)
|
|
153
161
|
if named_ports is not None:
|
|
@@ -155,25 +163,34 @@ class ElastigroupBackendServiceArgs:
|
|
|
155
163
|
if scheme is not None:
|
|
156
164
|
pulumi.set(__self__, "scheme", scheme)
|
|
157
165
|
|
|
158
|
-
@property
|
|
166
|
+
@_builtins.property
|
|
159
167
|
@pulumi.getter(name="serviceName")
|
|
160
|
-
def service_name(self) -> pulumi.Input[str]:
|
|
168
|
+
def service_name(self) -> pulumi.Input[_builtins.str]:
|
|
161
169
|
return pulumi.get(self, "service_name")
|
|
162
170
|
|
|
163
171
|
@service_name.setter
|
|
164
|
-
def service_name(self, value: pulumi.Input[str]):
|
|
172
|
+
def service_name(self, value: pulumi.Input[_builtins.str]):
|
|
165
173
|
pulumi.set(self, "service_name", value)
|
|
166
174
|
|
|
167
|
-
@property
|
|
175
|
+
@_builtins.property
|
|
176
|
+
@pulumi.getter(name="backendBalancing")
|
|
177
|
+
def backend_balancing(self) -> Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]:
|
|
178
|
+
return pulumi.get(self, "backend_balancing")
|
|
179
|
+
|
|
180
|
+
@backend_balancing.setter
|
|
181
|
+
def backend_balancing(self, value: Optional[pulumi.Input['ElastigroupBackendServiceBackendBalancingArgs']]):
|
|
182
|
+
pulumi.set(self, "backend_balancing", value)
|
|
183
|
+
|
|
184
|
+
@_builtins.property
|
|
168
185
|
@pulumi.getter(name="locationType")
|
|
169
|
-
def location_type(self) -> Optional[pulumi.Input[str]]:
|
|
186
|
+
def location_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
170
187
|
return pulumi.get(self, "location_type")
|
|
171
188
|
|
|
172
189
|
@location_type.setter
|
|
173
|
-
def location_type(self, value: Optional[pulumi.Input[str]]):
|
|
190
|
+
def location_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
174
191
|
pulumi.set(self, "location_type", value)
|
|
175
192
|
|
|
176
|
-
@property
|
|
193
|
+
@_builtins.property
|
|
177
194
|
@pulumi.getter(name="namedPorts")
|
|
178
195
|
def named_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]]:
|
|
179
196
|
return pulumi.get(self, "named_ports")
|
|
@@ -182,74 +199,110 @@ class ElastigroupBackendServiceArgs:
|
|
|
182
199
|
def named_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceNamedPortArgs']]]]):
|
|
183
200
|
pulumi.set(self, "named_ports", value)
|
|
184
201
|
|
|
185
|
-
@property
|
|
202
|
+
@_builtins.property
|
|
186
203
|
@pulumi.getter
|
|
187
|
-
def scheme(self) -> Optional[pulumi.Input[str]]:
|
|
204
|
+
def scheme(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
188
205
|
return pulumi.get(self, "scheme")
|
|
189
206
|
|
|
190
207
|
@scheme.setter
|
|
191
|
-
def scheme(self, value: Optional[pulumi.Input[str]]):
|
|
208
|
+
def scheme(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
192
209
|
pulumi.set(self, "scheme", value)
|
|
193
210
|
|
|
194
211
|
|
|
212
|
+
if not MYPY:
|
|
213
|
+
class ElastigroupBackendServiceBackendBalancingArgsDict(TypedDict):
|
|
214
|
+
backend_balancing_mode: NotRequired[pulumi.Input[_builtins.str]]
|
|
215
|
+
max_rate_per_instance: NotRequired[pulumi.Input[_builtins.int]]
|
|
216
|
+
elif False:
|
|
217
|
+
ElastigroupBackendServiceBackendBalancingArgsDict: TypeAlias = Mapping[str, Any]
|
|
218
|
+
|
|
219
|
+
@pulumi.input_type
|
|
220
|
+
class ElastigroupBackendServiceBackendBalancingArgs:
|
|
221
|
+
def __init__(__self__, *,
|
|
222
|
+
backend_balancing_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
223
|
+
max_rate_per_instance: Optional[pulumi.Input[_builtins.int]] = None):
|
|
224
|
+
if backend_balancing_mode is not None:
|
|
225
|
+
pulumi.set(__self__, "backend_balancing_mode", backend_balancing_mode)
|
|
226
|
+
if max_rate_per_instance is not None:
|
|
227
|
+
pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
|
|
228
|
+
|
|
229
|
+
@_builtins.property
|
|
230
|
+
@pulumi.getter(name="backendBalancingMode")
|
|
231
|
+
def backend_balancing_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
232
|
+
return pulumi.get(self, "backend_balancing_mode")
|
|
233
|
+
|
|
234
|
+
@backend_balancing_mode.setter
|
|
235
|
+
def backend_balancing_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
236
|
+
pulumi.set(self, "backend_balancing_mode", value)
|
|
237
|
+
|
|
238
|
+
@_builtins.property
|
|
239
|
+
@pulumi.getter(name="maxRatePerInstance")
|
|
240
|
+
def max_rate_per_instance(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
241
|
+
return pulumi.get(self, "max_rate_per_instance")
|
|
242
|
+
|
|
243
|
+
@max_rate_per_instance.setter
|
|
244
|
+
def max_rate_per_instance(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
245
|
+
pulumi.set(self, "max_rate_per_instance", value)
|
|
246
|
+
|
|
247
|
+
|
|
195
248
|
if not MYPY:
|
|
196
249
|
class ElastigroupBackendServiceNamedPortArgsDict(TypedDict):
|
|
197
|
-
name: pulumi.Input[str]
|
|
198
|
-
ports: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
250
|
+
name: pulumi.Input[_builtins.str]
|
|
251
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
199
252
|
elif False:
|
|
200
253
|
ElastigroupBackendServiceNamedPortArgsDict: TypeAlias = Mapping[str, Any]
|
|
201
254
|
|
|
202
255
|
@pulumi.input_type
|
|
203
256
|
class ElastigroupBackendServiceNamedPortArgs:
|
|
204
257
|
def __init__(__self__, *,
|
|
205
|
-
name: pulumi.Input[str],
|
|
206
|
-
ports: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
258
|
+
name: pulumi.Input[_builtins.str],
|
|
259
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
207
260
|
pulumi.set(__self__, "name", name)
|
|
208
261
|
pulumi.set(__self__, "ports", ports)
|
|
209
262
|
|
|
210
|
-
@property
|
|
263
|
+
@_builtins.property
|
|
211
264
|
@pulumi.getter
|
|
212
|
-
def name(self) -> pulumi.Input[str]:
|
|
265
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
213
266
|
return pulumi.get(self, "name")
|
|
214
267
|
|
|
215
268
|
@name.setter
|
|
216
|
-
def name(self, value: pulumi.Input[str]):
|
|
269
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
217
270
|
pulumi.set(self, "name", value)
|
|
218
271
|
|
|
219
|
-
@property
|
|
272
|
+
@_builtins.property
|
|
220
273
|
@pulumi.getter
|
|
221
|
-
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
274
|
+
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
222
275
|
return pulumi.get(self, "ports")
|
|
223
276
|
|
|
224
277
|
@ports.setter
|
|
225
|
-
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
278
|
+
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
226
279
|
pulumi.set(self, "ports", value)
|
|
227
280
|
|
|
228
281
|
|
|
229
282
|
if not MYPY:
|
|
230
283
|
class ElastigroupDiskArgsDict(TypedDict):
|
|
231
|
-
auto_delete: NotRequired[pulumi.Input[bool]]
|
|
232
|
-
boot: NotRequired[pulumi.Input[bool]]
|
|
233
|
-
device_name: NotRequired[pulumi.Input[str]]
|
|
284
|
+
auto_delete: NotRequired[pulumi.Input[_builtins.bool]]
|
|
285
|
+
boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
286
|
+
device_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
234
287
|
initialize_params: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgsDict']]]]
|
|
235
|
-
interface: NotRequired[pulumi.Input[str]]
|
|
236
|
-
mode: NotRequired[pulumi.Input[str]]
|
|
237
|
-
source: NotRequired[pulumi.Input[str]]
|
|
238
|
-
type: NotRequired[pulumi.Input[str]]
|
|
288
|
+
interface: NotRequired[pulumi.Input[_builtins.str]]
|
|
289
|
+
mode: NotRequired[pulumi.Input[_builtins.str]]
|
|
290
|
+
source: NotRequired[pulumi.Input[_builtins.str]]
|
|
291
|
+
type: NotRequired[pulumi.Input[_builtins.str]]
|
|
239
292
|
elif False:
|
|
240
293
|
ElastigroupDiskArgsDict: TypeAlias = Mapping[str, Any]
|
|
241
294
|
|
|
242
295
|
@pulumi.input_type
|
|
243
296
|
class ElastigroupDiskArgs:
|
|
244
297
|
def __init__(__self__, *,
|
|
245
|
-
auto_delete: Optional[pulumi.Input[bool]] = None,
|
|
246
|
-
boot: Optional[pulumi.Input[bool]] = None,
|
|
247
|
-
device_name: Optional[pulumi.Input[str]] = None,
|
|
298
|
+
auto_delete: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
299
|
+
boot: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
300
|
+
device_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
248
301
|
initialize_params: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]] = None,
|
|
249
|
-
interface: Optional[pulumi.Input[str]] = None,
|
|
250
|
-
mode: Optional[pulumi.Input[str]] = None,
|
|
251
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
252
|
-
type: Optional[pulumi.Input[str]] = None):
|
|
302
|
+
interface: Optional[pulumi.Input[_builtins.str]] = None,
|
|
303
|
+
mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
304
|
+
source: Optional[pulumi.Input[_builtins.str]] = None,
|
|
305
|
+
type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
253
306
|
if auto_delete is not None:
|
|
254
307
|
pulumi.set(__self__, "auto_delete", auto_delete)
|
|
255
308
|
if boot is not None:
|
|
@@ -267,34 +320,34 @@ class ElastigroupDiskArgs:
|
|
|
267
320
|
if type is not None:
|
|
268
321
|
pulumi.set(__self__, "type", type)
|
|
269
322
|
|
|
270
|
-
@property
|
|
323
|
+
@_builtins.property
|
|
271
324
|
@pulumi.getter(name="autoDelete")
|
|
272
|
-
def auto_delete(self) -> Optional[pulumi.Input[bool]]:
|
|
325
|
+
def auto_delete(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
273
326
|
return pulumi.get(self, "auto_delete")
|
|
274
327
|
|
|
275
328
|
@auto_delete.setter
|
|
276
|
-
def auto_delete(self, value: Optional[pulumi.Input[bool]]):
|
|
329
|
+
def auto_delete(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
277
330
|
pulumi.set(self, "auto_delete", value)
|
|
278
331
|
|
|
279
|
-
@property
|
|
332
|
+
@_builtins.property
|
|
280
333
|
@pulumi.getter
|
|
281
|
-
def boot(self) -> Optional[pulumi.Input[bool]]:
|
|
334
|
+
def boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
282
335
|
return pulumi.get(self, "boot")
|
|
283
336
|
|
|
284
337
|
@boot.setter
|
|
285
|
-
def boot(self, value: Optional[pulumi.Input[bool]]):
|
|
338
|
+
def boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
286
339
|
pulumi.set(self, "boot", value)
|
|
287
340
|
|
|
288
|
-
@property
|
|
341
|
+
@_builtins.property
|
|
289
342
|
@pulumi.getter(name="deviceName")
|
|
290
|
-
def device_name(self) -> Optional[pulumi.Input[str]]:
|
|
343
|
+
def device_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
291
344
|
return pulumi.get(self, "device_name")
|
|
292
345
|
|
|
293
346
|
@device_name.setter
|
|
294
|
-
def device_name(self, value: Optional[pulumi.Input[str]]):
|
|
347
|
+
def device_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
295
348
|
pulumi.set(self, "device_name", value)
|
|
296
349
|
|
|
297
|
-
@property
|
|
350
|
+
@_builtins.property
|
|
298
351
|
@pulumi.getter(name="initializeParams")
|
|
299
352
|
def initialize_params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]]:
|
|
300
353
|
return pulumi.get(self, "initialize_params")
|
|
@@ -303,197 +356,197 @@ class ElastigroupDiskArgs:
|
|
|
303
356
|
def initialize_params(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskInitializeParamArgs']]]]):
|
|
304
357
|
pulumi.set(self, "initialize_params", value)
|
|
305
358
|
|
|
306
|
-
@property
|
|
359
|
+
@_builtins.property
|
|
307
360
|
@pulumi.getter
|
|
308
|
-
def interface(self) -> Optional[pulumi.Input[str]]:
|
|
361
|
+
def interface(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
309
362
|
return pulumi.get(self, "interface")
|
|
310
363
|
|
|
311
364
|
@interface.setter
|
|
312
|
-
def interface(self, value: Optional[pulumi.Input[str]]):
|
|
365
|
+
def interface(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
313
366
|
pulumi.set(self, "interface", value)
|
|
314
367
|
|
|
315
|
-
@property
|
|
368
|
+
@_builtins.property
|
|
316
369
|
@pulumi.getter
|
|
317
|
-
def mode(self) -> Optional[pulumi.Input[str]]:
|
|
370
|
+
def mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
318
371
|
return pulumi.get(self, "mode")
|
|
319
372
|
|
|
320
373
|
@mode.setter
|
|
321
|
-
def mode(self, value: Optional[pulumi.Input[str]]):
|
|
374
|
+
def mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
322
375
|
pulumi.set(self, "mode", value)
|
|
323
376
|
|
|
324
|
-
@property
|
|
377
|
+
@_builtins.property
|
|
325
378
|
@pulumi.getter
|
|
326
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
379
|
+
def source(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
327
380
|
return pulumi.get(self, "source")
|
|
328
381
|
|
|
329
382
|
@source.setter
|
|
330
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
383
|
+
def source(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
331
384
|
pulumi.set(self, "source", value)
|
|
332
385
|
|
|
333
|
-
@property
|
|
386
|
+
@_builtins.property
|
|
334
387
|
@pulumi.getter
|
|
335
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
388
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
336
389
|
return pulumi.get(self, "type")
|
|
337
390
|
|
|
338
391
|
@type.setter
|
|
339
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
392
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
340
393
|
pulumi.set(self, "type", value)
|
|
341
394
|
|
|
342
395
|
|
|
343
396
|
if not MYPY:
|
|
344
397
|
class ElastigroupDiskInitializeParamArgsDict(TypedDict):
|
|
345
|
-
source_image: pulumi.Input[str]
|
|
346
|
-
disk_size_gb: NotRequired[pulumi.Input[str]]
|
|
347
|
-
disk_type: NotRequired[pulumi.Input[str]]
|
|
398
|
+
source_image: pulumi.Input[_builtins.str]
|
|
399
|
+
disk_size_gb: NotRequired[pulumi.Input[_builtins.str]]
|
|
400
|
+
disk_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
348
401
|
elif False:
|
|
349
402
|
ElastigroupDiskInitializeParamArgsDict: TypeAlias = Mapping[str, Any]
|
|
350
403
|
|
|
351
404
|
@pulumi.input_type
|
|
352
405
|
class ElastigroupDiskInitializeParamArgs:
|
|
353
406
|
def __init__(__self__, *,
|
|
354
|
-
source_image: pulumi.Input[str],
|
|
355
|
-
disk_size_gb: Optional[pulumi.Input[str]] = None,
|
|
356
|
-
disk_type: Optional[pulumi.Input[str]] = None):
|
|
407
|
+
source_image: pulumi.Input[_builtins.str],
|
|
408
|
+
disk_size_gb: Optional[pulumi.Input[_builtins.str]] = None,
|
|
409
|
+
disk_type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
357
410
|
pulumi.set(__self__, "source_image", source_image)
|
|
358
411
|
if disk_size_gb is not None:
|
|
359
412
|
pulumi.set(__self__, "disk_size_gb", disk_size_gb)
|
|
360
413
|
if disk_type is not None:
|
|
361
414
|
pulumi.set(__self__, "disk_type", disk_type)
|
|
362
415
|
|
|
363
|
-
@property
|
|
416
|
+
@_builtins.property
|
|
364
417
|
@pulumi.getter(name="sourceImage")
|
|
365
|
-
def source_image(self) -> pulumi.Input[str]:
|
|
418
|
+
def source_image(self) -> pulumi.Input[_builtins.str]:
|
|
366
419
|
return pulumi.get(self, "source_image")
|
|
367
420
|
|
|
368
421
|
@source_image.setter
|
|
369
|
-
def source_image(self, value: pulumi.Input[str]):
|
|
422
|
+
def source_image(self, value: pulumi.Input[_builtins.str]):
|
|
370
423
|
pulumi.set(self, "source_image", value)
|
|
371
424
|
|
|
372
|
-
@property
|
|
425
|
+
@_builtins.property
|
|
373
426
|
@pulumi.getter(name="diskSizeGb")
|
|
374
|
-
def disk_size_gb(self) -> Optional[pulumi.Input[str]]:
|
|
427
|
+
def disk_size_gb(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
375
428
|
return pulumi.get(self, "disk_size_gb")
|
|
376
429
|
|
|
377
430
|
@disk_size_gb.setter
|
|
378
|
-
def disk_size_gb(self, value: Optional[pulumi.Input[str]]):
|
|
431
|
+
def disk_size_gb(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
379
432
|
pulumi.set(self, "disk_size_gb", value)
|
|
380
433
|
|
|
381
|
-
@property
|
|
434
|
+
@_builtins.property
|
|
382
435
|
@pulumi.getter(name="diskType")
|
|
383
|
-
def disk_type(self) -> Optional[pulumi.Input[str]]:
|
|
436
|
+
def disk_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
384
437
|
return pulumi.get(self, "disk_type")
|
|
385
438
|
|
|
386
439
|
@disk_type.setter
|
|
387
|
-
def disk_type(self, value: Optional[pulumi.Input[str]]):
|
|
440
|
+
def disk_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
388
441
|
pulumi.set(self, "disk_type", value)
|
|
389
442
|
|
|
390
443
|
|
|
391
444
|
if not MYPY:
|
|
392
445
|
class ElastigroupGpuArgsDict(TypedDict):
|
|
393
|
-
count: pulumi.Input[int]
|
|
394
|
-
type: pulumi.Input[str]
|
|
446
|
+
count: pulumi.Input[_builtins.int]
|
|
447
|
+
type: pulumi.Input[_builtins.str]
|
|
395
448
|
elif False:
|
|
396
449
|
ElastigroupGpuArgsDict: TypeAlias = Mapping[str, Any]
|
|
397
450
|
|
|
398
451
|
@pulumi.input_type
|
|
399
452
|
class ElastigroupGpuArgs:
|
|
400
453
|
def __init__(__self__, *,
|
|
401
|
-
count: pulumi.Input[int],
|
|
402
|
-
type: pulumi.Input[str]):
|
|
454
|
+
count: pulumi.Input[_builtins.int],
|
|
455
|
+
type: pulumi.Input[_builtins.str]):
|
|
403
456
|
pulumi.set(__self__, "count", count)
|
|
404
457
|
pulumi.set(__self__, "type", type)
|
|
405
458
|
|
|
406
|
-
@property
|
|
459
|
+
@_builtins.property
|
|
407
460
|
@pulumi.getter
|
|
408
|
-
def count(self) -> pulumi.Input[int]:
|
|
461
|
+
def count(self) -> pulumi.Input[_builtins.int]:
|
|
409
462
|
return pulumi.get(self, "count")
|
|
410
463
|
|
|
411
464
|
@count.setter
|
|
412
|
-
def count(self, value: pulumi.Input[int]):
|
|
465
|
+
def count(self, value: pulumi.Input[_builtins.int]):
|
|
413
466
|
pulumi.set(self, "count", value)
|
|
414
467
|
|
|
415
|
-
@property
|
|
468
|
+
@_builtins.property
|
|
416
469
|
@pulumi.getter
|
|
417
|
-
def type(self) -> pulumi.Input[str]:
|
|
470
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
418
471
|
return pulumi.get(self, "type")
|
|
419
472
|
|
|
420
473
|
@type.setter
|
|
421
|
-
def type(self, value: pulumi.Input[str]):
|
|
474
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
422
475
|
pulumi.set(self, "type", value)
|
|
423
476
|
|
|
424
477
|
|
|
425
478
|
if not MYPY:
|
|
426
479
|
class ElastigroupInstanceTypesCustomArgsDict(TypedDict):
|
|
427
|
-
memory_gib: pulumi.Input[int]
|
|
428
|
-
vcpu: pulumi.Input[int]
|
|
480
|
+
memory_gib: pulumi.Input[_builtins.int]
|
|
481
|
+
vcpu: pulumi.Input[_builtins.int]
|
|
429
482
|
elif False:
|
|
430
483
|
ElastigroupInstanceTypesCustomArgsDict: TypeAlias = Mapping[str, Any]
|
|
431
484
|
|
|
432
485
|
@pulumi.input_type
|
|
433
486
|
class ElastigroupInstanceTypesCustomArgs:
|
|
434
487
|
def __init__(__self__, *,
|
|
435
|
-
memory_gib: pulumi.Input[int],
|
|
436
|
-
vcpu: pulumi.Input[int]):
|
|
488
|
+
memory_gib: pulumi.Input[_builtins.int],
|
|
489
|
+
vcpu: pulumi.Input[_builtins.int]):
|
|
437
490
|
pulumi.set(__self__, "memory_gib", memory_gib)
|
|
438
491
|
pulumi.set(__self__, "vcpu", vcpu)
|
|
439
492
|
|
|
440
|
-
@property
|
|
493
|
+
@_builtins.property
|
|
441
494
|
@pulumi.getter(name="memoryGib")
|
|
442
|
-
def memory_gib(self) -> pulumi.Input[int]:
|
|
495
|
+
def memory_gib(self) -> pulumi.Input[_builtins.int]:
|
|
443
496
|
return pulumi.get(self, "memory_gib")
|
|
444
497
|
|
|
445
498
|
@memory_gib.setter
|
|
446
|
-
def memory_gib(self, value: pulumi.Input[int]):
|
|
499
|
+
def memory_gib(self, value: pulumi.Input[_builtins.int]):
|
|
447
500
|
pulumi.set(self, "memory_gib", value)
|
|
448
501
|
|
|
449
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
450
503
|
@pulumi.getter
|
|
451
|
-
def vcpu(self) -> pulumi.Input[int]:
|
|
504
|
+
def vcpu(self) -> pulumi.Input[_builtins.int]:
|
|
452
505
|
return pulumi.get(self, "vcpu")
|
|
453
506
|
|
|
454
507
|
@vcpu.setter
|
|
455
|
-
def vcpu(self, value: pulumi.Input[int]):
|
|
508
|
+
def vcpu(self, value: pulumi.Input[_builtins.int]):
|
|
456
509
|
pulumi.set(self, "vcpu", value)
|
|
457
510
|
|
|
458
511
|
|
|
459
512
|
if not MYPY:
|
|
460
513
|
class ElastigroupIntegrationDockerSwarmArgsDict(TypedDict):
|
|
461
|
-
master_host: pulumi.Input[str]
|
|
462
|
-
master_port: pulumi.Input[int]
|
|
514
|
+
master_host: pulumi.Input[_builtins.str]
|
|
515
|
+
master_port: pulumi.Input[_builtins.int]
|
|
463
516
|
elif False:
|
|
464
517
|
ElastigroupIntegrationDockerSwarmArgsDict: TypeAlias = Mapping[str, Any]
|
|
465
518
|
|
|
466
519
|
@pulumi.input_type
|
|
467
520
|
class ElastigroupIntegrationDockerSwarmArgs:
|
|
468
521
|
def __init__(__self__, *,
|
|
469
|
-
master_host: pulumi.Input[str],
|
|
470
|
-
master_port: pulumi.Input[int]):
|
|
522
|
+
master_host: pulumi.Input[_builtins.str],
|
|
523
|
+
master_port: pulumi.Input[_builtins.int]):
|
|
471
524
|
pulumi.set(__self__, "master_host", master_host)
|
|
472
525
|
pulumi.set(__self__, "master_port", master_port)
|
|
473
526
|
|
|
474
|
-
@property
|
|
527
|
+
@_builtins.property
|
|
475
528
|
@pulumi.getter(name="masterHost")
|
|
476
|
-
def master_host(self) -> pulumi.Input[str]:
|
|
529
|
+
def master_host(self) -> pulumi.Input[_builtins.str]:
|
|
477
530
|
return pulumi.get(self, "master_host")
|
|
478
531
|
|
|
479
532
|
@master_host.setter
|
|
480
|
-
def master_host(self, value: pulumi.Input[str]):
|
|
533
|
+
def master_host(self, value: pulumi.Input[_builtins.str]):
|
|
481
534
|
pulumi.set(self, "master_host", value)
|
|
482
535
|
|
|
483
|
-
@property
|
|
536
|
+
@_builtins.property
|
|
484
537
|
@pulumi.getter(name="masterPort")
|
|
485
|
-
def master_port(self) -> pulumi.Input[int]:
|
|
538
|
+
def master_port(self) -> pulumi.Input[_builtins.int]:
|
|
486
539
|
return pulumi.get(self, "master_port")
|
|
487
540
|
|
|
488
541
|
@master_port.setter
|
|
489
|
-
def master_port(self, value: pulumi.Input[int]):
|
|
542
|
+
def master_port(self, value: pulumi.Input[_builtins.int]):
|
|
490
543
|
pulumi.set(self, "master_port", value)
|
|
491
544
|
|
|
492
545
|
|
|
493
546
|
if not MYPY:
|
|
494
547
|
class ElastigroupIntegrationGkeArgsDict(TypedDict):
|
|
495
|
-
auto_update: NotRequired[pulumi.Input[bool]]
|
|
496
|
-
autoscale_cooldown: NotRequired[pulumi.Input[int]]
|
|
548
|
+
auto_update: NotRequired[pulumi.Input[_builtins.bool]]
|
|
549
|
+
autoscale_cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
497
550
|
"""
|
|
498
551
|
The amount of time, in seconds, after a scaling activity completes before any further trigger-related scaling activities can start.
|
|
499
552
|
"""
|
|
@@ -505,8 +558,8 @@ if not MYPY:
|
|
|
505
558
|
"""
|
|
506
559
|
Headroom for the cluster.
|
|
507
560
|
"""
|
|
508
|
-
autoscale_is_auto_config: NotRequired[pulumi.Input[bool]]
|
|
509
|
-
autoscale_is_enabled: NotRequired[pulumi.Input[bool]]
|
|
561
|
+
autoscale_is_auto_config: NotRequired[pulumi.Input[_builtins.bool]]
|
|
562
|
+
autoscale_is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
510
563
|
"""
|
|
511
564
|
Specifies whether the auto scaling feature is enabled.
|
|
512
565
|
"""
|
|
@@ -514,8 +567,8 @@ if not MYPY:
|
|
|
514
567
|
"""
|
|
515
568
|
Labels to assign to the resource.
|
|
516
569
|
"""
|
|
517
|
-
cluster_id: NotRequired[pulumi.Input[str]]
|
|
518
|
-
location: NotRequired[pulumi.Input[str]]
|
|
570
|
+
cluster_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
571
|
+
location: NotRequired[pulumi.Input[_builtins.str]]
|
|
519
572
|
"""
|
|
520
573
|
The location of your GKE cluster.
|
|
521
574
|
"""
|
|
@@ -525,22 +578,22 @@ elif False:
|
|
|
525
578
|
@pulumi.input_type
|
|
526
579
|
class ElastigroupIntegrationGkeArgs:
|
|
527
580
|
def __init__(__self__, *,
|
|
528
|
-
auto_update: Optional[pulumi.Input[bool]] = None,
|
|
529
|
-
autoscale_cooldown: Optional[pulumi.Input[int]] = None,
|
|
581
|
+
auto_update: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
582
|
+
autoscale_cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
530
583
|
autoscale_down: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']] = None,
|
|
531
584
|
autoscale_headroom: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']] = None,
|
|
532
|
-
autoscale_is_auto_config: Optional[pulumi.Input[bool]] = None,
|
|
533
|
-
autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
585
|
+
autoscale_is_auto_config: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
586
|
+
autoscale_is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
534
587
|
autoscale_labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]] = None,
|
|
535
|
-
cluster_id: Optional[pulumi.Input[str]] = None,
|
|
536
|
-
location: Optional[pulumi.Input[str]] = None):
|
|
588
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
589
|
+
location: Optional[pulumi.Input[_builtins.str]] = None):
|
|
537
590
|
"""
|
|
538
|
-
:param pulumi.Input[int] autoscale_cooldown: The amount of time, in seconds, after a scaling activity completes before any further trigger-related scaling activities can start.
|
|
591
|
+
:param pulumi.Input[_builtins.int] autoscale_cooldown: The amount of time, in seconds, after a scaling activity completes before any further trigger-related scaling activities can start.
|
|
539
592
|
:param pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs'] autoscale_down: Enabling scale down.
|
|
540
593
|
:param pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs'] autoscale_headroom: Headroom for the cluster.
|
|
541
|
-
:param pulumi.Input[bool] autoscale_is_enabled: Specifies whether the auto scaling feature is enabled.
|
|
594
|
+
:param pulumi.Input[_builtins.bool] autoscale_is_enabled: Specifies whether the auto scaling feature is enabled.
|
|
542
595
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]] autoscale_labels: Labels to assign to the resource.
|
|
543
|
-
:param pulumi.Input[str] location: The location of your GKE cluster.
|
|
596
|
+
:param pulumi.Input[_builtins.str] location: The location of your GKE cluster.
|
|
544
597
|
"""
|
|
545
598
|
if auto_update is not None:
|
|
546
599
|
pulumi.set(__self__, "auto_update", auto_update)
|
|
@@ -561,28 +614,28 @@ class ElastigroupIntegrationGkeArgs:
|
|
|
561
614
|
if location is not None:
|
|
562
615
|
pulumi.set(__self__, "location", location)
|
|
563
616
|
|
|
564
|
-
@property
|
|
617
|
+
@_builtins.property
|
|
565
618
|
@pulumi.getter(name="autoUpdate")
|
|
566
|
-
def auto_update(self) -> Optional[pulumi.Input[bool]]:
|
|
619
|
+
def auto_update(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
567
620
|
return pulumi.get(self, "auto_update")
|
|
568
621
|
|
|
569
622
|
@auto_update.setter
|
|
570
|
-
def auto_update(self, value: Optional[pulumi.Input[bool]]):
|
|
623
|
+
def auto_update(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
571
624
|
pulumi.set(self, "auto_update", value)
|
|
572
625
|
|
|
573
|
-
@property
|
|
626
|
+
@_builtins.property
|
|
574
627
|
@pulumi.getter(name="autoscaleCooldown")
|
|
575
|
-
def autoscale_cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
628
|
+
def autoscale_cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
576
629
|
"""
|
|
577
630
|
The amount of time, in seconds, after a scaling activity completes before any further trigger-related scaling activities can start.
|
|
578
631
|
"""
|
|
579
632
|
return pulumi.get(self, "autoscale_cooldown")
|
|
580
633
|
|
|
581
634
|
@autoscale_cooldown.setter
|
|
582
|
-
def autoscale_cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
635
|
+
def autoscale_cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
583
636
|
pulumi.set(self, "autoscale_cooldown", value)
|
|
584
637
|
|
|
585
|
-
@property
|
|
638
|
+
@_builtins.property
|
|
586
639
|
@pulumi.getter(name="autoscaleDown")
|
|
587
640
|
def autoscale_down(self) -> Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']]:
|
|
588
641
|
"""
|
|
@@ -594,7 +647,7 @@ class ElastigroupIntegrationGkeArgs:
|
|
|
594
647
|
def autoscale_down(self, value: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleDownArgs']]):
|
|
595
648
|
pulumi.set(self, "autoscale_down", value)
|
|
596
649
|
|
|
597
|
-
@property
|
|
650
|
+
@_builtins.property
|
|
598
651
|
@pulumi.getter(name="autoscaleHeadroom")
|
|
599
652
|
def autoscale_headroom(self) -> Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']]:
|
|
600
653
|
"""
|
|
@@ -606,28 +659,28 @@ class ElastigroupIntegrationGkeArgs:
|
|
|
606
659
|
def autoscale_headroom(self, value: Optional[pulumi.Input['ElastigroupIntegrationGkeAutoscaleHeadroomArgs']]):
|
|
607
660
|
pulumi.set(self, "autoscale_headroom", value)
|
|
608
661
|
|
|
609
|
-
@property
|
|
662
|
+
@_builtins.property
|
|
610
663
|
@pulumi.getter(name="autoscaleIsAutoConfig")
|
|
611
|
-
def autoscale_is_auto_config(self) -> Optional[pulumi.Input[bool]]:
|
|
664
|
+
def autoscale_is_auto_config(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
612
665
|
return pulumi.get(self, "autoscale_is_auto_config")
|
|
613
666
|
|
|
614
667
|
@autoscale_is_auto_config.setter
|
|
615
|
-
def autoscale_is_auto_config(self, value: Optional[pulumi.Input[bool]]):
|
|
668
|
+
def autoscale_is_auto_config(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
616
669
|
pulumi.set(self, "autoscale_is_auto_config", value)
|
|
617
670
|
|
|
618
|
-
@property
|
|
671
|
+
@_builtins.property
|
|
619
672
|
@pulumi.getter(name="autoscaleIsEnabled")
|
|
620
|
-
def autoscale_is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
673
|
+
def autoscale_is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
621
674
|
"""
|
|
622
675
|
Specifies whether the auto scaling feature is enabled.
|
|
623
676
|
"""
|
|
624
677
|
return pulumi.get(self, "autoscale_is_enabled")
|
|
625
678
|
|
|
626
679
|
@autoscale_is_enabled.setter
|
|
627
|
-
def autoscale_is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
680
|
+
def autoscale_is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
628
681
|
pulumi.set(self, "autoscale_is_enabled", value)
|
|
629
682
|
|
|
630
|
-
@property
|
|
683
|
+
@_builtins.property
|
|
631
684
|
@pulumi.getter(name="autoscaleLabels")
|
|
632
685
|
def autoscale_labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]]:
|
|
633
686
|
"""
|
|
@@ -639,31 +692,31 @@ class ElastigroupIntegrationGkeArgs:
|
|
|
639
692
|
def autoscale_labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationGkeAutoscaleLabelArgs']]]]):
|
|
640
693
|
pulumi.set(self, "autoscale_labels", value)
|
|
641
694
|
|
|
642
|
-
@property
|
|
695
|
+
@_builtins.property
|
|
643
696
|
@pulumi.getter(name="clusterId")
|
|
644
|
-
def cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
697
|
+
def cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
645
698
|
return pulumi.get(self, "cluster_id")
|
|
646
699
|
|
|
647
700
|
@cluster_id.setter
|
|
648
|
-
def cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
701
|
+
def cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
649
702
|
pulumi.set(self, "cluster_id", value)
|
|
650
703
|
|
|
651
|
-
@property
|
|
704
|
+
@_builtins.property
|
|
652
705
|
@pulumi.getter
|
|
653
|
-
def location(self) -> Optional[pulumi.Input[str]]:
|
|
706
|
+
def location(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
654
707
|
"""
|
|
655
708
|
The location of your GKE cluster.
|
|
656
709
|
"""
|
|
657
710
|
return pulumi.get(self, "location")
|
|
658
711
|
|
|
659
712
|
@location.setter
|
|
660
|
-
def location(self, value: Optional[pulumi.Input[str]]):
|
|
713
|
+
def location(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
661
714
|
pulumi.set(self, "location", value)
|
|
662
715
|
|
|
663
716
|
|
|
664
717
|
if not MYPY:
|
|
665
718
|
class ElastigroupIntegrationGkeAutoscaleDownArgsDict(TypedDict):
|
|
666
|
-
evaluation_periods: NotRequired[pulumi.Input[int]]
|
|
719
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
667
720
|
"""
|
|
668
721
|
Amount of cooldown evaluation periods for scale down.
|
|
669
722
|
"""
|
|
@@ -673,37 +726,37 @@ elif False:
|
|
|
673
726
|
@pulumi.input_type
|
|
674
727
|
class ElastigroupIntegrationGkeAutoscaleDownArgs:
|
|
675
728
|
def __init__(__self__, *,
|
|
676
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None):
|
|
729
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None):
|
|
677
730
|
"""
|
|
678
|
-
:param pulumi.Input[int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
|
|
731
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
|
|
679
732
|
"""
|
|
680
733
|
if evaluation_periods is not None:
|
|
681
734
|
pulumi.set(__self__, "evaluation_periods", evaluation_periods)
|
|
682
735
|
|
|
683
|
-
@property
|
|
736
|
+
@_builtins.property
|
|
684
737
|
@pulumi.getter(name="evaluationPeriods")
|
|
685
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
738
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
686
739
|
"""
|
|
687
740
|
Amount of cooldown evaluation periods for scale down.
|
|
688
741
|
"""
|
|
689
742
|
return pulumi.get(self, "evaluation_periods")
|
|
690
743
|
|
|
691
744
|
@evaluation_periods.setter
|
|
692
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
745
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
693
746
|
pulumi.set(self, "evaluation_periods", value)
|
|
694
747
|
|
|
695
748
|
|
|
696
749
|
if not MYPY:
|
|
697
750
|
class ElastigroupIntegrationGkeAutoscaleHeadroomArgsDict(TypedDict):
|
|
698
|
-
cpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
751
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
699
752
|
"""
|
|
700
753
|
Cpu units for compute.
|
|
701
754
|
"""
|
|
702
|
-
memory_per_unit: NotRequired[pulumi.Input[int]]
|
|
755
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
703
756
|
"""
|
|
704
757
|
RAM units for compute.
|
|
705
758
|
"""
|
|
706
|
-
num_of_units: NotRequired[pulumi.Input[int]]
|
|
759
|
+
num_of_units: NotRequired[pulumi.Input[_builtins.int]]
|
|
707
760
|
"""
|
|
708
761
|
Amount of units for compute.
|
|
709
762
|
"""
|
|
@@ -713,13 +766,13 @@ elif False:
|
|
|
713
766
|
@pulumi.input_type
|
|
714
767
|
class ElastigroupIntegrationGkeAutoscaleHeadroomArgs:
|
|
715
768
|
def __init__(__self__, *,
|
|
716
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
717
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None,
|
|
718
|
-
num_of_units: Optional[pulumi.Input[int]] = None):
|
|
769
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
770
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
771
|
+
num_of_units: Optional[pulumi.Input[_builtins.int]] = None):
|
|
719
772
|
"""
|
|
720
|
-
:param pulumi.Input[int] cpu_per_unit: Cpu units for compute.
|
|
721
|
-
:param pulumi.Input[int] memory_per_unit: RAM units for compute.
|
|
722
|
-
:param pulumi.Input[int] num_of_units: Amount of units for compute.
|
|
773
|
+
:param pulumi.Input[_builtins.int] cpu_per_unit: Cpu units for compute.
|
|
774
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: RAM units for compute.
|
|
775
|
+
:param pulumi.Input[_builtins.int] num_of_units: Amount of units for compute.
|
|
723
776
|
"""
|
|
724
777
|
if cpu_per_unit is not None:
|
|
725
778
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -728,148 +781,148 @@ class ElastigroupIntegrationGkeAutoscaleHeadroomArgs:
|
|
|
728
781
|
if num_of_units is not None:
|
|
729
782
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
730
783
|
|
|
731
|
-
@property
|
|
784
|
+
@_builtins.property
|
|
732
785
|
@pulumi.getter(name="cpuPerUnit")
|
|
733
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
786
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
734
787
|
"""
|
|
735
788
|
Cpu units for compute.
|
|
736
789
|
"""
|
|
737
790
|
return pulumi.get(self, "cpu_per_unit")
|
|
738
791
|
|
|
739
792
|
@cpu_per_unit.setter
|
|
740
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
793
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
741
794
|
pulumi.set(self, "cpu_per_unit", value)
|
|
742
795
|
|
|
743
|
-
@property
|
|
796
|
+
@_builtins.property
|
|
744
797
|
@pulumi.getter(name="memoryPerUnit")
|
|
745
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
798
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
746
799
|
"""
|
|
747
800
|
RAM units for compute.
|
|
748
801
|
"""
|
|
749
802
|
return pulumi.get(self, "memory_per_unit")
|
|
750
803
|
|
|
751
804
|
@memory_per_unit.setter
|
|
752
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
805
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
753
806
|
pulumi.set(self, "memory_per_unit", value)
|
|
754
807
|
|
|
755
|
-
@property
|
|
808
|
+
@_builtins.property
|
|
756
809
|
@pulumi.getter(name="numOfUnits")
|
|
757
|
-
def num_of_units(self) -> Optional[pulumi.Input[int]]:
|
|
810
|
+
def num_of_units(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
758
811
|
"""
|
|
759
812
|
Amount of units for compute.
|
|
760
813
|
"""
|
|
761
814
|
return pulumi.get(self, "num_of_units")
|
|
762
815
|
|
|
763
816
|
@num_of_units.setter
|
|
764
|
-
def num_of_units(self, value: Optional[pulumi.Input[int]]):
|
|
817
|
+
def num_of_units(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
765
818
|
pulumi.set(self, "num_of_units", value)
|
|
766
819
|
|
|
767
820
|
|
|
768
821
|
if not MYPY:
|
|
769
822
|
class ElastigroupIntegrationGkeAutoscaleLabelArgsDict(TypedDict):
|
|
770
|
-
key: pulumi.Input[str]
|
|
771
|
-
value: pulumi.Input[str]
|
|
823
|
+
key: pulumi.Input[_builtins.str]
|
|
824
|
+
value: pulumi.Input[_builtins.str]
|
|
772
825
|
elif False:
|
|
773
826
|
ElastigroupIntegrationGkeAutoscaleLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
774
827
|
|
|
775
828
|
@pulumi.input_type
|
|
776
829
|
class ElastigroupIntegrationGkeAutoscaleLabelArgs:
|
|
777
830
|
def __init__(__self__, *,
|
|
778
|
-
key: pulumi.Input[str],
|
|
779
|
-
value: pulumi.Input[str]):
|
|
831
|
+
key: pulumi.Input[_builtins.str],
|
|
832
|
+
value: pulumi.Input[_builtins.str]):
|
|
780
833
|
pulumi.set(__self__, "key", key)
|
|
781
834
|
pulumi.set(__self__, "value", value)
|
|
782
835
|
|
|
783
|
-
@property
|
|
836
|
+
@_builtins.property
|
|
784
837
|
@pulumi.getter
|
|
785
|
-
def key(self) -> pulumi.Input[str]:
|
|
838
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
786
839
|
return pulumi.get(self, "key")
|
|
787
840
|
|
|
788
841
|
@key.setter
|
|
789
|
-
def key(self, value: pulumi.Input[str]):
|
|
842
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
790
843
|
pulumi.set(self, "key", value)
|
|
791
844
|
|
|
792
|
-
@property
|
|
845
|
+
@_builtins.property
|
|
793
846
|
@pulumi.getter
|
|
794
|
-
def value(self) -> pulumi.Input[str]:
|
|
847
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
795
848
|
return pulumi.get(self, "value")
|
|
796
849
|
|
|
797
850
|
@value.setter
|
|
798
|
-
def value(self, value: pulumi.Input[str]):
|
|
851
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
799
852
|
pulumi.set(self, "value", value)
|
|
800
853
|
|
|
801
854
|
|
|
802
855
|
if not MYPY:
|
|
803
856
|
class ElastigroupLabelArgsDict(TypedDict):
|
|
804
|
-
key: pulumi.Input[str]
|
|
805
|
-
value: pulumi.Input[str]
|
|
857
|
+
key: pulumi.Input[_builtins.str]
|
|
858
|
+
value: pulumi.Input[_builtins.str]
|
|
806
859
|
elif False:
|
|
807
860
|
ElastigroupLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
808
861
|
|
|
809
862
|
@pulumi.input_type
|
|
810
863
|
class ElastigroupLabelArgs:
|
|
811
864
|
def __init__(__self__, *,
|
|
812
|
-
key: pulumi.Input[str],
|
|
813
|
-
value: pulumi.Input[str]):
|
|
865
|
+
key: pulumi.Input[_builtins.str],
|
|
866
|
+
value: pulumi.Input[_builtins.str]):
|
|
814
867
|
pulumi.set(__self__, "key", key)
|
|
815
868
|
pulumi.set(__self__, "value", value)
|
|
816
869
|
|
|
817
|
-
@property
|
|
870
|
+
@_builtins.property
|
|
818
871
|
@pulumi.getter
|
|
819
|
-
def key(self) -> pulumi.Input[str]:
|
|
872
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
820
873
|
return pulumi.get(self, "key")
|
|
821
874
|
|
|
822
875
|
@key.setter
|
|
823
|
-
def key(self, value: pulumi.Input[str]):
|
|
876
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
824
877
|
pulumi.set(self, "key", value)
|
|
825
878
|
|
|
826
|
-
@property
|
|
879
|
+
@_builtins.property
|
|
827
880
|
@pulumi.getter
|
|
828
|
-
def value(self) -> pulumi.Input[str]:
|
|
881
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
829
882
|
return pulumi.get(self, "value")
|
|
830
883
|
|
|
831
884
|
@value.setter
|
|
832
|
-
def value(self, value: pulumi.Input[str]):
|
|
885
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
833
886
|
pulumi.set(self, "value", value)
|
|
834
887
|
|
|
835
888
|
|
|
836
889
|
if not MYPY:
|
|
837
890
|
class ElastigroupMetadataArgsDict(TypedDict):
|
|
838
|
-
key: pulumi.Input[str]
|
|
839
|
-
value: pulumi.Input[str]
|
|
891
|
+
key: pulumi.Input[_builtins.str]
|
|
892
|
+
value: pulumi.Input[_builtins.str]
|
|
840
893
|
elif False:
|
|
841
894
|
ElastigroupMetadataArgsDict: TypeAlias = Mapping[str, Any]
|
|
842
895
|
|
|
843
896
|
@pulumi.input_type
|
|
844
897
|
class ElastigroupMetadataArgs:
|
|
845
898
|
def __init__(__self__, *,
|
|
846
|
-
key: pulumi.Input[str],
|
|
847
|
-
value: pulumi.Input[str]):
|
|
899
|
+
key: pulumi.Input[_builtins.str],
|
|
900
|
+
value: pulumi.Input[_builtins.str]):
|
|
848
901
|
pulumi.set(__self__, "key", key)
|
|
849
902
|
pulumi.set(__self__, "value", value)
|
|
850
903
|
|
|
851
|
-
@property
|
|
904
|
+
@_builtins.property
|
|
852
905
|
@pulumi.getter
|
|
853
|
-
def key(self) -> pulumi.Input[str]:
|
|
906
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
854
907
|
return pulumi.get(self, "key")
|
|
855
908
|
|
|
856
909
|
@key.setter
|
|
857
|
-
def key(self, value: pulumi.Input[str]):
|
|
910
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
858
911
|
pulumi.set(self, "key", value)
|
|
859
912
|
|
|
860
|
-
@property
|
|
913
|
+
@_builtins.property
|
|
861
914
|
@pulumi.getter
|
|
862
|
-
def value(self) -> pulumi.Input[str]:
|
|
915
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
863
916
|
return pulumi.get(self, "value")
|
|
864
917
|
|
|
865
918
|
@value.setter
|
|
866
|
-
def value(self, value: pulumi.Input[str]):
|
|
919
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
867
920
|
pulumi.set(self, "value", value)
|
|
868
921
|
|
|
869
922
|
|
|
870
923
|
if not MYPY:
|
|
871
924
|
class ElastigroupNetworkInterfaceArgsDict(TypedDict):
|
|
872
|
-
network: pulumi.Input[str]
|
|
925
|
+
network: pulumi.Input[_builtins.str]
|
|
873
926
|
access_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgsDict']]]]
|
|
874
927
|
alias_ip_ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgsDict']]]]
|
|
875
928
|
elif False:
|
|
@@ -878,7 +931,7 @@ elif False:
|
|
|
878
931
|
@pulumi.input_type
|
|
879
932
|
class ElastigroupNetworkInterfaceArgs:
|
|
880
933
|
def __init__(__self__, *,
|
|
881
|
-
network: pulumi.Input[str],
|
|
934
|
+
network: pulumi.Input[_builtins.str],
|
|
882
935
|
access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]] = None,
|
|
883
936
|
alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgs']]]] = None):
|
|
884
937
|
pulumi.set(__self__, "network", network)
|
|
@@ -887,16 +940,16 @@ class ElastigroupNetworkInterfaceArgs:
|
|
|
887
940
|
if alias_ip_ranges is not None:
|
|
888
941
|
pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
|
|
889
942
|
|
|
890
|
-
@property
|
|
943
|
+
@_builtins.property
|
|
891
944
|
@pulumi.getter
|
|
892
|
-
def network(self) -> pulumi.Input[str]:
|
|
945
|
+
def network(self) -> pulumi.Input[_builtins.str]:
|
|
893
946
|
return pulumi.get(self, "network")
|
|
894
947
|
|
|
895
948
|
@network.setter
|
|
896
|
-
def network(self, value: pulumi.Input[str]):
|
|
949
|
+
def network(self, value: pulumi.Input[_builtins.str]):
|
|
897
950
|
pulumi.set(self, "network", value)
|
|
898
951
|
|
|
899
|
-
@property
|
|
952
|
+
@_builtins.property
|
|
900
953
|
@pulumi.getter(name="accessConfigs")
|
|
901
954
|
def access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]]:
|
|
902
955
|
return pulumi.get(self, "access_configs")
|
|
@@ -905,7 +958,7 @@ class ElastigroupNetworkInterfaceArgs:
|
|
|
905
958
|
def access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAccessConfigArgs']]]]):
|
|
906
959
|
pulumi.set(self, "access_configs", value)
|
|
907
960
|
|
|
908
|
-
@property
|
|
961
|
+
@_builtins.property
|
|
909
962
|
@pulumi.getter(name="aliasIpRanges")
|
|
910
963
|
def alias_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceAliasIpRangeArgs']]]]:
|
|
911
964
|
return pulumi.get(self, "alias_ip_ranges")
|
|
@@ -917,137 +970,137 @@ class ElastigroupNetworkInterfaceArgs:
|
|
|
917
970
|
|
|
918
971
|
if not MYPY:
|
|
919
972
|
class ElastigroupNetworkInterfaceAccessConfigArgsDict(TypedDict):
|
|
920
|
-
name: NotRequired[pulumi.Input[str]]
|
|
921
|
-
type: NotRequired[pulumi.Input[str]]
|
|
973
|
+
name: NotRequired[pulumi.Input[_builtins.str]]
|
|
974
|
+
type: NotRequired[pulumi.Input[_builtins.str]]
|
|
922
975
|
elif False:
|
|
923
976
|
ElastigroupNetworkInterfaceAccessConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
924
977
|
|
|
925
978
|
@pulumi.input_type
|
|
926
979
|
class ElastigroupNetworkInterfaceAccessConfigArgs:
|
|
927
980
|
def __init__(__self__, *,
|
|
928
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
929
|
-
type: Optional[pulumi.Input[str]] = None):
|
|
981
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
982
|
+
type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
930
983
|
if name is not None:
|
|
931
984
|
pulumi.set(__self__, "name", name)
|
|
932
985
|
if type is not None:
|
|
933
986
|
pulumi.set(__self__, "type", type)
|
|
934
987
|
|
|
935
|
-
@property
|
|
988
|
+
@_builtins.property
|
|
936
989
|
@pulumi.getter
|
|
937
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
990
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
938
991
|
return pulumi.get(self, "name")
|
|
939
992
|
|
|
940
993
|
@name.setter
|
|
941
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
994
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
942
995
|
pulumi.set(self, "name", value)
|
|
943
996
|
|
|
944
|
-
@property
|
|
997
|
+
@_builtins.property
|
|
945
998
|
@pulumi.getter
|
|
946
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
999
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
947
1000
|
return pulumi.get(self, "type")
|
|
948
1001
|
|
|
949
1002
|
@type.setter
|
|
950
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
1003
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
951
1004
|
pulumi.set(self, "type", value)
|
|
952
1005
|
|
|
953
1006
|
|
|
954
1007
|
if not MYPY:
|
|
955
1008
|
class ElastigroupNetworkInterfaceAliasIpRangeArgsDict(TypedDict):
|
|
956
|
-
ip_cidr_range: pulumi.Input[str]
|
|
957
|
-
subnetwork_range_name: pulumi.Input[str]
|
|
1009
|
+
ip_cidr_range: pulumi.Input[_builtins.str]
|
|
1010
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]
|
|
958
1011
|
elif False:
|
|
959
1012
|
ElastigroupNetworkInterfaceAliasIpRangeArgsDict: TypeAlias = Mapping[str, Any]
|
|
960
1013
|
|
|
961
1014
|
@pulumi.input_type
|
|
962
1015
|
class ElastigroupNetworkInterfaceAliasIpRangeArgs:
|
|
963
1016
|
def __init__(__self__, *,
|
|
964
|
-
ip_cidr_range: pulumi.Input[str],
|
|
965
|
-
subnetwork_range_name: pulumi.Input[str]):
|
|
1017
|
+
ip_cidr_range: pulumi.Input[_builtins.str],
|
|
1018
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]):
|
|
966
1019
|
pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
|
|
967
1020
|
pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
|
|
968
1021
|
|
|
969
|
-
@property
|
|
1022
|
+
@_builtins.property
|
|
970
1023
|
@pulumi.getter(name="ipCidrRange")
|
|
971
|
-
def ip_cidr_range(self) -> pulumi.Input[str]:
|
|
1024
|
+
def ip_cidr_range(self) -> pulumi.Input[_builtins.str]:
|
|
972
1025
|
return pulumi.get(self, "ip_cidr_range")
|
|
973
1026
|
|
|
974
1027
|
@ip_cidr_range.setter
|
|
975
|
-
def ip_cidr_range(self, value: pulumi.Input[str]):
|
|
1028
|
+
def ip_cidr_range(self, value: pulumi.Input[_builtins.str]):
|
|
976
1029
|
pulumi.set(self, "ip_cidr_range", value)
|
|
977
1030
|
|
|
978
|
-
@property
|
|
1031
|
+
@_builtins.property
|
|
979
1032
|
@pulumi.getter(name="subnetworkRangeName")
|
|
980
|
-
def subnetwork_range_name(self) -> pulumi.Input[str]:
|
|
1033
|
+
def subnetwork_range_name(self) -> pulumi.Input[_builtins.str]:
|
|
981
1034
|
return pulumi.get(self, "subnetwork_range_name")
|
|
982
1035
|
|
|
983
1036
|
@subnetwork_range_name.setter
|
|
984
|
-
def subnetwork_range_name(self, value: pulumi.Input[str]):
|
|
1037
|
+
def subnetwork_range_name(self, value: pulumi.Input[_builtins.str]):
|
|
985
1038
|
pulumi.set(self, "subnetwork_range_name", value)
|
|
986
1039
|
|
|
987
1040
|
|
|
988
1041
|
if not MYPY:
|
|
989
1042
|
class ElastigroupRevertToPreemptibleArgsDict(TypedDict):
|
|
990
|
-
perform_at: pulumi.Input[str]
|
|
1043
|
+
perform_at: pulumi.Input[_builtins.str]
|
|
991
1044
|
elif False:
|
|
992
1045
|
ElastigroupRevertToPreemptibleArgsDict: TypeAlias = Mapping[str, Any]
|
|
993
1046
|
|
|
994
1047
|
@pulumi.input_type
|
|
995
1048
|
class ElastigroupRevertToPreemptibleArgs:
|
|
996
1049
|
def __init__(__self__, *,
|
|
997
|
-
perform_at: pulumi.Input[str]):
|
|
1050
|
+
perform_at: pulumi.Input[_builtins.str]):
|
|
998
1051
|
pulumi.set(__self__, "perform_at", perform_at)
|
|
999
1052
|
|
|
1000
|
-
@property
|
|
1053
|
+
@_builtins.property
|
|
1001
1054
|
@pulumi.getter(name="performAt")
|
|
1002
|
-
def perform_at(self) -> pulumi.Input[str]:
|
|
1055
|
+
def perform_at(self) -> pulumi.Input[_builtins.str]:
|
|
1003
1056
|
return pulumi.get(self, "perform_at")
|
|
1004
1057
|
|
|
1005
1058
|
@perform_at.setter
|
|
1006
|
-
def perform_at(self, value: pulumi.Input[str]):
|
|
1059
|
+
def perform_at(self, value: pulumi.Input[_builtins.str]):
|
|
1007
1060
|
pulumi.set(self, "perform_at", value)
|
|
1008
1061
|
|
|
1009
1062
|
|
|
1010
1063
|
if not MYPY:
|
|
1011
1064
|
class ElastigroupScalingDownPolicyArgsDict(TypedDict):
|
|
1012
|
-
metric_name: pulumi.Input[str]
|
|
1013
|
-
namespace: pulumi.Input[str]
|
|
1014
|
-
policy_name: pulumi.Input[str]
|
|
1015
|
-
threshold: pulumi.Input[float]
|
|
1016
|
-
unit: pulumi.Input[str]
|
|
1017
|
-
action_type: NotRequired[pulumi.Input[str]]
|
|
1018
|
-
adjustment: NotRequired[pulumi.Input[int]]
|
|
1019
|
-
cooldown: NotRequired[pulumi.Input[int]]
|
|
1065
|
+
metric_name: pulumi.Input[_builtins.str]
|
|
1066
|
+
namespace: pulumi.Input[_builtins.str]
|
|
1067
|
+
policy_name: pulumi.Input[_builtins.str]
|
|
1068
|
+
threshold: pulumi.Input[_builtins.float]
|
|
1069
|
+
unit: pulumi.Input[_builtins.str]
|
|
1070
|
+
action_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1071
|
+
adjustment: NotRequired[pulumi.Input[_builtins.int]]
|
|
1072
|
+
cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
1020
1073
|
dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgsDict']]]]
|
|
1021
|
-
evaluation_periods: NotRequired[pulumi.Input[int]]
|
|
1074
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
1022
1075
|
"""
|
|
1023
1076
|
Amount of cooldown evaluation periods for scale down.
|
|
1024
1077
|
"""
|
|
1025
|
-
operator: NotRequired[pulumi.Input[str]]
|
|
1026
|
-
period: NotRequired[pulumi.Input[int]]
|
|
1027
|
-
source: NotRequired[pulumi.Input[str]]
|
|
1028
|
-
statistic: NotRequired[pulumi.Input[str]]
|
|
1078
|
+
operator: NotRequired[pulumi.Input[_builtins.str]]
|
|
1079
|
+
period: NotRequired[pulumi.Input[_builtins.int]]
|
|
1080
|
+
source: NotRequired[pulumi.Input[_builtins.str]]
|
|
1081
|
+
statistic: NotRequired[pulumi.Input[_builtins.str]]
|
|
1029
1082
|
elif False:
|
|
1030
1083
|
ElastigroupScalingDownPolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1031
1084
|
|
|
1032
1085
|
@pulumi.input_type
|
|
1033
1086
|
class ElastigroupScalingDownPolicyArgs:
|
|
1034
1087
|
def __init__(__self__, *,
|
|
1035
|
-
metric_name: pulumi.Input[str],
|
|
1036
|
-
namespace: pulumi.Input[str],
|
|
1037
|
-
policy_name: pulumi.Input[str],
|
|
1038
|
-
threshold: pulumi.Input[float],
|
|
1039
|
-
unit: pulumi.Input[str],
|
|
1040
|
-
action_type: Optional[pulumi.Input[str]] = None,
|
|
1041
|
-
adjustment: Optional[pulumi.Input[int]] = None,
|
|
1042
|
-
cooldown: Optional[pulumi.Input[int]] = None,
|
|
1088
|
+
metric_name: pulumi.Input[_builtins.str],
|
|
1089
|
+
namespace: pulumi.Input[_builtins.str],
|
|
1090
|
+
policy_name: pulumi.Input[_builtins.str],
|
|
1091
|
+
threshold: pulumi.Input[_builtins.float],
|
|
1092
|
+
unit: pulumi.Input[_builtins.str],
|
|
1093
|
+
action_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1094
|
+
adjustment: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1095
|
+
cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1043
1096
|
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]] = None,
|
|
1044
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None,
|
|
1045
|
-
operator: Optional[pulumi.Input[str]] = None,
|
|
1046
|
-
period: Optional[pulumi.Input[int]] = None,
|
|
1047
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
1048
|
-
statistic: Optional[pulumi.Input[str]] = None):
|
|
1097
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1098
|
+
operator: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1099
|
+
period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1100
|
+
source: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1101
|
+
statistic: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1049
1102
|
"""
|
|
1050
|
-
:param pulumi.Input[int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
|
|
1103
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
|
|
1051
1104
|
"""
|
|
1052
1105
|
pulumi.set(__self__, "metric_name", metric_name)
|
|
1053
1106
|
pulumi.set(__self__, "namespace", namespace)
|
|
@@ -1073,79 +1126,79 @@ class ElastigroupScalingDownPolicyArgs:
|
|
|
1073
1126
|
if statistic is not None:
|
|
1074
1127
|
pulumi.set(__self__, "statistic", statistic)
|
|
1075
1128
|
|
|
1076
|
-
@property
|
|
1129
|
+
@_builtins.property
|
|
1077
1130
|
@pulumi.getter(name="metricName")
|
|
1078
|
-
def metric_name(self) -> pulumi.Input[str]:
|
|
1131
|
+
def metric_name(self) -> pulumi.Input[_builtins.str]:
|
|
1079
1132
|
return pulumi.get(self, "metric_name")
|
|
1080
1133
|
|
|
1081
1134
|
@metric_name.setter
|
|
1082
|
-
def metric_name(self, value: pulumi.Input[str]):
|
|
1135
|
+
def metric_name(self, value: pulumi.Input[_builtins.str]):
|
|
1083
1136
|
pulumi.set(self, "metric_name", value)
|
|
1084
1137
|
|
|
1085
|
-
@property
|
|
1138
|
+
@_builtins.property
|
|
1086
1139
|
@pulumi.getter
|
|
1087
|
-
def namespace(self) -> pulumi.Input[str]:
|
|
1140
|
+
def namespace(self) -> pulumi.Input[_builtins.str]:
|
|
1088
1141
|
return pulumi.get(self, "namespace")
|
|
1089
1142
|
|
|
1090
1143
|
@namespace.setter
|
|
1091
|
-
def namespace(self, value: pulumi.Input[str]):
|
|
1144
|
+
def namespace(self, value: pulumi.Input[_builtins.str]):
|
|
1092
1145
|
pulumi.set(self, "namespace", value)
|
|
1093
1146
|
|
|
1094
|
-
@property
|
|
1147
|
+
@_builtins.property
|
|
1095
1148
|
@pulumi.getter(name="policyName")
|
|
1096
|
-
def policy_name(self) -> pulumi.Input[str]:
|
|
1149
|
+
def policy_name(self) -> pulumi.Input[_builtins.str]:
|
|
1097
1150
|
return pulumi.get(self, "policy_name")
|
|
1098
1151
|
|
|
1099
1152
|
@policy_name.setter
|
|
1100
|
-
def policy_name(self, value: pulumi.Input[str]):
|
|
1153
|
+
def policy_name(self, value: pulumi.Input[_builtins.str]):
|
|
1101
1154
|
pulumi.set(self, "policy_name", value)
|
|
1102
1155
|
|
|
1103
|
-
@property
|
|
1156
|
+
@_builtins.property
|
|
1104
1157
|
@pulumi.getter
|
|
1105
|
-
def threshold(self) -> pulumi.Input[float]:
|
|
1158
|
+
def threshold(self) -> pulumi.Input[_builtins.float]:
|
|
1106
1159
|
return pulumi.get(self, "threshold")
|
|
1107
1160
|
|
|
1108
1161
|
@threshold.setter
|
|
1109
|
-
def threshold(self, value: pulumi.Input[float]):
|
|
1162
|
+
def threshold(self, value: pulumi.Input[_builtins.float]):
|
|
1110
1163
|
pulumi.set(self, "threshold", value)
|
|
1111
1164
|
|
|
1112
|
-
@property
|
|
1165
|
+
@_builtins.property
|
|
1113
1166
|
@pulumi.getter
|
|
1114
|
-
def unit(self) -> pulumi.Input[str]:
|
|
1167
|
+
def unit(self) -> pulumi.Input[_builtins.str]:
|
|
1115
1168
|
return pulumi.get(self, "unit")
|
|
1116
1169
|
|
|
1117
1170
|
@unit.setter
|
|
1118
|
-
def unit(self, value: pulumi.Input[str]):
|
|
1171
|
+
def unit(self, value: pulumi.Input[_builtins.str]):
|
|
1119
1172
|
pulumi.set(self, "unit", value)
|
|
1120
1173
|
|
|
1121
|
-
@property
|
|
1174
|
+
@_builtins.property
|
|
1122
1175
|
@pulumi.getter(name="actionType")
|
|
1123
|
-
def action_type(self) -> Optional[pulumi.Input[str]]:
|
|
1176
|
+
def action_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1124
1177
|
return pulumi.get(self, "action_type")
|
|
1125
1178
|
|
|
1126
1179
|
@action_type.setter
|
|
1127
|
-
def action_type(self, value: Optional[pulumi.Input[str]]):
|
|
1180
|
+
def action_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1128
1181
|
pulumi.set(self, "action_type", value)
|
|
1129
1182
|
|
|
1130
|
-
@property
|
|
1183
|
+
@_builtins.property
|
|
1131
1184
|
@pulumi.getter
|
|
1132
|
-
def adjustment(self) -> Optional[pulumi.Input[int]]:
|
|
1185
|
+
def adjustment(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1133
1186
|
return pulumi.get(self, "adjustment")
|
|
1134
1187
|
|
|
1135
1188
|
@adjustment.setter
|
|
1136
|
-
def adjustment(self, value: Optional[pulumi.Input[int]]):
|
|
1189
|
+
def adjustment(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1137
1190
|
pulumi.set(self, "adjustment", value)
|
|
1138
1191
|
|
|
1139
|
-
@property
|
|
1192
|
+
@_builtins.property
|
|
1140
1193
|
@pulumi.getter
|
|
1141
|
-
def cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
1194
|
+
def cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1142
1195
|
return pulumi.get(self, "cooldown")
|
|
1143
1196
|
|
|
1144
1197
|
@cooldown.setter
|
|
1145
|
-
def cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
1198
|
+
def cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1146
1199
|
pulumi.set(self, "cooldown", value)
|
|
1147
1200
|
|
|
1148
|
-
@property
|
|
1201
|
+
@_builtins.property
|
|
1149
1202
|
@pulumi.getter
|
|
1150
1203
|
def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]]:
|
|
1151
1204
|
return pulumi.get(self, "dimensions")
|
|
@@ -1154,131 +1207,131 @@ class ElastigroupScalingDownPolicyArgs:
|
|
|
1154
1207
|
def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyDimensionArgs']]]]):
|
|
1155
1208
|
pulumi.set(self, "dimensions", value)
|
|
1156
1209
|
|
|
1157
|
-
@property
|
|
1210
|
+
@_builtins.property
|
|
1158
1211
|
@pulumi.getter(name="evaluationPeriods")
|
|
1159
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
1212
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1160
1213
|
"""
|
|
1161
1214
|
Amount of cooldown evaluation periods for scale down.
|
|
1162
1215
|
"""
|
|
1163
1216
|
return pulumi.get(self, "evaluation_periods")
|
|
1164
1217
|
|
|
1165
1218
|
@evaluation_periods.setter
|
|
1166
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
1219
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1167
1220
|
pulumi.set(self, "evaluation_periods", value)
|
|
1168
1221
|
|
|
1169
|
-
@property
|
|
1222
|
+
@_builtins.property
|
|
1170
1223
|
@pulumi.getter
|
|
1171
|
-
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1224
|
+
def operator(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1172
1225
|
return pulumi.get(self, "operator")
|
|
1173
1226
|
|
|
1174
1227
|
@operator.setter
|
|
1175
|
-
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1228
|
+
def operator(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1176
1229
|
pulumi.set(self, "operator", value)
|
|
1177
1230
|
|
|
1178
|
-
@property
|
|
1231
|
+
@_builtins.property
|
|
1179
1232
|
@pulumi.getter
|
|
1180
|
-
def period(self) -> Optional[pulumi.Input[int]]:
|
|
1233
|
+
def period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1181
1234
|
return pulumi.get(self, "period")
|
|
1182
1235
|
|
|
1183
1236
|
@period.setter
|
|
1184
|
-
def period(self, value: Optional[pulumi.Input[int]]):
|
|
1237
|
+
def period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1185
1238
|
pulumi.set(self, "period", value)
|
|
1186
1239
|
|
|
1187
|
-
@property
|
|
1240
|
+
@_builtins.property
|
|
1188
1241
|
@pulumi.getter
|
|
1189
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
1242
|
+
def source(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1190
1243
|
return pulumi.get(self, "source")
|
|
1191
1244
|
|
|
1192
1245
|
@source.setter
|
|
1193
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
1246
|
+
def source(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1194
1247
|
pulumi.set(self, "source", value)
|
|
1195
1248
|
|
|
1196
|
-
@property
|
|
1249
|
+
@_builtins.property
|
|
1197
1250
|
@pulumi.getter
|
|
1198
|
-
def statistic(self) -> Optional[pulumi.Input[str]]:
|
|
1251
|
+
def statistic(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1199
1252
|
return pulumi.get(self, "statistic")
|
|
1200
1253
|
|
|
1201
1254
|
@statistic.setter
|
|
1202
|
-
def statistic(self, value: Optional[pulumi.Input[str]]):
|
|
1255
|
+
def statistic(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1203
1256
|
pulumi.set(self, "statistic", value)
|
|
1204
1257
|
|
|
1205
1258
|
|
|
1206
1259
|
if not MYPY:
|
|
1207
1260
|
class ElastigroupScalingDownPolicyDimensionArgsDict(TypedDict):
|
|
1208
|
-
name: pulumi.Input[str]
|
|
1209
|
-
value: NotRequired[pulumi.Input[str]]
|
|
1261
|
+
name: pulumi.Input[_builtins.str]
|
|
1262
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
1210
1263
|
elif False:
|
|
1211
1264
|
ElastigroupScalingDownPolicyDimensionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1212
1265
|
|
|
1213
1266
|
@pulumi.input_type
|
|
1214
1267
|
class ElastigroupScalingDownPolicyDimensionArgs:
|
|
1215
1268
|
def __init__(__self__, *,
|
|
1216
|
-
name: pulumi.Input[str],
|
|
1217
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
1269
|
+
name: pulumi.Input[_builtins.str],
|
|
1270
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1218
1271
|
pulumi.set(__self__, "name", name)
|
|
1219
1272
|
if value is not None:
|
|
1220
1273
|
pulumi.set(__self__, "value", value)
|
|
1221
1274
|
|
|
1222
|
-
@property
|
|
1275
|
+
@_builtins.property
|
|
1223
1276
|
@pulumi.getter
|
|
1224
|
-
def name(self) -> pulumi.Input[str]:
|
|
1277
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
1225
1278
|
return pulumi.get(self, "name")
|
|
1226
1279
|
|
|
1227
1280
|
@name.setter
|
|
1228
|
-
def name(self, value: pulumi.Input[str]):
|
|
1281
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
1229
1282
|
pulumi.set(self, "name", value)
|
|
1230
1283
|
|
|
1231
|
-
@property
|
|
1284
|
+
@_builtins.property
|
|
1232
1285
|
@pulumi.getter
|
|
1233
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
1286
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1234
1287
|
return pulumi.get(self, "value")
|
|
1235
1288
|
|
|
1236
1289
|
@value.setter
|
|
1237
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
1290
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1238
1291
|
pulumi.set(self, "value", value)
|
|
1239
1292
|
|
|
1240
1293
|
|
|
1241
1294
|
if not MYPY:
|
|
1242
1295
|
class ElastigroupScalingUpPolicyArgsDict(TypedDict):
|
|
1243
|
-
metric_name: pulumi.Input[str]
|
|
1244
|
-
namespace: pulumi.Input[str]
|
|
1245
|
-
policy_name: pulumi.Input[str]
|
|
1246
|
-
threshold: pulumi.Input[float]
|
|
1247
|
-
unit: pulumi.Input[str]
|
|
1248
|
-
action_type: NotRequired[pulumi.Input[str]]
|
|
1249
|
-
adjustment: NotRequired[pulumi.Input[int]]
|
|
1250
|
-
cooldown: NotRequired[pulumi.Input[int]]
|
|
1296
|
+
metric_name: pulumi.Input[_builtins.str]
|
|
1297
|
+
namespace: pulumi.Input[_builtins.str]
|
|
1298
|
+
policy_name: pulumi.Input[_builtins.str]
|
|
1299
|
+
threshold: pulumi.Input[_builtins.float]
|
|
1300
|
+
unit: pulumi.Input[_builtins.str]
|
|
1301
|
+
action_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1302
|
+
adjustment: NotRequired[pulumi.Input[_builtins.int]]
|
|
1303
|
+
cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
1251
1304
|
dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgsDict']]]]
|
|
1252
|
-
evaluation_periods: NotRequired[pulumi.Input[int]]
|
|
1305
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
1253
1306
|
"""
|
|
1254
1307
|
Amount of cooldown evaluation periods for scale down.
|
|
1255
1308
|
"""
|
|
1256
|
-
operator: NotRequired[pulumi.Input[str]]
|
|
1257
|
-
period: NotRequired[pulumi.Input[int]]
|
|
1258
|
-
source: NotRequired[pulumi.Input[str]]
|
|
1259
|
-
statistic: NotRequired[pulumi.Input[str]]
|
|
1309
|
+
operator: NotRequired[pulumi.Input[_builtins.str]]
|
|
1310
|
+
period: NotRequired[pulumi.Input[_builtins.int]]
|
|
1311
|
+
source: NotRequired[pulumi.Input[_builtins.str]]
|
|
1312
|
+
statistic: NotRequired[pulumi.Input[_builtins.str]]
|
|
1260
1313
|
elif False:
|
|
1261
1314
|
ElastigroupScalingUpPolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1262
1315
|
|
|
1263
1316
|
@pulumi.input_type
|
|
1264
1317
|
class ElastigroupScalingUpPolicyArgs:
|
|
1265
1318
|
def __init__(__self__, *,
|
|
1266
|
-
metric_name: pulumi.Input[str],
|
|
1267
|
-
namespace: pulumi.Input[str],
|
|
1268
|
-
policy_name: pulumi.Input[str],
|
|
1269
|
-
threshold: pulumi.Input[float],
|
|
1270
|
-
unit: pulumi.Input[str],
|
|
1271
|
-
action_type: Optional[pulumi.Input[str]] = None,
|
|
1272
|
-
adjustment: Optional[pulumi.Input[int]] = None,
|
|
1273
|
-
cooldown: Optional[pulumi.Input[int]] = None,
|
|
1319
|
+
metric_name: pulumi.Input[_builtins.str],
|
|
1320
|
+
namespace: pulumi.Input[_builtins.str],
|
|
1321
|
+
policy_name: pulumi.Input[_builtins.str],
|
|
1322
|
+
threshold: pulumi.Input[_builtins.float],
|
|
1323
|
+
unit: pulumi.Input[_builtins.str],
|
|
1324
|
+
action_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1325
|
+
adjustment: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1326
|
+
cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1274
1327
|
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]] = None,
|
|
1275
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None,
|
|
1276
|
-
operator: Optional[pulumi.Input[str]] = None,
|
|
1277
|
-
period: Optional[pulumi.Input[int]] = None,
|
|
1278
|
-
source: Optional[pulumi.Input[str]] = None,
|
|
1279
|
-
statistic: Optional[pulumi.Input[str]] = None):
|
|
1328
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1329
|
+
operator: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1330
|
+
period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1331
|
+
source: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1332
|
+
statistic: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1280
1333
|
"""
|
|
1281
|
-
:param pulumi.Input[int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
|
|
1334
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: Amount of cooldown evaluation periods for scale down.
|
|
1282
1335
|
"""
|
|
1283
1336
|
pulumi.set(__self__, "metric_name", metric_name)
|
|
1284
1337
|
pulumi.set(__self__, "namespace", namespace)
|
|
@@ -1304,79 +1357,79 @@ class ElastigroupScalingUpPolicyArgs:
|
|
|
1304
1357
|
if statistic is not None:
|
|
1305
1358
|
pulumi.set(__self__, "statistic", statistic)
|
|
1306
1359
|
|
|
1307
|
-
@property
|
|
1360
|
+
@_builtins.property
|
|
1308
1361
|
@pulumi.getter(name="metricName")
|
|
1309
|
-
def metric_name(self) -> pulumi.Input[str]:
|
|
1362
|
+
def metric_name(self) -> pulumi.Input[_builtins.str]:
|
|
1310
1363
|
return pulumi.get(self, "metric_name")
|
|
1311
1364
|
|
|
1312
1365
|
@metric_name.setter
|
|
1313
|
-
def metric_name(self, value: pulumi.Input[str]):
|
|
1366
|
+
def metric_name(self, value: pulumi.Input[_builtins.str]):
|
|
1314
1367
|
pulumi.set(self, "metric_name", value)
|
|
1315
1368
|
|
|
1316
|
-
@property
|
|
1369
|
+
@_builtins.property
|
|
1317
1370
|
@pulumi.getter
|
|
1318
|
-
def namespace(self) -> pulumi.Input[str]:
|
|
1371
|
+
def namespace(self) -> pulumi.Input[_builtins.str]:
|
|
1319
1372
|
return pulumi.get(self, "namespace")
|
|
1320
1373
|
|
|
1321
1374
|
@namespace.setter
|
|
1322
|
-
def namespace(self, value: pulumi.Input[str]):
|
|
1375
|
+
def namespace(self, value: pulumi.Input[_builtins.str]):
|
|
1323
1376
|
pulumi.set(self, "namespace", value)
|
|
1324
1377
|
|
|
1325
|
-
@property
|
|
1378
|
+
@_builtins.property
|
|
1326
1379
|
@pulumi.getter(name="policyName")
|
|
1327
|
-
def policy_name(self) -> pulumi.Input[str]:
|
|
1380
|
+
def policy_name(self) -> pulumi.Input[_builtins.str]:
|
|
1328
1381
|
return pulumi.get(self, "policy_name")
|
|
1329
1382
|
|
|
1330
1383
|
@policy_name.setter
|
|
1331
|
-
def policy_name(self, value: pulumi.Input[str]):
|
|
1384
|
+
def policy_name(self, value: pulumi.Input[_builtins.str]):
|
|
1332
1385
|
pulumi.set(self, "policy_name", value)
|
|
1333
1386
|
|
|
1334
|
-
@property
|
|
1387
|
+
@_builtins.property
|
|
1335
1388
|
@pulumi.getter
|
|
1336
|
-
def threshold(self) -> pulumi.Input[float]:
|
|
1389
|
+
def threshold(self) -> pulumi.Input[_builtins.float]:
|
|
1337
1390
|
return pulumi.get(self, "threshold")
|
|
1338
1391
|
|
|
1339
1392
|
@threshold.setter
|
|
1340
|
-
def threshold(self, value: pulumi.Input[float]):
|
|
1393
|
+
def threshold(self, value: pulumi.Input[_builtins.float]):
|
|
1341
1394
|
pulumi.set(self, "threshold", value)
|
|
1342
1395
|
|
|
1343
|
-
@property
|
|
1396
|
+
@_builtins.property
|
|
1344
1397
|
@pulumi.getter
|
|
1345
|
-
def unit(self) -> pulumi.Input[str]:
|
|
1398
|
+
def unit(self) -> pulumi.Input[_builtins.str]:
|
|
1346
1399
|
return pulumi.get(self, "unit")
|
|
1347
1400
|
|
|
1348
1401
|
@unit.setter
|
|
1349
|
-
def unit(self, value: pulumi.Input[str]):
|
|
1402
|
+
def unit(self, value: pulumi.Input[_builtins.str]):
|
|
1350
1403
|
pulumi.set(self, "unit", value)
|
|
1351
1404
|
|
|
1352
|
-
@property
|
|
1405
|
+
@_builtins.property
|
|
1353
1406
|
@pulumi.getter(name="actionType")
|
|
1354
|
-
def action_type(self) -> Optional[pulumi.Input[str]]:
|
|
1407
|
+
def action_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1355
1408
|
return pulumi.get(self, "action_type")
|
|
1356
1409
|
|
|
1357
1410
|
@action_type.setter
|
|
1358
|
-
def action_type(self, value: Optional[pulumi.Input[str]]):
|
|
1411
|
+
def action_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1359
1412
|
pulumi.set(self, "action_type", value)
|
|
1360
1413
|
|
|
1361
|
-
@property
|
|
1414
|
+
@_builtins.property
|
|
1362
1415
|
@pulumi.getter
|
|
1363
|
-
def adjustment(self) -> Optional[pulumi.Input[int]]:
|
|
1416
|
+
def adjustment(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1364
1417
|
return pulumi.get(self, "adjustment")
|
|
1365
1418
|
|
|
1366
1419
|
@adjustment.setter
|
|
1367
|
-
def adjustment(self, value: Optional[pulumi.Input[int]]):
|
|
1420
|
+
def adjustment(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1368
1421
|
pulumi.set(self, "adjustment", value)
|
|
1369
1422
|
|
|
1370
|
-
@property
|
|
1423
|
+
@_builtins.property
|
|
1371
1424
|
@pulumi.getter
|
|
1372
|
-
def cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
1425
|
+
def cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1373
1426
|
return pulumi.get(self, "cooldown")
|
|
1374
1427
|
|
|
1375
1428
|
@cooldown.setter
|
|
1376
|
-
def cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
1429
|
+
def cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1377
1430
|
pulumi.set(self, "cooldown", value)
|
|
1378
1431
|
|
|
1379
|
-
@property
|
|
1432
|
+
@_builtins.property
|
|
1380
1433
|
@pulumi.getter
|
|
1381
1434
|
def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]]:
|
|
1382
1435
|
return pulumi.get(self, "dimensions")
|
|
@@ -1385,129 +1438,129 @@ class ElastigroupScalingUpPolicyArgs:
|
|
|
1385
1438
|
def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyDimensionArgs']]]]):
|
|
1386
1439
|
pulumi.set(self, "dimensions", value)
|
|
1387
1440
|
|
|
1388
|
-
@property
|
|
1441
|
+
@_builtins.property
|
|
1389
1442
|
@pulumi.getter(name="evaluationPeriods")
|
|
1390
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
1443
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1391
1444
|
"""
|
|
1392
1445
|
Amount of cooldown evaluation periods for scale down.
|
|
1393
1446
|
"""
|
|
1394
1447
|
return pulumi.get(self, "evaluation_periods")
|
|
1395
1448
|
|
|
1396
1449
|
@evaluation_periods.setter
|
|
1397
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
1450
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1398
1451
|
pulumi.set(self, "evaluation_periods", value)
|
|
1399
1452
|
|
|
1400
|
-
@property
|
|
1453
|
+
@_builtins.property
|
|
1401
1454
|
@pulumi.getter
|
|
1402
|
-
def operator(self) -> Optional[pulumi.Input[str]]:
|
|
1455
|
+
def operator(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1403
1456
|
return pulumi.get(self, "operator")
|
|
1404
1457
|
|
|
1405
1458
|
@operator.setter
|
|
1406
|
-
def operator(self, value: Optional[pulumi.Input[str]]):
|
|
1459
|
+
def operator(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1407
1460
|
pulumi.set(self, "operator", value)
|
|
1408
1461
|
|
|
1409
|
-
@property
|
|
1462
|
+
@_builtins.property
|
|
1410
1463
|
@pulumi.getter
|
|
1411
|
-
def period(self) -> Optional[pulumi.Input[int]]:
|
|
1464
|
+
def period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1412
1465
|
return pulumi.get(self, "period")
|
|
1413
1466
|
|
|
1414
1467
|
@period.setter
|
|
1415
|
-
def period(self, value: Optional[pulumi.Input[int]]):
|
|
1468
|
+
def period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1416
1469
|
pulumi.set(self, "period", value)
|
|
1417
1470
|
|
|
1418
|
-
@property
|
|
1471
|
+
@_builtins.property
|
|
1419
1472
|
@pulumi.getter
|
|
1420
|
-
def source(self) -> Optional[pulumi.Input[str]]:
|
|
1473
|
+
def source(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1421
1474
|
return pulumi.get(self, "source")
|
|
1422
1475
|
|
|
1423
1476
|
@source.setter
|
|
1424
|
-
def source(self, value: Optional[pulumi.Input[str]]):
|
|
1477
|
+
def source(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1425
1478
|
pulumi.set(self, "source", value)
|
|
1426
1479
|
|
|
1427
|
-
@property
|
|
1480
|
+
@_builtins.property
|
|
1428
1481
|
@pulumi.getter
|
|
1429
|
-
def statistic(self) -> Optional[pulumi.Input[str]]:
|
|
1482
|
+
def statistic(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1430
1483
|
return pulumi.get(self, "statistic")
|
|
1431
1484
|
|
|
1432
1485
|
@statistic.setter
|
|
1433
|
-
def statistic(self, value: Optional[pulumi.Input[str]]):
|
|
1486
|
+
def statistic(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1434
1487
|
pulumi.set(self, "statistic", value)
|
|
1435
1488
|
|
|
1436
1489
|
|
|
1437
1490
|
if not MYPY:
|
|
1438
1491
|
class ElastigroupScalingUpPolicyDimensionArgsDict(TypedDict):
|
|
1439
|
-
name: pulumi.Input[str]
|
|
1440
|
-
value: NotRequired[pulumi.Input[str]]
|
|
1492
|
+
name: pulumi.Input[_builtins.str]
|
|
1493
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
1441
1494
|
elif False:
|
|
1442
1495
|
ElastigroupScalingUpPolicyDimensionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1443
1496
|
|
|
1444
1497
|
@pulumi.input_type
|
|
1445
1498
|
class ElastigroupScalingUpPolicyDimensionArgs:
|
|
1446
1499
|
def __init__(__self__, *,
|
|
1447
|
-
name: pulumi.Input[str],
|
|
1448
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
1500
|
+
name: pulumi.Input[_builtins.str],
|
|
1501
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1449
1502
|
pulumi.set(__self__, "name", name)
|
|
1450
1503
|
if value is not None:
|
|
1451
1504
|
pulumi.set(__self__, "value", value)
|
|
1452
1505
|
|
|
1453
|
-
@property
|
|
1506
|
+
@_builtins.property
|
|
1454
1507
|
@pulumi.getter
|
|
1455
|
-
def name(self) -> pulumi.Input[str]:
|
|
1508
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
1456
1509
|
return pulumi.get(self, "name")
|
|
1457
1510
|
|
|
1458
1511
|
@name.setter
|
|
1459
|
-
def name(self, value: pulumi.Input[str]):
|
|
1512
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
1460
1513
|
pulumi.set(self, "name", value)
|
|
1461
1514
|
|
|
1462
|
-
@property
|
|
1515
|
+
@_builtins.property
|
|
1463
1516
|
@pulumi.getter
|
|
1464
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
1517
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1465
1518
|
return pulumi.get(self, "value")
|
|
1466
1519
|
|
|
1467
1520
|
@value.setter
|
|
1468
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
1521
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1469
1522
|
pulumi.set(self, "value", value)
|
|
1470
1523
|
|
|
1471
1524
|
|
|
1472
1525
|
if not MYPY:
|
|
1473
1526
|
class ElastigroupShieldedInstanceConfigArgsDict(TypedDict):
|
|
1474
|
-
enable_integrity_monitoring: NotRequired[pulumi.Input[bool]]
|
|
1475
|
-
enable_secure_boot: NotRequired[pulumi.Input[bool]]
|
|
1527
|
+
enable_integrity_monitoring: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1528
|
+
enable_secure_boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1476
1529
|
elif False:
|
|
1477
1530
|
ElastigroupShieldedInstanceConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
1478
1531
|
|
|
1479
1532
|
@pulumi.input_type
|
|
1480
1533
|
class ElastigroupShieldedInstanceConfigArgs:
|
|
1481
1534
|
def __init__(__self__, *,
|
|
1482
|
-
enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
|
|
1483
|
-
enable_secure_boot: Optional[pulumi.Input[bool]] = None):
|
|
1535
|
+
enable_integrity_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1536
|
+
enable_secure_boot: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
1484
1537
|
if enable_integrity_monitoring is not None:
|
|
1485
1538
|
pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
|
|
1486
1539
|
if enable_secure_boot is not None:
|
|
1487
1540
|
pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
|
|
1488
1541
|
|
|
1489
|
-
@property
|
|
1542
|
+
@_builtins.property
|
|
1490
1543
|
@pulumi.getter(name="enableIntegrityMonitoring")
|
|
1491
|
-
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
1544
|
+
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1492
1545
|
return pulumi.get(self, "enable_integrity_monitoring")
|
|
1493
1546
|
|
|
1494
1547
|
@enable_integrity_monitoring.setter
|
|
1495
|
-
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
1548
|
+
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1496
1549
|
pulumi.set(self, "enable_integrity_monitoring", value)
|
|
1497
1550
|
|
|
1498
|
-
@property
|
|
1551
|
+
@_builtins.property
|
|
1499
1552
|
@pulumi.getter(name="enableSecureBoot")
|
|
1500
|
-
def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
|
|
1553
|
+
def enable_secure_boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1501
1554
|
return pulumi.get(self, "enable_secure_boot")
|
|
1502
1555
|
|
|
1503
1556
|
@enable_secure_boot.setter
|
|
1504
|
-
def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
|
|
1557
|
+
def enable_secure_boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1505
1558
|
pulumi.set(self, "enable_secure_boot", value)
|
|
1506
1559
|
|
|
1507
1560
|
|
|
1508
1561
|
if not MYPY:
|
|
1509
1562
|
class OceanImportAutoUpdateArgsDict(TypedDict):
|
|
1510
|
-
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
1563
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1511
1564
|
"""
|
|
1512
1565
|
Enable the Ocean Kubernetes AutoUpdate.
|
|
1513
1566
|
"""
|
|
@@ -1517,33 +1570,33 @@ elif False:
|
|
|
1517
1570
|
@pulumi.input_type
|
|
1518
1571
|
class OceanImportAutoUpdateArgs:
|
|
1519
1572
|
def __init__(__self__, *,
|
|
1520
|
-
is_enabled: Optional[pulumi.Input[bool]] = None):
|
|
1573
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
1521
1574
|
"""
|
|
1522
|
-
:param pulumi.Input[bool] is_enabled: Enable the Ocean Kubernetes AutoUpdate.
|
|
1575
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Enable the Ocean Kubernetes AutoUpdate.
|
|
1523
1576
|
"""
|
|
1524
1577
|
if is_enabled is not None:
|
|
1525
1578
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
1526
1579
|
|
|
1527
|
-
@property
|
|
1580
|
+
@_builtins.property
|
|
1528
1581
|
@pulumi.getter(name="isEnabled")
|
|
1529
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1582
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1530
1583
|
"""
|
|
1531
1584
|
Enable the Ocean Kubernetes AutoUpdate.
|
|
1532
1585
|
"""
|
|
1533
1586
|
return pulumi.get(self, "is_enabled")
|
|
1534
1587
|
|
|
1535
1588
|
@is_enabled.setter
|
|
1536
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1589
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1537
1590
|
pulumi.set(self, "is_enabled", value)
|
|
1538
1591
|
|
|
1539
1592
|
|
|
1540
1593
|
if not MYPY:
|
|
1541
1594
|
class OceanImportAutoscalerArgsDict(TypedDict):
|
|
1542
|
-
auto_headroom_percentage: NotRequired[pulumi.Input[int]]
|
|
1595
|
+
auto_headroom_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
1543
1596
|
"""
|
|
1544
1597
|
Optionally set the auto headroom percentage, set a number between 0-200 to control the headroom % from the cluster. Relevant when isAutoConfig=true.
|
|
1545
1598
|
"""
|
|
1546
|
-
cooldown: NotRequired[pulumi.Input[int]]
|
|
1599
|
+
cooldown: NotRequired[pulumi.Input[_builtins.int]]
|
|
1547
1600
|
"""
|
|
1548
1601
|
Cooldown period between scaling actions.
|
|
1549
1602
|
"""
|
|
@@ -1551,7 +1604,7 @@ if not MYPY:
|
|
|
1551
1604
|
"""
|
|
1552
1605
|
Auto Scaling scale down operations.
|
|
1553
1606
|
"""
|
|
1554
|
-
enable_automatic_and_manual_headroom: NotRequired[pulumi.Input[bool]]
|
|
1607
|
+
enable_automatic_and_manual_headroom: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1555
1608
|
"""
|
|
1556
1609
|
enables automatic and manual headroom to work in parallel. When set to false, automatic headroom overrides all other headroom definitions manually configured, whether they are at cluster or VNG level.
|
|
1557
1610
|
"""
|
|
@@ -1559,11 +1612,11 @@ if not MYPY:
|
|
|
1559
1612
|
"""
|
|
1560
1613
|
Spare resource capacity management enabling fast assignment of Pods without waiting for new resources to launch.
|
|
1561
1614
|
"""
|
|
1562
|
-
is_auto_config: NotRequired[pulumi.Input[bool]]
|
|
1615
|
+
is_auto_config: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1563
1616
|
"""
|
|
1564
1617
|
Automatically configure and optimize headroom resources.
|
|
1565
1618
|
"""
|
|
1566
|
-
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
1619
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1567
1620
|
"""
|
|
1568
1621
|
Enable the Ocean Kubernetes Autoscaler.
|
|
1569
1622
|
"""
|
|
@@ -1577,22 +1630,22 @@ elif False:
|
|
|
1577
1630
|
@pulumi.input_type
|
|
1578
1631
|
class OceanImportAutoscalerArgs:
|
|
1579
1632
|
def __init__(__self__, *,
|
|
1580
|
-
auto_headroom_percentage: Optional[pulumi.Input[int]] = None,
|
|
1581
|
-
cooldown: Optional[pulumi.Input[int]] = None,
|
|
1633
|
+
auto_headroom_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1634
|
+
cooldown: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1582
1635
|
down: Optional[pulumi.Input['OceanImportAutoscalerDownArgs']] = None,
|
|
1583
|
-
enable_automatic_and_manual_headroom: Optional[pulumi.Input[bool]] = None,
|
|
1636
|
+
enable_automatic_and_manual_headroom: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1584
1637
|
headroom: Optional[pulumi.Input['OceanImportAutoscalerHeadroomArgs']] = None,
|
|
1585
|
-
is_auto_config: Optional[pulumi.Input[bool]] = None,
|
|
1586
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1638
|
+
is_auto_config: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1639
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1587
1640
|
resource_limits: Optional[pulumi.Input['OceanImportAutoscalerResourceLimitsArgs']] = None):
|
|
1588
1641
|
"""
|
|
1589
|
-
:param pulumi.Input[int] auto_headroom_percentage: Optionally set the auto headroom percentage, set a number between 0-200 to control the headroom % from the cluster. Relevant when isAutoConfig=true.
|
|
1590
|
-
:param pulumi.Input[int] cooldown: Cooldown period between scaling actions.
|
|
1642
|
+
:param pulumi.Input[_builtins.int] auto_headroom_percentage: Optionally set the auto headroom percentage, set a number between 0-200 to control the headroom % from the cluster. Relevant when isAutoConfig=true.
|
|
1643
|
+
:param pulumi.Input[_builtins.int] cooldown: Cooldown period between scaling actions.
|
|
1591
1644
|
:param pulumi.Input['OceanImportAutoscalerDownArgs'] down: Auto Scaling scale down operations.
|
|
1592
|
-
:param pulumi.Input[bool] enable_automatic_and_manual_headroom: enables automatic and manual headroom to work in parallel. When set to false, automatic headroom overrides all other headroom definitions manually configured, whether they are at cluster or VNG level.
|
|
1645
|
+
:param pulumi.Input[_builtins.bool] enable_automatic_and_manual_headroom: enables automatic and manual headroom to work in parallel. When set to false, automatic headroom overrides all other headroom definitions manually configured, whether they are at cluster or VNG level.
|
|
1593
1646
|
:param pulumi.Input['OceanImportAutoscalerHeadroomArgs'] headroom: Spare resource capacity management enabling fast assignment of Pods without waiting for new resources to launch.
|
|
1594
|
-
:param pulumi.Input[bool] is_auto_config: Automatically configure and optimize headroom resources.
|
|
1595
|
-
:param pulumi.Input[bool] is_enabled: Enable the Ocean Kubernetes Autoscaler.
|
|
1647
|
+
:param pulumi.Input[_builtins.bool] is_auto_config: Automatically configure and optimize headroom resources.
|
|
1648
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Enable the Ocean Kubernetes Autoscaler.
|
|
1596
1649
|
:param pulumi.Input['OceanImportAutoscalerResourceLimitsArgs'] resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
|
|
1597
1650
|
"""
|
|
1598
1651
|
if auto_headroom_percentage is not None:
|
|
@@ -1612,31 +1665,31 @@ class OceanImportAutoscalerArgs:
|
|
|
1612
1665
|
if resource_limits is not None:
|
|
1613
1666
|
pulumi.set(__self__, "resource_limits", resource_limits)
|
|
1614
1667
|
|
|
1615
|
-
@property
|
|
1668
|
+
@_builtins.property
|
|
1616
1669
|
@pulumi.getter(name="autoHeadroomPercentage")
|
|
1617
|
-
def auto_headroom_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1670
|
+
def auto_headroom_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1618
1671
|
"""
|
|
1619
1672
|
Optionally set the auto headroom percentage, set a number between 0-200 to control the headroom % from the cluster. Relevant when isAutoConfig=true.
|
|
1620
1673
|
"""
|
|
1621
1674
|
return pulumi.get(self, "auto_headroom_percentage")
|
|
1622
1675
|
|
|
1623
1676
|
@auto_headroom_percentage.setter
|
|
1624
|
-
def auto_headroom_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1677
|
+
def auto_headroom_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1625
1678
|
pulumi.set(self, "auto_headroom_percentage", value)
|
|
1626
1679
|
|
|
1627
|
-
@property
|
|
1680
|
+
@_builtins.property
|
|
1628
1681
|
@pulumi.getter
|
|
1629
|
-
def cooldown(self) -> Optional[pulumi.Input[int]]:
|
|
1682
|
+
def cooldown(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1630
1683
|
"""
|
|
1631
1684
|
Cooldown period between scaling actions.
|
|
1632
1685
|
"""
|
|
1633
1686
|
return pulumi.get(self, "cooldown")
|
|
1634
1687
|
|
|
1635
1688
|
@cooldown.setter
|
|
1636
|
-
def cooldown(self, value: Optional[pulumi.Input[int]]):
|
|
1689
|
+
def cooldown(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1637
1690
|
pulumi.set(self, "cooldown", value)
|
|
1638
1691
|
|
|
1639
|
-
@property
|
|
1692
|
+
@_builtins.property
|
|
1640
1693
|
@pulumi.getter
|
|
1641
1694
|
def down(self) -> Optional[pulumi.Input['OceanImportAutoscalerDownArgs']]:
|
|
1642
1695
|
"""
|
|
@@ -1648,19 +1701,19 @@ class OceanImportAutoscalerArgs:
|
|
|
1648
1701
|
def down(self, value: Optional[pulumi.Input['OceanImportAutoscalerDownArgs']]):
|
|
1649
1702
|
pulumi.set(self, "down", value)
|
|
1650
1703
|
|
|
1651
|
-
@property
|
|
1704
|
+
@_builtins.property
|
|
1652
1705
|
@pulumi.getter(name="enableAutomaticAndManualHeadroom")
|
|
1653
|
-
def enable_automatic_and_manual_headroom(self) -> Optional[pulumi.Input[bool]]:
|
|
1706
|
+
def enable_automatic_and_manual_headroom(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1654
1707
|
"""
|
|
1655
1708
|
enables automatic and manual headroom to work in parallel. When set to false, automatic headroom overrides all other headroom definitions manually configured, whether they are at cluster or VNG level.
|
|
1656
1709
|
"""
|
|
1657
1710
|
return pulumi.get(self, "enable_automatic_and_manual_headroom")
|
|
1658
1711
|
|
|
1659
1712
|
@enable_automatic_and_manual_headroom.setter
|
|
1660
|
-
def enable_automatic_and_manual_headroom(self, value: Optional[pulumi.Input[bool]]):
|
|
1713
|
+
def enable_automatic_and_manual_headroom(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1661
1714
|
pulumi.set(self, "enable_automatic_and_manual_headroom", value)
|
|
1662
1715
|
|
|
1663
|
-
@property
|
|
1716
|
+
@_builtins.property
|
|
1664
1717
|
@pulumi.getter
|
|
1665
1718
|
def headroom(self) -> Optional[pulumi.Input['OceanImportAutoscalerHeadroomArgs']]:
|
|
1666
1719
|
"""
|
|
@@ -1672,31 +1725,31 @@ class OceanImportAutoscalerArgs:
|
|
|
1672
1725
|
def headroom(self, value: Optional[pulumi.Input['OceanImportAutoscalerHeadroomArgs']]):
|
|
1673
1726
|
pulumi.set(self, "headroom", value)
|
|
1674
1727
|
|
|
1675
|
-
@property
|
|
1728
|
+
@_builtins.property
|
|
1676
1729
|
@pulumi.getter(name="isAutoConfig")
|
|
1677
|
-
def is_auto_config(self) -> Optional[pulumi.Input[bool]]:
|
|
1730
|
+
def is_auto_config(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1678
1731
|
"""
|
|
1679
1732
|
Automatically configure and optimize headroom resources.
|
|
1680
1733
|
"""
|
|
1681
1734
|
return pulumi.get(self, "is_auto_config")
|
|
1682
1735
|
|
|
1683
1736
|
@is_auto_config.setter
|
|
1684
|
-
def is_auto_config(self, value: Optional[pulumi.Input[bool]]):
|
|
1737
|
+
def is_auto_config(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1685
1738
|
pulumi.set(self, "is_auto_config", value)
|
|
1686
1739
|
|
|
1687
|
-
@property
|
|
1740
|
+
@_builtins.property
|
|
1688
1741
|
@pulumi.getter(name="isEnabled")
|
|
1689
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1742
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1690
1743
|
"""
|
|
1691
1744
|
Enable the Ocean Kubernetes Autoscaler.
|
|
1692
1745
|
"""
|
|
1693
1746
|
return pulumi.get(self, "is_enabled")
|
|
1694
1747
|
|
|
1695
1748
|
@is_enabled.setter
|
|
1696
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1749
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1697
1750
|
pulumi.set(self, "is_enabled", value)
|
|
1698
1751
|
|
|
1699
|
-
@property
|
|
1752
|
+
@_builtins.property
|
|
1700
1753
|
@pulumi.getter(name="resourceLimits")
|
|
1701
1754
|
def resource_limits(self) -> Optional[pulumi.Input['OceanImportAutoscalerResourceLimitsArgs']]:
|
|
1702
1755
|
"""
|
|
@@ -1711,15 +1764,15 @@ class OceanImportAutoscalerArgs:
|
|
|
1711
1764
|
|
|
1712
1765
|
if not MYPY:
|
|
1713
1766
|
class OceanImportAutoscalerDownArgsDict(TypedDict):
|
|
1714
|
-
evaluation_periods: NotRequired[pulumi.Input[int]]
|
|
1767
|
+
evaluation_periods: NotRequired[pulumi.Input[_builtins.int]]
|
|
1715
1768
|
"""
|
|
1716
1769
|
The number of evaluation periods that should accumulate before a scale down action takes place.
|
|
1717
1770
|
"""
|
|
1718
|
-
is_aggressive_scale_down_enabled: NotRequired[pulumi.Input[bool]]
|
|
1771
|
+
is_aggressive_scale_down_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1719
1772
|
"""
|
|
1720
1773
|
When set to 'true', the Aggressive Scale Down feature is enabled.
|
|
1721
1774
|
"""
|
|
1722
|
-
max_scale_down_percentage: NotRequired[pulumi.Input[float]]
|
|
1775
|
+
max_scale_down_percentage: NotRequired[pulumi.Input[_builtins.float]]
|
|
1723
1776
|
"""
|
|
1724
1777
|
Would represent the maximum % to scale-down. Number between 1-100.
|
|
1725
1778
|
"""
|
|
@@ -1729,13 +1782,13 @@ elif False:
|
|
|
1729
1782
|
@pulumi.input_type
|
|
1730
1783
|
class OceanImportAutoscalerDownArgs:
|
|
1731
1784
|
def __init__(__self__, *,
|
|
1732
|
-
evaluation_periods: Optional[pulumi.Input[int]] = None,
|
|
1733
|
-
is_aggressive_scale_down_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1734
|
-
max_scale_down_percentage: Optional[pulumi.Input[float]] = None):
|
|
1785
|
+
evaluation_periods: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1786
|
+
is_aggressive_scale_down_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1787
|
+
max_scale_down_percentage: Optional[pulumi.Input[_builtins.float]] = None):
|
|
1735
1788
|
"""
|
|
1736
|
-
:param pulumi.Input[int] evaluation_periods: The number of evaluation periods that should accumulate before a scale down action takes place.
|
|
1737
|
-
:param pulumi.Input[bool] is_aggressive_scale_down_enabled: When set to 'true', the Aggressive Scale Down feature is enabled.
|
|
1738
|
-
:param pulumi.Input[float] max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
|
|
1789
|
+
:param pulumi.Input[_builtins.int] evaluation_periods: The number of evaluation periods that should accumulate before a scale down action takes place.
|
|
1790
|
+
:param pulumi.Input[_builtins.bool] is_aggressive_scale_down_enabled: When set to 'true', the Aggressive Scale Down feature is enabled.
|
|
1791
|
+
:param pulumi.Input[_builtins.float] max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
|
|
1739
1792
|
"""
|
|
1740
1793
|
if evaluation_periods is not None:
|
|
1741
1794
|
pulumi.set(__self__, "evaluation_periods", evaluation_periods)
|
|
@@ -1744,58 +1797,58 @@ class OceanImportAutoscalerDownArgs:
|
|
|
1744
1797
|
if max_scale_down_percentage is not None:
|
|
1745
1798
|
pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
|
|
1746
1799
|
|
|
1747
|
-
@property
|
|
1800
|
+
@_builtins.property
|
|
1748
1801
|
@pulumi.getter(name="evaluationPeriods")
|
|
1749
|
-
def evaluation_periods(self) -> Optional[pulumi.Input[int]]:
|
|
1802
|
+
def evaluation_periods(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1750
1803
|
"""
|
|
1751
1804
|
The number of evaluation periods that should accumulate before a scale down action takes place.
|
|
1752
1805
|
"""
|
|
1753
1806
|
return pulumi.get(self, "evaluation_periods")
|
|
1754
1807
|
|
|
1755
1808
|
@evaluation_periods.setter
|
|
1756
|
-
def evaluation_periods(self, value: Optional[pulumi.Input[int]]):
|
|
1809
|
+
def evaluation_periods(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1757
1810
|
pulumi.set(self, "evaluation_periods", value)
|
|
1758
1811
|
|
|
1759
|
-
@property
|
|
1812
|
+
@_builtins.property
|
|
1760
1813
|
@pulumi.getter(name="isAggressiveScaleDownEnabled")
|
|
1761
|
-
def is_aggressive_scale_down_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1814
|
+
def is_aggressive_scale_down_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1762
1815
|
"""
|
|
1763
1816
|
When set to 'true', the Aggressive Scale Down feature is enabled.
|
|
1764
1817
|
"""
|
|
1765
1818
|
return pulumi.get(self, "is_aggressive_scale_down_enabled")
|
|
1766
1819
|
|
|
1767
1820
|
@is_aggressive_scale_down_enabled.setter
|
|
1768
|
-
def is_aggressive_scale_down_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1821
|
+
def is_aggressive_scale_down_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1769
1822
|
pulumi.set(self, "is_aggressive_scale_down_enabled", value)
|
|
1770
1823
|
|
|
1771
|
-
@property
|
|
1824
|
+
@_builtins.property
|
|
1772
1825
|
@pulumi.getter(name="maxScaleDownPercentage")
|
|
1773
|
-
def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:
|
|
1826
|
+
def max_scale_down_percentage(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1774
1827
|
"""
|
|
1775
1828
|
Would represent the maximum % to scale-down. Number between 1-100.
|
|
1776
1829
|
"""
|
|
1777
1830
|
return pulumi.get(self, "max_scale_down_percentage")
|
|
1778
1831
|
|
|
1779
1832
|
@max_scale_down_percentage.setter
|
|
1780
|
-
def max_scale_down_percentage(self, value: Optional[pulumi.Input[float]]):
|
|
1833
|
+
def max_scale_down_percentage(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1781
1834
|
pulumi.set(self, "max_scale_down_percentage", value)
|
|
1782
1835
|
|
|
1783
1836
|
|
|
1784
1837
|
if not MYPY:
|
|
1785
1838
|
class OceanImportAutoscalerHeadroomArgsDict(TypedDict):
|
|
1786
|
-
cpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
1839
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1787
1840
|
"""
|
|
1788
1841
|
Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1789
1842
|
"""
|
|
1790
|
-
gpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
1843
|
+
gpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1791
1844
|
"""
|
|
1792
1845
|
How much GPU allocate for headroom unit.
|
|
1793
1846
|
"""
|
|
1794
|
-
memory_per_unit: NotRequired[pulumi.Input[int]]
|
|
1847
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
1795
1848
|
"""
|
|
1796
1849
|
Optionally configure the amount of memory (MiB) to allocate the headroom.
|
|
1797
1850
|
"""
|
|
1798
|
-
num_of_units: NotRequired[pulumi.Input[int]]
|
|
1851
|
+
num_of_units: NotRequired[pulumi.Input[_builtins.int]]
|
|
1799
1852
|
"""
|
|
1800
1853
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1801
1854
|
"""
|
|
@@ -1805,15 +1858,15 @@ elif False:
|
|
|
1805
1858
|
@pulumi.input_type
|
|
1806
1859
|
class OceanImportAutoscalerHeadroomArgs:
|
|
1807
1860
|
def __init__(__self__, *,
|
|
1808
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1809
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1810
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1811
|
-
num_of_units: Optional[pulumi.Input[int]] = None):
|
|
1861
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1862
|
+
gpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1863
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1864
|
+
num_of_units: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1812
1865
|
"""
|
|
1813
|
-
:param pulumi.Input[int] cpu_per_unit: Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1814
|
-
:param pulumi.Input[int] gpu_per_unit: How much GPU allocate for headroom unit.
|
|
1815
|
-
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate the headroom.
|
|
1816
|
-
:param pulumi.Input[int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1866
|
+
:param pulumi.Input[_builtins.int] cpu_per_unit: Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1867
|
+
:param pulumi.Input[_builtins.int] gpu_per_unit: How much GPU allocate for headroom unit.
|
|
1868
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate the headroom.
|
|
1869
|
+
:param pulumi.Input[_builtins.int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1817
1870
|
"""
|
|
1818
1871
|
if cpu_per_unit is not None:
|
|
1819
1872
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -1824,62 +1877,62 @@ class OceanImportAutoscalerHeadroomArgs:
|
|
|
1824
1877
|
if num_of_units is not None:
|
|
1825
1878
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
1826
1879
|
|
|
1827
|
-
@property
|
|
1880
|
+
@_builtins.property
|
|
1828
1881
|
@pulumi.getter(name="cpuPerUnit")
|
|
1829
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
1882
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1830
1883
|
"""
|
|
1831
1884
|
Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1832
1885
|
"""
|
|
1833
1886
|
return pulumi.get(self, "cpu_per_unit")
|
|
1834
1887
|
|
|
1835
1888
|
@cpu_per_unit.setter
|
|
1836
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
1889
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1837
1890
|
pulumi.set(self, "cpu_per_unit", value)
|
|
1838
1891
|
|
|
1839
|
-
@property
|
|
1892
|
+
@_builtins.property
|
|
1840
1893
|
@pulumi.getter(name="gpuPerUnit")
|
|
1841
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
1894
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1842
1895
|
"""
|
|
1843
1896
|
How much GPU allocate for headroom unit.
|
|
1844
1897
|
"""
|
|
1845
1898
|
return pulumi.get(self, "gpu_per_unit")
|
|
1846
1899
|
|
|
1847
1900
|
@gpu_per_unit.setter
|
|
1848
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
1901
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1849
1902
|
pulumi.set(self, "gpu_per_unit", value)
|
|
1850
1903
|
|
|
1851
|
-
@property
|
|
1904
|
+
@_builtins.property
|
|
1852
1905
|
@pulumi.getter(name="memoryPerUnit")
|
|
1853
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
1906
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1854
1907
|
"""
|
|
1855
1908
|
Optionally configure the amount of memory (MiB) to allocate the headroom.
|
|
1856
1909
|
"""
|
|
1857
1910
|
return pulumi.get(self, "memory_per_unit")
|
|
1858
1911
|
|
|
1859
1912
|
@memory_per_unit.setter
|
|
1860
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
1913
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1861
1914
|
pulumi.set(self, "memory_per_unit", value)
|
|
1862
1915
|
|
|
1863
|
-
@property
|
|
1916
|
+
@_builtins.property
|
|
1864
1917
|
@pulumi.getter(name="numOfUnits")
|
|
1865
|
-
def num_of_units(self) -> Optional[pulumi.Input[int]]:
|
|
1918
|
+
def num_of_units(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1866
1919
|
"""
|
|
1867
1920
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1868
1921
|
"""
|
|
1869
1922
|
return pulumi.get(self, "num_of_units")
|
|
1870
1923
|
|
|
1871
1924
|
@num_of_units.setter
|
|
1872
|
-
def num_of_units(self, value: Optional[pulumi.Input[int]]):
|
|
1925
|
+
def num_of_units(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1873
1926
|
pulumi.set(self, "num_of_units", value)
|
|
1874
1927
|
|
|
1875
1928
|
|
|
1876
1929
|
if not MYPY:
|
|
1877
1930
|
class OceanImportAutoscalerResourceLimitsArgsDict(TypedDict):
|
|
1878
|
-
max_memory_gib: NotRequired[pulumi.Input[int]]
|
|
1931
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.int]]
|
|
1879
1932
|
"""
|
|
1880
1933
|
The maximum memory in GiB units that can be allocated to the cluster.
|
|
1881
1934
|
"""
|
|
1882
|
-
max_vcpu: NotRequired[pulumi.Input[int]]
|
|
1935
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
1883
1936
|
"""
|
|
1884
1937
|
The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
1885
1938
|
"""
|
|
@@ -1889,54 +1942,54 @@ elif False:
|
|
|
1889
1942
|
@pulumi.input_type
|
|
1890
1943
|
class OceanImportAutoscalerResourceLimitsArgs:
|
|
1891
1944
|
def __init__(__self__, *,
|
|
1892
|
-
max_memory_gib: Optional[pulumi.Input[int]] = None,
|
|
1893
|
-
max_vcpu: Optional[pulumi.Input[int]] = None):
|
|
1945
|
+
max_memory_gib: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1946
|
+
max_vcpu: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1894
1947
|
"""
|
|
1895
|
-
:param pulumi.Input[int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
|
|
1896
|
-
:param pulumi.Input[int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
1948
|
+
:param pulumi.Input[_builtins.int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
|
|
1949
|
+
:param pulumi.Input[_builtins.int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
1897
1950
|
"""
|
|
1898
1951
|
if max_memory_gib is not None:
|
|
1899
1952
|
pulumi.set(__self__, "max_memory_gib", max_memory_gib)
|
|
1900
1953
|
if max_vcpu is not None:
|
|
1901
1954
|
pulumi.set(__self__, "max_vcpu", max_vcpu)
|
|
1902
1955
|
|
|
1903
|
-
@property
|
|
1956
|
+
@_builtins.property
|
|
1904
1957
|
@pulumi.getter(name="maxMemoryGib")
|
|
1905
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[int]]:
|
|
1958
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1906
1959
|
"""
|
|
1907
1960
|
The maximum memory in GiB units that can be allocated to the cluster.
|
|
1908
1961
|
"""
|
|
1909
1962
|
return pulumi.get(self, "max_memory_gib")
|
|
1910
1963
|
|
|
1911
1964
|
@max_memory_gib.setter
|
|
1912
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[int]]):
|
|
1965
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1913
1966
|
pulumi.set(self, "max_memory_gib", value)
|
|
1914
1967
|
|
|
1915
|
-
@property
|
|
1968
|
+
@_builtins.property
|
|
1916
1969
|
@pulumi.getter(name="maxVcpu")
|
|
1917
|
-
def max_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
1970
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1918
1971
|
"""
|
|
1919
1972
|
The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
1920
1973
|
"""
|
|
1921
1974
|
return pulumi.get(self, "max_vcpu")
|
|
1922
1975
|
|
|
1923
1976
|
@max_vcpu.setter
|
|
1924
|
-
def max_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
1977
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1925
1978
|
pulumi.set(self, "max_vcpu", value)
|
|
1926
1979
|
|
|
1927
1980
|
|
|
1928
1981
|
if not MYPY:
|
|
1929
1982
|
class OceanImportBackendServiceArgsDict(TypedDict):
|
|
1930
|
-
service_name: pulumi.Input[str]
|
|
1983
|
+
service_name: pulumi.Input[_builtins.str]
|
|
1931
1984
|
"""
|
|
1932
1985
|
The name of the backend service.
|
|
1933
1986
|
"""
|
|
1934
|
-
location_type: NotRequired[pulumi.Input[str]]
|
|
1987
|
+
location_type: NotRequired[pulumi.Input[_builtins.str]]
|
|
1935
1988
|
"""
|
|
1936
1989
|
Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
1937
1990
|
"""
|
|
1938
1991
|
named_ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceNamedPortArgsDict']]]]
|
|
1939
|
-
scheme: NotRequired[pulumi.Input[str]]
|
|
1992
|
+
scheme: NotRequired[pulumi.Input[_builtins.str]]
|
|
1940
1993
|
"""
|
|
1941
1994
|
Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
1942
1995
|
"""
|
|
@@ -1946,14 +1999,14 @@ elif False:
|
|
|
1946
1999
|
@pulumi.input_type
|
|
1947
2000
|
class OceanImportBackendServiceArgs:
|
|
1948
2001
|
def __init__(__self__, *,
|
|
1949
|
-
service_name: pulumi.Input[str],
|
|
1950
|
-
location_type: Optional[pulumi.Input[str]] = None,
|
|
2002
|
+
service_name: pulumi.Input[_builtins.str],
|
|
2003
|
+
location_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1951
2004
|
named_ports: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceNamedPortArgs']]]] = None,
|
|
1952
|
-
scheme: Optional[pulumi.Input[str]] = None):
|
|
2005
|
+
scheme: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1953
2006
|
"""
|
|
1954
|
-
:param pulumi.Input[str] service_name: The name of the backend service.
|
|
1955
|
-
:param pulumi.Input[str] location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
1956
|
-
:param pulumi.Input[str] scheme: Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
2007
|
+
:param pulumi.Input[_builtins.str] service_name: The name of the backend service.
|
|
2008
|
+
:param pulumi.Input[_builtins.str] location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
2009
|
+
:param pulumi.Input[_builtins.str] scheme: Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
1957
2010
|
"""
|
|
1958
2011
|
pulumi.set(__self__, "service_name", service_name)
|
|
1959
2012
|
if location_type is not None:
|
|
@@ -1963,31 +2016,31 @@ class OceanImportBackendServiceArgs:
|
|
|
1963
2016
|
if scheme is not None:
|
|
1964
2017
|
pulumi.set(__self__, "scheme", scheme)
|
|
1965
2018
|
|
|
1966
|
-
@property
|
|
2019
|
+
@_builtins.property
|
|
1967
2020
|
@pulumi.getter(name="serviceName")
|
|
1968
|
-
def service_name(self) -> pulumi.Input[str]:
|
|
2021
|
+
def service_name(self) -> pulumi.Input[_builtins.str]:
|
|
1969
2022
|
"""
|
|
1970
2023
|
The name of the backend service.
|
|
1971
2024
|
"""
|
|
1972
2025
|
return pulumi.get(self, "service_name")
|
|
1973
2026
|
|
|
1974
2027
|
@service_name.setter
|
|
1975
|
-
def service_name(self, value: pulumi.Input[str]):
|
|
2028
|
+
def service_name(self, value: pulumi.Input[_builtins.str]):
|
|
1976
2029
|
pulumi.set(self, "service_name", value)
|
|
1977
2030
|
|
|
1978
|
-
@property
|
|
2031
|
+
@_builtins.property
|
|
1979
2032
|
@pulumi.getter(name="locationType")
|
|
1980
|
-
def location_type(self) -> Optional[pulumi.Input[str]]:
|
|
2033
|
+
def location_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1981
2034
|
"""
|
|
1982
2035
|
Sets which location the backend services will be active. Valid values: `regional`, `global`.
|
|
1983
2036
|
"""
|
|
1984
2037
|
return pulumi.get(self, "location_type")
|
|
1985
2038
|
|
|
1986
2039
|
@location_type.setter
|
|
1987
|
-
def location_type(self, value: Optional[pulumi.Input[str]]):
|
|
2040
|
+
def location_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1988
2041
|
pulumi.set(self, "location_type", value)
|
|
1989
2042
|
|
|
1990
|
-
@property
|
|
2043
|
+
@_builtins.property
|
|
1991
2044
|
@pulumi.getter(name="namedPorts")
|
|
1992
2045
|
def named_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceNamedPortArgs']]]]:
|
|
1993
2046
|
return pulumi.get(self, "named_ports")
|
|
@@ -1996,23 +2049,23 @@ class OceanImportBackendServiceArgs:
|
|
|
1996
2049
|
def named_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportBackendServiceNamedPortArgs']]]]):
|
|
1997
2050
|
pulumi.set(self, "named_ports", value)
|
|
1998
2051
|
|
|
1999
|
-
@property
|
|
2052
|
+
@_builtins.property
|
|
2000
2053
|
@pulumi.getter
|
|
2001
|
-
def scheme(self) -> Optional[pulumi.Input[str]]:
|
|
2054
|
+
def scheme(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2002
2055
|
"""
|
|
2003
2056
|
Use when `location_type` is `regional`. Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
|
|
2004
2057
|
"""
|
|
2005
2058
|
return pulumi.get(self, "scheme")
|
|
2006
2059
|
|
|
2007
2060
|
@scheme.setter
|
|
2008
|
-
def scheme(self, value: Optional[pulumi.Input[str]]):
|
|
2061
|
+
def scheme(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2009
2062
|
pulumi.set(self, "scheme", value)
|
|
2010
2063
|
|
|
2011
2064
|
|
|
2012
2065
|
if not MYPY:
|
|
2013
2066
|
class OceanImportBackendServiceNamedPortArgsDict(TypedDict):
|
|
2014
|
-
name: pulumi.Input[str]
|
|
2015
|
-
ports: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
2067
|
+
name: pulumi.Input[_builtins.str]
|
|
2068
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
2016
2069
|
"""
|
|
2017
2070
|
A list of ports.
|
|
2018
2071
|
"""
|
|
@@ -2022,59 +2075,59 @@ elif False:
|
|
|
2022
2075
|
@pulumi.input_type
|
|
2023
2076
|
class OceanImportBackendServiceNamedPortArgs:
|
|
2024
2077
|
def __init__(__self__, *,
|
|
2025
|
-
name: pulumi.Input[str],
|
|
2026
|
-
ports: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
2078
|
+
name: pulumi.Input[_builtins.str],
|
|
2079
|
+
ports: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
2027
2080
|
"""
|
|
2028
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] ports: A list of ports.
|
|
2081
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ports: A list of ports.
|
|
2029
2082
|
"""
|
|
2030
2083
|
pulumi.set(__self__, "name", name)
|
|
2031
2084
|
pulumi.set(__self__, "ports", ports)
|
|
2032
2085
|
|
|
2033
|
-
@property
|
|
2086
|
+
@_builtins.property
|
|
2034
2087
|
@pulumi.getter
|
|
2035
|
-
def name(self) -> pulumi.Input[str]:
|
|
2088
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
2036
2089
|
return pulumi.get(self, "name")
|
|
2037
2090
|
|
|
2038
2091
|
@name.setter
|
|
2039
|
-
def name(self, value: pulumi.Input[str]):
|
|
2092
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
2040
2093
|
pulumi.set(self, "name", value)
|
|
2041
2094
|
|
|
2042
|
-
@property
|
|
2095
|
+
@_builtins.property
|
|
2043
2096
|
@pulumi.getter
|
|
2044
|
-
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
2097
|
+
def ports(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
2045
2098
|
"""
|
|
2046
2099
|
A list of ports.
|
|
2047
2100
|
"""
|
|
2048
2101
|
return pulumi.get(self, "ports")
|
|
2049
2102
|
|
|
2050
2103
|
@ports.setter
|
|
2051
|
-
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
2104
|
+
def ports(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
2052
2105
|
pulumi.set(self, "ports", value)
|
|
2053
2106
|
|
|
2054
2107
|
|
|
2055
2108
|
if not MYPY:
|
|
2056
2109
|
class OceanImportFiltersArgsDict(TypedDict):
|
|
2057
|
-
exclude_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2110
|
+
exclude_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2058
2111
|
"""
|
|
2059
2112
|
Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
2060
2113
|
"""
|
|
2061
|
-
include_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2114
|
+
include_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2062
2115
|
"""
|
|
2063
2116
|
Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
2064
2117
|
"""
|
|
2065
|
-
max_memory_gib: NotRequired[pulumi.Input[float]]
|
|
2118
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
2066
2119
|
"""
|
|
2067
2120
|
Maximum amount of Memory (GiB).
|
|
2068
2121
|
"""
|
|
2069
|
-
max_vcpu: NotRequired[pulumi.Input[int]]
|
|
2122
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
2070
2123
|
"""
|
|
2071
2124
|
Maximum number of vcpus available.
|
|
2072
2125
|
"""
|
|
2073
|
-
min_memory_gib: NotRequired[pulumi.Input[float]]
|
|
2126
|
+
min_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
2074
2127
|
"""
|
|
2075
2128
|
Minimum amount of Memory (GiB).
|
|
2076
2129
|
"""
|
|
2077
|
-
min_vcpu: NotRequired[pulumi.Input[int]]
|
|
2130
|
+
min_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
2078
2131
|
"""
|
|
2079
2132
|
Minimum number of vcpus available.
|
|
2080
2133
|
"""
|
|
@@ -2084,19 +2137,19 @@ elif False:
|
|
|
2084
2137
|
@pulumi.input_type
|
|
2085
2138
|
class OceanImportFiltersArgs:
|
|
2086
2139
|
def __init__(__self__, *,
|
|
2087
|
-
exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2088
|
-
include_families: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2089
|
-
max_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
2090
|
-
max_vcpu: Optional[pulumi.Input[int]] = None,
|
|
2091
|
-
min_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
2092
|
-
min_vcpu: Optional[pulumi.Input[int]] = None):
|
|
2093
|
-
"""
|
|
2094
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_families: Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
2095
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] include_families: Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
2096
|
-
:param pulumi.Input[float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
2097
|
-
:param pulumi.Input[int] max_vcpu: Maximum number of vcpus available.
|
|
2098
|
-
:param pulumi.Input[float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
2099
|
-
:param pulumi.Input[int] min_vcpu: Minimum number of vcpus available.
|
|
2140
|
+
exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2141
|
+
include_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2142
|
+
max_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
2143
|
+
max_vcpu: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2144
|
+
min_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
2145
|
+
min_vcpu: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2146
|
+
"""
|
|
2147
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_families: Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
2148
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] include_families: Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
2149
|
+
:param pulumi.Input[_builtins.float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
2150
|
+
:param pulumi.Input[_builtins.int] max_vcpu: Maximum number of vcpus available.
|
|
2151
|
+
:param pulumi.Input[_builtins.float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
2152
|
+
:param pulumi.Input[_builtins.int] min_vcpu: Minimum number of vcpus available.
|
|
2100
2153
|
"""
|
|
2101
2154
|
if exclude_families is not None:
|
|
2102
2155
|
pulumi.set(__self__, "exclude_families", exclude_families)
|
|
@@ -2111,76 +2164,76 @@ class OceanImportFiltersArgs:
|
|
|
2111
2164
|
if min_vcpu is not None:
|
|
2112
2165
|
pulumi.set(__self__, "min_vcpu", min_vcpu)
|
|
2113
2166
|
|
|
2114
|
-
@property
|
|
2167
|
+
@_builtins.property
|
|
2115
2168
|
@pulumi.getter(name="excludeFamilies")
|
|
2116
|
-
def exclude_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2169
|
+
def exclude_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2117
2170
|
"""
|
|
2118
2171
|
Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
2119
2172
|
"""
|
|
2120
2173
|
return pulumi.get(self, "exclude_families")
|
|
2121
2174
|
|
|
2122
2175
|
@exclude_families.setter
|
|
2123
|
-
def exclude_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2176
|
+
def exclude_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2124
2177
|
pulumi.set(self, "exclude_families", value)
|
|
2125
2178
|
|
|
2126
|
-
@property
|
|
2179
|
+
@_builtins.property
|
|
2127
2180
|
@pulumi.getter(name="includeFamilies")
|
|
2128
|
-
def include_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2181
|
+
def include_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2129
2182
|
"""
|
|
2130
2183
|
Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
2131
2184
|
"""
|
|
2132
2185
|
return pulumi.get(self, "include_families")
|
|
2133
2186
|
|
|
2134
2187
|
@include_families.setter
|
|
2135
|
-
def include_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2188
|
+
def include_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2136
2189
|
pulumi.set(self, "include_families", value)
|
|
2137
2190
|
|
|
2138
|
-
@property
|
|
2191
|
+
@_builtins.property
|
|
2139
2192
|
@pulumi.getter(name="maxMemoryGib")
|
|
2140
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
2193
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
2141
2194
|
"""
|
|
2142
2195
|
Maximum amount of Memory (GiB).
|
|
2143
2196
|
"""
|
|
2144
2197
|
return pulumi.get(self, "max_memory_gib")
|
|
2145
2198
|
|
|
2146
2199
|
@max_memory_gib.setter
|
|
2147
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
2200
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
2148
2201
|
pulumi.set(self, "max_memory_gib", value)
|
|
2149
2202
|
|
|
2150
|
-
@property
|
|
2203
|
+
@_builtins.property
|
|
2151
2204
|
@pulumi.getter(name="maxVcpu")
|
|
2152
|
-
def max_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
2205
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2153
2206
|
"""
|
|
2154
2207
|
Maximum number of vcpus available.
|
|
2155
2208
|
"""
|
|
2156
2209
|
return pulumi.get(self, "max_vcpu")
|
|
2157
2210
|
|
|
2158
2211
|
@max_vcpu.setter
|
|
2159
|
-
def max_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
2212
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2160
2213
|
pulumi.set(self, "max_vcpu", value)
|
|
2161
2214
|
|
|
2162
|
-
@property
|
|
2215
|
+
@_builtins.property
|
|
2163
2216
|
@pulumi.getter(name="minMemoryGib")
|
|
2164
|
-
def min_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
2217
|
+
def min_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
2165
2218
|
"""
|
|
2166
2219
|
Minimum amount of Memory (GiB).
|
|
2167
2220
|
"""
|
|
2168
2221
|
return pulumi.get(self, "min_memory_gib")
|
|
2169
2222
|
|
|
2170
2223
|
@min_memory_gib.setter
|
|
2171
|
-
def min_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
2224
|
+
def min_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
2172
2225
|
pulumi.set(self, "min_memory_gib", value)
|
|
2173
2226
|
|
|
2174
|
-
@property
|
|
2227
|
+
@_builtins.property
|
|
2175
2228
|
@pulumi.getter(name="minVcpu")
|
|
2176
|
-
def min_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
2229
|
+
def min_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2177
2230
|
"""
|
|
2178
2231
|
Minimum number of vcpus available.
|
|
2179
2232
|
"""
|
|
2180
2233
|
return pulumi.get(self, "min_vcpu")
|
|
2181
2234
|
|
|
2182
2235
|
@min_vcpu.setter
|
|
2183
|
-
def min_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
2236
|
+
def min_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2184
2237
|
pulumi.set(self, "min_vcpu", value)
|
|
2185
2238
|
|
|
2186
2239
|
|
|
@@ -2211,7 +2264,7 @@ class OceanImportScheduledTaskArgs:
|
|
|
2211
2264
|
if tasks is not None:
|
|
2212
2265
|
pulumi.set(__self__, "tasks", tasks)
|
|
2213
2266
|
|
|
2214
|
-
@property
|
|
2267
|
+
@_builtins.property
|
|
2215
2268
|
@pulumi.getter(name="shutdownHours")
|
|
2216
2269
|
def shutdown_hours(self) -> Optional[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs']]:
|
|
2217
2270
|
"""
|
|
@@ -2223,7 +2276,7 @@ class OceanImportScheduledTaskArgs:
|
|
|
2223
2276
|
def shutdown_hours(self, value: Optional[pulumi.Input['OceanImportScheduledTaskShutdownHoursArgs']]):
|
|
2224
2277
|
pulumi.set(self, "shutdown_hours", value)
|
|
2225
2278
|
|
|
2226
|
-
@property
|
|
2279
|
+
@_builtins.property
|
|
2227
2280
|
@pulumi.getter
|
|
2228
2281
|
def tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanImportScheduledTaskTaskArgs']]]]:
|
|
2229
2282
|
"""
|
|
@@ -2238,12 +2291,12 @@ class OceanImportScheduledTaskArgs:
|
|
|
2238
2291
|
|
|
2239
2292
|
if not MYPY:
|
|
2240
2293
|
class OceanImportScheduledTaskShutdownHoursArgsDict(TypedDict):
|
|
2241
|
-
time_windows: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
2294
|
+
time_windows: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
2242
2295
|
"""
|
|
2243
2296
|
Set time windows for shutdown hours. specify a list of 'timeWindows' with at least one time window Each string is in the format of - ddd:hh:mm-ddd:hh:mm ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59. Time windows should not overlap. required on cluster.scheduling.isEnabled = `true`. API Times are in UTC
|
|
2244
2297
|
Example: Fri:15:30-Wed:14:30
|
|
2245
2298
|
"""
|
|
2246
|
-
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
2299
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2247
2300
|
"""
|
|
2248
2301
|
Flag to enable / disable the shutdown hours.
|
|
2249
2302
|
Example: `true`
|
|
@@ -2254,21 +2307,21 @@ elif False:
|
|
|
2254
2307
|
@pulumi.input_type
|
|
2255
2308
|
class OceanImportScheduledTaskShutdownHoursArgs:
|
|
2256
2309
|
def __init__(__self__, *,
|
|
2257
|
-
time_windows: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
2258
|
-
is_enabled: Optional[pulumi.Input[bool]] = None):
|
|
2310
|
+
time_windows: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
2311
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2259
2312
|
"""
|
|
2260
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: Set time windows for shutdown hours. specify a list of 'timeWindows' with at least one time window Each string is in the format of - ddd:hh:mm-ddd:hh:mm ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59. Time windows should not overlap. required on cluster.scheduling.isEnabled = `true`. API Times are in UTC
|
|
2313
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] time_windows: Set time windows for shutdown hours. specify a list of 'timeWindows' with at least one time window Each string is in the format of - ddd:hh:mm-ddd:hh:mm ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59. Time windows should not overlap. required on cluster.scheduling.isEnabled = `true`. API Times are in UTC
|
|
2261
2314
|
Example: Fri:15:30-Wed:14:30
|
|
2262
|
-
:param pulumi.Input[bool] is_enabled: Flag to enable / disable the shutdown hours.
|
|
2315
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Flag to enable / disable the shutdown hours.
|
|
2263
2316
|
Example: `true`
|
|
2264
2317
|
"""
|
|
2265
2318
|
pulumi.set(__self__, "time_windows", time_windows)
|
|
2266
2319
|
if is_enabled is not None:
|
|
2267
2320
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
2268
2321
|
|
|
2269
|
-
@property
|
|
2322
|
+
@_builtins.property
|
|
2270
2323
|
@pulumi.getter(name="timeWindows")
|
|
2271
|
-
def time_windows(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
2324
|
+
def time_windows(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
2272
2325
|
"""
|
|
2273
2326
|
Set time windows for shutdown hours. specify a list of 'timeWindows' with at least one time window Each string is in the format of - ddd:hh:mm-ddd:hh:mm ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59. Time windows should not overlap. required on cluster.scheduling.isEnabled = `true`. API Times are in UTC
|
|
2274
2327
|
Example: Fri:15:30-Wed:14:30
|
|
@@ -2276,12 +2329,12 @@ class OceanImportScheduledTaskShutdownHoursArgs:
|
|
|
2276
2329
|
return pulumi.get(self, "time_windows")
|
|
2277
2330
|
|
|
2278
2331
|
@time_windows.setter
|
|
2279
|
-
def time_windows(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
2332
|
+
def time_windows(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
2280
2333
|
pulumi.set(self, "time_windows", value)
|
|
2281
2334
|
|
|
2282
|
-
@property
|
|
2335
|
+
@_builtins.property
|
|
2283
2336
|
@pulumi.getter(name="isEnabled")
|
|
2284
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
2337
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2285
2338
|
"""
|
|
2286
2339
|
Flag to enable / disable the shutdown hours.
|
|
2287
2340
|
Example: `true`
|
|
@@ -2289,22 +2342,22 @@ class OceanImportScheduledTaskShutdownHoursArgs:
|
|
|
2289
2342
|
return pulumi.get(self, "is_enabled")
|
|
2290
2343
|
|
|
2291
2344
|
@is_enabled.setter
|
|
2292
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
2345
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2293
2346
|
pulumi.set(self, "is_enabled", value)
|
|
2294
2347
|
|
|
2295
2348
|
|
|
2296
2349
|
if not MYPY:
|
|
2297
2350
|
class OceanImportScheduledTaskTaskArgsDict(TypedDict):
|
|
2298
|
-
cron_expression: pulumi.Input[str]
|
|
2351
|
+
cron_expression: pulumi.Input[_builtins.str]
|
|
2299
2352
|
"""
|
|
2300
2353
|
A valid cron expression. For example : " * * * * * ".The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of ‘frequency’ or ‘cronExpression’ should be used at a time. Required for cluster.scheduling.tasks object
|
|
2301
2354
|
Example: 0 1 * * *
|
|
2302
2355
|
"""
|
|
2303
|
-
is_enabled: pulumi.Input[bool]
|
|
2356
|
+
is_enabled: pulumi.Input[_builtins.bool]
|
|
2304
2357
|
"""
|
|
2305
2358
|
Describes whether the task is enabled. When true the task should run when false it should not run. Required for cluster.scheduling.tasks object.
|
|
2306
2359
|
"""
|
|
2307
|
-
task_type: pulumi.Input[str]
|
|
2360
|
+
task_type: pulumi.Input[_builtins.str]
|
|
2308
2361
|
"""
|
|
2309
2362
|
Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
|
|
2310
2363
|
"""
|
|
@@ -2318,15 +2371,15 @@ elif False:
|
|
|
2318
2371
|
@pulumi.input_type
|
|
2319
2372
|
class OceanImportScheduledTaskTaskArgs:
|
|
2320
2373
|
def __init__(__self__, *,
|
|
2321
|
-
cron_expression: pulumi.Input[str],
|
|
2322
|
-
is_enabled: pulumi.Input[bool],
|
|
2323
|
-
task_type: pulumi.Input[str],
|
|
2374
|
+
cron_expression: pulumi.Input[_builtins.str],
|
|
2375
|
+
is_enabled: pulumi.Input[_builtins.bool],
|
|
2376
|
+
task_type: pulumi.Input[_builtins.str],
|
|
2324
2377
|
task_parameters: Optional[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersArgs']] = None):
|
|
2325
2378
|
"""
|
|
2326
|
-
:param pulumi.Input[str] cron_expression: A valid cron expression. For example : " * * * * * ".The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of ‘frequency’ or ‘cronExpression’ should be used at a time. Required for cluster.scheduling.tasks object
|
|
2379
|
+
:param pulumi.Input[_builtins.str] cron_expression: A valid cron expression. For example : " * * * * * ".The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of ‘frequency’ or ‘cronExpression’ should be used at a time. Required for cluster.scheduling.tasks object
|
|
2327
2380
|
Example: 0 1 * * *
|
|
2328
|
-
:param pulumi.Input[bool] is_enabled: Describes whether the task is enabled. When true the task should run when false it should not run. Required for cluster.scheduling.tasks object.
|
|
2329
|
-
:param pulumi.Input[str] task_type: Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
|
|
2381
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Describes whether the task is enabled. When true the task should run when false it should not run. Required for cluster.scheduling.tasks object.
|
|
2382
|
+
:param pulumi.Input[_builtins.str] task_type: Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
|
|
2330
2383
|
:param pulumi.Input['OceanImportScheduledTaskTaskTaskParametersArgs'] task_parameters: The scheduling parameters for the cluster.
|
|
2331
2384
|
"""
|
|
2332
2385
|
pulumi.set(__self__, "cron_expression", cron_expression)
|
|
@@ -2335,9 +2388,9 @@ class OceanImportScheduledTaskTaskArgs:
|
|
|
2335
2388
|
if task_parameters is not None:
|
|
2336
2389
|
pulumi.set(__self__, "task_parameters", task_parameters)
|
|
2337
2390
|
|
|
2338
|
-
@property
|
|
2391
|
+
@_builtins.property
|
|
2339
2392
|
@pulumi.getter(name="cronExpression")
|
|
2340
|
-
def cron_expression(self) -> pulumi.Input[str]:
|
|
2393
|
+
def cron_expression(self) -> pulumi.Input[_builtins.str]:
|
|
2341
2394
|
"""
|
|
2342
2395
|
A valid cron expression. For example : " * * * * * ".The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of ‘frequency’ or ‘cronExpression’ should be used at a time. Required for cluster.scheduling.tasks object
|
|
2343
2396
|
Example: 0 1 * * *
|
|
@@ -2345,34 +2398,34 @@ class OceanImportScheduledTaskTaskArgs:
|
|
|
2345
2398
|
return pulumi.get(self, "cron_expression")
|
|
2346
2399
|
|
|
2347
2400
|
@cron_expression.setter
|
|
2348
|
-
def cron_expression(self, value: pulumi.Input[str]):
|
|
2401
|
+
def cron_expression(self, value: pulumi.Input[_builtins.str]):
|
|
2349
2402
|
pulumi.set(self, "cron_expression", value)
|
|
2350
2403
|
|
|
2351
|
-
@property
|
|
2404
|
+
@_builtins.property
|
|
2352
2405
|
@pulumi.getter(name="isEnabled")
|
|
2353
|
-
def is_enabled(self) -> pulumi.Input[bool]:
|
|
2406
|
+
def is_enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
2354
2407
|
"""
|
|
2355
2408
|
Describes whether the task is enabled. When true the task should run when false it should not run. Required for cluster.scheduling.tasks object.
|
|
2356
2409
|
"""
|
|
2357
2410
|
return pulumi.get(self, "is_enabled")
|
|
2358
2411
|
|
|
2359
2412
|
@is_enabled.setter
|
|
2360
|
-
def is_enabled(self, value: pulumi.Input[bool]):
|
|
2413
|
+
def is_enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
2361
2414
|
pulumi.set(self, "is_enabled", value)
|
|
2362
2415
|
|
|
2363
|
-
@property
|
|
2416
|
+
@_builtins.property
|
|
2364
2417
|
@pulumi.getter(name="taskType")
|
|
2365
|
-
def task_type(self) -> pulumi.Input[str]:
|
|
2418
|
+
def task_type(self) -> pulumi.Input[_builtins.str]:
|
|
2366
2419
|
"""
|
|
2367
2420
|
Valid values: "clusterRoll". Required for cluster.scheduling.tasks object.
|
|
2368
2421
|
"""
|
|
2369
2422
|
return pulumi.get(self, "task_type")
|
|
2370
2423
|
|
|
2371
2424
|
@task_type.setter
|
|
2372
|
-
def task_type(self, value: pulumi.Input[str]):
|
|
2425
|
+
def task_type(self, value: pulumi.Input[_builtins.str]):
|
|
2373
2426
|
pulumi.set(self, "task_type", value)
|
|
2374
2427
|
|
|
2375
|
-
@property
|
|
2428
|
+
@_builtins.property
|
|
2376
2429
|
@pulumi.getter(name="taskParameters")
|
|
2377
2430
|
def task_parameters(self) -> Optional[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersArgs']]:
|
|
2378
2431
|
"""
|
|
@@ -2404,7 +2457,7 @@ class OceanImportScheduledTaskTaskTaskParametersArgs:
|
|
|
2404
2457
|
if cluster_roll is not None:
|
|
2405
2458
|
pulumi.set(__self__, "cluster_roll", cluster_roll)
|
|
2406
2459
|
|
|
2407
|
-
@property
|
|
2460
|
+
@_builtins.property
|
|
2408
2461
|
@pulumi.getter(name="clusterRoll")
|
|
2409
2462
|
def cluster_roll(self) -> Optional[pulumi.Input['OceanImportScheduledTaskTaskTaskParametersClusterRollArgs']]:
|
|
2410
2463
|
"""
|
|
@@ -2419,19 +2472,19 @@ class OceanImportScheduledTaskTaskTaskParametersArgs:
|
|
|
2419
2472
|
|
|
2420
2473
|
if not MYPY:
|
|
2421
2474
|
class OceanImportScheduledTaskTaskTaskParametersClusterRollArgsDict(TypedDict):
|
|
2422
|
-
batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
|
|
2475
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2423
2476
|
"""
|
|
2424
2477
|
Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
|
|
2425
2478
|
"""
|
|
2426
|
-
batch_size_percentage: NotRequired[pulumi.Input[int]]
|
|
2479
|
+
batch_size_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2427
2480
|
"""
|
|
2428
2481
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100.
|
|
2429
2482
|
"""
|
|
2430
|
-
comment: NotRequired[pulumi.Input[str]]
|
|
2483
|
+
comment: NotRequired[pulumi.Input[_builtins.str]]
|
|
2431
2484
|
"""
|
|
2432
2485
|
Add a comment description for the roll. The comment is limited to 256 chars.
|
|
2433
2486
|
"""
|
|
2434
|
-
respect_pdb: NotRequired[pulumi.Input[bool]]
|
|
2487
|
+
respect_pdb: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2435
2488
|
"""
|
|
2436
2489
|
During the roll, if the parameter is set to true we honor PDB during the instance replacement.
|
|
2437
2490
|
"""
|
|
@@ -2441,15 +2494,15 @@ elif False:
|
|
|
2441
2494
|
@pulumi.input_type
|
|
2442
2495
|
class OceanImportScheduledTaskTaskTaskParametersClusterRollArgs:
|
|
2443
2496
|
def __init__(__self__, *,
|
|
2444
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
2445
|
-
batch_size_percentage: Optional[pulumi.Input[int]] = None,
|
|
2446
|
-
comment: Optional[pulumi.Input[str]] = None,
|
|
2447
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None):
|
|
2497
|
+
batch_min_healthy_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2498
|
+
batch_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2499
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2500
|
+
respect_pdb: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2448
2501
|
"""
|
|
2449
|
-
:param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
|
|
2450
|
-
:param pulumi.Input[int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100.
|
|
2451
|
-
:param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars.
|
|
2452
|
-
:param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the instance replacement.
|
|
2502
|
+
:param pulumi.Input[_builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
|
|
2503
|
+
:param pulumi.Input[_builtins.int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100.
|
|
2504
|
+
:param pulumi.Input[_builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars.
|
|
2505
|
+
:param pulumi.Input[_builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the instance replacement.
|
|
2453
2506
|
"""
|
|
2454
2507
|
if batch_min_healthy_percentage is not None:
|
|
2455
2508
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -2460,62 +2513,62 @@ class OceanImportScheduledTaskTaskTaskParametersClusterRollArgs:
|
|
|
2460
2513
|
if respect_pdb is not None:
|
|
2461
2514
|
pulumi.set(__self__, "respect_pdb", respect_pdb)
|
|
2462
2515
|
|
|
2463
|
-
@property
|
|
2516
|
+
@_builtins.property
|
|
2464
2517
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
2465
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2518
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2466
2519
|
"""
|
|
2467
2520
|
Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
|
|
2468
2521
|
"""
|
|
2469
2522
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
2470
2523
|
|
|
2471
2524
|
@batch_min_healthy_percentage.setter
|
|
2472
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2525
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2473
2526
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
2474
2527
|
|
|
2475
|
-
@property
|
|
2528
|
+
@_builtins.property
|
|
2476
2529
|
@pulumi.getter(name="batchSizePercentage")
|
|
2477
|
-
def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2530
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2478
2531
|
"""
|
|
2479
2532
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100.
|
|
2480
2533
|
"""
|
|
2481
2534
|
return pulumi.get(self, "batch_size_percentage")
|
|
2482
2535
|
|
|
2483
2536
|
@batch_size_percentage.setter
|
|
2484
|
-
def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2537
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2485
2538
|
pulumi.set(self, "batch_size_percentage", value)
|
|
2486
2539
|
|
|
2487
|
-
@property
|
|
2540
|
+
@_builtins.property
|
|
2488
2541
|
@pulumi.getter
|
|
2489
|
-
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
2542
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2490
2543
|
"""
|
|
2491
2544
|
Add a comment description for the roll. The comment is limited to 256 chars.
|
|
2492
2545
|
"""
|
|
2493
2546
|
return pulumi.get(self, "comment")
|
|
2494
2547
|
|
|
2495
2548
|
@comment.setter
|
|
2496
|
-
def comment(self, value: Optional[pulumi.Input[str]]):
|
|
2549
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2497
2550
|
pulumi.set(self, "comment", value)
|
|
2498
2551
|
|
|
2499
|
-
@property
|
|
2552
|
+
@_builtins.property
|
|
2500
2553
|
@pulumi.getter(name="respectPdb")
|
|
2501
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
2554
|
+
def respect_pdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2502
2555
|
"""
|
|
2503
2556
|
During the roll, if the parameter is set to true we honor PDB during the instance replacement.
|
|
2504
2557
|
"""
|
|
2505
2558
|
return pulumi.get(self, "respect_pdb")
|
|
2506
2559
|
|
|
2507
2560
|
@respect_pdb.setter
|
|
2508
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
2561
|
+
def respect_pdb(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2509
2562
|
pulumi.set(self, "respect_pdb", value)
|
|
2510
2563
|
|
|
2511
2564
|
|
|
2512
2565
|
if not MYPY:
|
|
2513
2566
|
class OceanImportShieldedInstanceConfigArgsDict(TypedDict):
|
|
2514
|
-
enable_integrity_monitoring: NotRequired[pulumi.Input[bool]]
|
|
2567
|
+
enable_integrity_monitoring: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2515
2568
|
"""
|
|
2516
2569
|
Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
2517
2570
|
"""
|
|
2518
|
-
enable_secure_boot: NotRequired[pulumi.Input[bool]]
|
|
2571
|
+
enable_secure_boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2519
2572
|
"""
|
|
2520
2573
|
Boolean. Enable the secure boot parameter on the GCP instances.
|
|
2521
2574
|
"""
|
|
@@ -2525,57 +2578,61 @@ elif False:
|
|
|
2525
2578
|
@pulumi.input_type
|
|
2526
2579
|
class OceanImportShieldedInstanceConfigArgs:
|
|
2527
2580
|
def __init__(__self__, *,
|
|
2528
|
-
enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
|
|
2529
|
-
enable_secure_boot: Optional[pulumi.Input[bool]] = None):
|
|
2581
|
+
enable_integrity_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2582
|
+
enable_secure_boot: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2530
2583
|
"""
|
|
2531
|
-
:param pulumi.Input[bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
2532
|
-
:param pulumi.Input[bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
|
|
2584
|
+
:param pulumi.Input[_builtins.bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
2585
|
+
:param pulumi.Input[_builtins.bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
|
|
2533
2586
|
"""
|
|
2534
2587
|
if enable_integrity_monitoring is not None:
|
|
2535
2588
|
pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
|
|
2536
2589
|
if enable_secure_boot is not None:
|
|
2537
2590
|
pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
|
|
2538
2591
|
|
|
2539
|
-
@property
|
|
2592
|
+
@_builtins.property
|
|
2540
2593
|
@pulumi.getter(name="enableIntegrityMonitoring")
|
|
2541
|
-
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
2594
|
+
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2542
2595
|
"""
|
|
2543
2596
|
Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
2544
2597
|
"""
|
|
2545
2598
|
return pulumi.get(self, "enable_integrity_monitoring")
|
|
2546
2599
|
|
|
2547
2600
|
@enable_integrity_monitoring.setter
|
|
2548
|
-
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
2601
|
+
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2549
2602
|
pulumi.set(self, "enable_integrity_monitoring", value)
|
|
2550
2603
|
|
|
2551
|
-
@property
|
|
2604
|
+
@_builtins.property
|
|
2552
2605
|
@pulumi.getter(name="enableSecureBoot")
|
|
2553
|
-
def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
|
|
2606
|
+
def enable_secure_boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2554
2607
|
"""
|
|
2555
2608
|
Boolean. Enable the secure boot parameter on the GCP instances.
|
|
2556
2609
|
"""
|
|
2557
2610
|
return pulumi.get(self, "enable_secure_boot")
|
|
2558
2611
|
|
|
2559
2612
|
@enable_secure_boot.setter
|
|
2560
|
-
def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
|
|
2613
|
+
def enable_secure_boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2561
2614
|
pulumi.set(self, "enable_secure_boot", value)
|
|
2562
2615
|
|
|
2563
2616
|
|
|
2564
2617
|
if not MYPY:
|
|
2565
2618
|
class OceanImportStrategyArgsDict(TypedDict):
|
|
2566
|
-
draining_timeout: NotRequired[pulumi.Input[int]]
|
|
2619
|
+
draining_timeout: NotRequired[pulumi.Input[_builtins.int]]
|
|
2567
2620
|
"""
|
|
2568
2621
|
The draining timeout (in seconds) before terminating the instance. If no draining timeout is defined, the default draining timeout will be used.
|
|
2569
2622
|
"""
|
|
2570
|
-
preemptible_percentage: NotRequired[pulumi.Input[int]]
|
|
2623
|
+
preemptible_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2571
2624
|
"""
|
|
2572
2625
|
Defines the desired preemptible percentage for the cluster.
|
|
2573
2626
|
"""
|
|
2574
|
-
provisioning_model: NotRequired[pulumi.Input[str]]
|
|
2627
|
+
provisioning_model: NotRequired[pulumi.Input[_builtins.str]]
|
|
2575
2628
|
"""
|
|
2576
2629
|
Define the provisioning model of the launched instances. Valid values: `SPOT`, `PREEMPTIBLE`.
|
|
2577
2630
|
"""
|
|
2578
|
-
|
|
2631
|
+
scaling_orientation: NotRequired[pulumi.Input[_builtins.str]]
|
|
2632
|
+
"""
|
|
2633
|
+
Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
2634
|
+
"""
|
|
2635
|
+
should_utilize_commitments: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2579
2636
|
"""
|
|
2580
2637
|
Enable committed use discounts utilization.
|
|
2581
2638
|
"""
|
|
@@ -2585,15 +2642,17 @@ elif False:
|
|
|
2585
2642
|
@pulumi.input_type
|
|
2586
2643
|
class OceanImportStrategyArgs:
|
|
2587
2644
|
def __init__(__self__, *,
|
|
2588
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
2589
|
-
preemptible_percentage: Optional[pulumi.Input[int]] = None,
|
|
2590
|
-
provisioning_model: Optional[pulumi.Input[str]] = None,
|
|
2591
|
-
|
|
2592
|
-
|
|
2593
|
-
|
|
2594
|
-
:param pulumi.Input[int]
|
|
2595
|
-
:param pulumi.Input[
|
|
2596
|
-
:param pulumi.Input[
|
|
2645
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2646
|
+
preemptible_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2647
|
+
provisioning_model: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2648
|
+
scaling_orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2649
|
+
should_utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2650
|
+
"""
|
|
2651
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The draining timeout (in seconds) before terminating the instance. If no draining timeout is defined, the default draining timeout will be used.
|
|
2652
|
+
:param pulumi.Input[_builtins.int] preemptible_percentage: Defines the desired preemptible percentage for the cluster.
|
|
2653
|
+
:param pulumi.Input[_builtins.str] provisioning_model: Define the provisioning model of the launched instances. Valid values: `SPOT`, `PREEMPTIBLE`.
|
|
2654
|
+
:param pulumi.Input[_builtins.str] scaling_orientation: Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
2655
|
+
:param pulumi.Input[_builtins.bool] should_utilize_commitments: Enable committed use discounts utilization.
|
|
2597
2656
|
"""
|
|
2598
2657
|
if draining_timeout is not None:
|
|
2599
2658
|
pulumi.set(__self__, "draining_timeout", draining_timeout)
|
|
@@ -2601,65 +2660,79 @@ class OceanImportStrategyArgs:
|
|
|
2601
2660
|
pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
|
|
2602
2661
|
if provisioning_model is not None:
|
|
2603
2662
|
pulumi.set(__self__, "provisioning_model", provisioning_model)
|
|
2663
|
+
if scaling_orientation is not None:
|
|
2664
|
+
pulumi.set(__self__, "scaling_orientation", scaling_orientation)
|
|
2604
2665
|
if should_utilize_commitments is not None:
|
|
2605
2666
|
pulumi.set(__self__, "should_utilize_commitments", should_utilize_commitments)
|
|
2606
2667
|
|
|
2607
|
-
@property
|
|
2668
|
+
@_builtins.property
|
|
2608
2669
|
@pulumi.getter(name="drainingTimeout")
|
|
2609
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
2670
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2610
2671
|
"""
|
|
2611
2672
|
The draining timeout (in seconds) before terminating the instance. If no draining timeout is defined, the default draining timeout will be used.
|
|
2612
2673
|
"""
|
|
2613
2674
|
return pulumi.get(self, "draining_timeout")
|
|
2614
2675
|
|
|
2615
2676
|
@draining_timeout.setter
|
|
2616
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
2677
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2617
2678
|
pulumi.set(self, "draining_timeout", value)
|
|
2618
2679
|
|
|
2619
|
-
@property
|
|
2680
|
+
@_builtins.property
|
|
2620
2681
|
@pulumi.getter(name="preemptiblePercentage")
|
|
2621
|
-
def preemptible_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2682
|
+
def preemptible_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2622
2683
|
"""
|
|
2623
2684
|
Defines the desired preemptible percentage for the cluster.
|
|
2624
2685
|
"""
|
|
2625
2686
|
return pulumi.get(self, "preemptible_percentage")
|
|
2626
2687
|
|
|
2627
2688
|
@preemptible_percentage.setter
|
|
2628
|
-
def preemptible_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2689
|
+
def preemptible_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2629
2690
|
pulumi.set(self, "preemptible_percentage", value)
|
|
2630
2691
|
|
|
2631
|
-
@property
|
|
2692
|
+
@_builtins.property
|
|
2632
2693
|
@pulumi.getter(name="provisioningModel")
|
|
2633
|
-
def provisioning_model(self) -> Optional[pulumi.Input[str]]:
|
|
2694
|
+
def provisioning_model(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2634
2695
|
"""
|
|
2635
2696
|
Define the provisioning model of the launched instances. Valid values: `SPOT`, `PREEMPTIBLE`.
|
|
2636
2697
|
"""
|
|
2637
2698
|
return pulumi.get(self, "provisioning_model")
|
|
2638
2699
|
|
|
2639
2700
|
@provisioning_model.setter
|
|
2640
|
-
def provisioning_model(self, value: Optional[pulumi.Input[str]]):
|
|
2701
|
+
def provisioning_model(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2641
2702
|
pulumi.set(self, "provisioning_model", value)
|
|
2642
2703
|
|
|
2643
|
-
@property
|
|
2704
|
+
@_builtins.property
|
|
2705
|
+
@pulumi.getter(name="scalingOrientation")
|
|
2706
|
+
def scaling_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2707
|
+
"""
|
|
2708
|
+
Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
2709
|
+
"""
|
|
2710
|
+
return pulumi.get(self, "scaling_orientation")
|
|
2711
|
+
|
|
2712
|
+
@scaling_orientation.setter
|
|
2713
|
+
def scaling_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2714
|
+
pulumi.set(self, "scaling_orientation", value)
|
|
2715
|
+
|
|
2716
|
+
@_builtins.property
|
|
2644
2717
|
@pulumi.getter(name="shouldUtilizeCommitments")
|
|
2645
|
-
def should_utilize_commitments(self) -> Optional[pulumi.Input[bool]]:
|
|
2718
|
+
def should_utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2646
2719
|
"""
|
|
2647
2720
|
Enable committed use discounts utilization.
|
|
2648
2721
|
"""
|
|
2649
2722
|
return pulumi.get(self, "should_utilize_commitments")
|
|
2650
2723
|
|
|
2651
2724
|
@should_utilize_commitments.setter
|
|
2652
|
-
def should_utilize_commitments(self, value: Optional[pulumi.Input[bool]]):
|
|
2725
|
+
def should_utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2653
2726
|
pulumi.set(self, "should_utilize_commitments", value)
|
|
2654
2727
|
|
|
2655
2728
|
|
|
2656
2729
|
if not MYPY:
|
|
2657
2730
|
class OceanImportUpdatePolicyArgsDict(TypedDict):
|
|
2658
|
-
should_roll: pulumi.Input[bool]
|
|
2731
|
+
should_roll: pulumi.Input[_builtins.bool]
|
|
2659
2732
|
"""
|
|
2660
2733
|
Enables the roll.
|
|
2661
2734
|
"""
|
|
2662
|
-
conditioned_roll: NotRequired[pulumi.Input[bool]]
|
|
2735
|
+
conditioned_roll: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2663
2736
|
"""
|
|
2664
2737
|
Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as AMI, Key Pair, user data, instance types, load balancers, etc).
|
|
2665
2738
|
"""
|
|
@@ -2673,12 +2746,12 @@ elif False:
|
|
|
2673
2746
|
@pulumi.input_type
|
|
2674
2747
|
class OceanImportUpdatePolicyArgs:
|
|
2675
2748
|
def __init__(__self__, *,
|
|
2676
|
-
should_roll: pulumi.Input[bool],
|
|
2677
|
-
conditioned_roll: Optional[pulumi.Input[bool]] = None,
|
|
2749
|
+
should_roll: pulumi.Input[_builtins.bool],
|
|
2750
|
+
conditioned_roll: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2678
2751
|
roll_config: Optional[pulumi.Input['OceanImportUpdatePolicyRollConfigArgs']] = None):
|
|
2679
2752
|
"""
|
|
2680
|
-
:param pulumi.Input[bool] should_roll: Enables the roll.
|
|
2681
|
-
:param pulumi.Input[bool] conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as AMI, Key Pair, user data, instance types, load balancers, etc).
|
|
2753
|
+
:param pulumi.Input[_builtins.bool] should_roll: Enables the roll.
|
|
2754
|
+
:param pulumi.Input[_builtins.bool] conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as AMI, Key Pair, user data, instance types, load balancers, etc).
|
|
2682
2755
|
:param pulumi.Input['OceanImportUpdatePolicyRollConfigArgs'] roll_config: Holds the roll configuration.
|
|
2683
2756
|
"""
|
|
2684
2757
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
@@ -2687,31 +2760,31 @@ class OceanImportUpdatePolicyArgs:
|
|
|
2687
2760
|
if roll_config is not None:
|
|
2688
2761
|
pulumi.set(__self__, "roll_config", roll_config)
|
|
2689
2762
|
|
|
2690
|
-
@property
|
|
2763
|
+
@_builtins.property
|
|
2691
2764
|
@pulumi.getter(name="shouldRoll")
|
|
2692
|
-
def should_roll(self) -> pulumi.Input[bool]:
|
|
2765
|
+
def should_roll(self) -> pulumi.Input[_builtins.bool]:
|
|
2693
2766
|
"""
|
|
2694
2767
|
Enables the roll.
|
|
2695
2768
|
"""
|
|
2696
2769
|
return pulumi.get(self, "should_roll")
|
|
2697
2770
|
|
|
2698
2771
|
@should_roll.setter
|
|
2699
|
-
def should_roll(self, value: pulumi.Input[bool]):
|
|
2772
|
+
def should_roll(self, value: pulumi.Input[_builtins.bool]):
|
|
2700
2773
|
pulumi.set(self, "should_roll", value)
|
|
2701
2774
|
|
|
2702
|
-
@property
|
|
2775
|
+
@_builtins.property
|
|
2703
2776
|
@pulumi.getter(name="conditionedRoll")
|
|
2704
|
-
def conditioned_roll(self) -> Optional[pulumi.Input[bool]]:
|
|
2777
|
+
def conditioned_roll(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2705
2778
|
"""
|
|
2706
2779
|
Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as AMI, Key Pair, user data, instance types, load balancers, etc).
|
|
2707
2780
|
"""
|
|
2708
2781
|
return pulumi.get(self, "conditioned_roll")
|
|
2709
2782
|
|
|
2710
2783
|
@conditioned_roll.setter
|
|
2711
|
-
def conditioned_roll(self, value: Optional[pulumi.Input[bool]]):
|
|
2784
|
+
def conditioned_roll(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2712
2785
|
pulumi.set(self, "conditioned_roll", value)
|
|
2713
2786
|
|
|
2714
|
-
@property
|
|
2787
|
+
@_builtins.property
|
|
2715
2788
|
@pulumi.getter(name="rollConfig")
|
|
2716
2789
|
def roll_config(self) -> Optional[pulumi.Input['OceanImportUpdatePolicyRollConfigArgs']]:
|
|
2717
2790
|
"""
|
|
@@ -2726,19 +2799,19 @@ class OceanImportUpdatePolicyArgs:
|
|
|
2726
2799
|
|
|
2727
2800
|
if not MYPY:
|
|
2728
2801
|
class OceanImportUpdatePolicyRollConfigArgsDict(TypedDict):
|
|
2729
|
-
batch_size_percentage: pulumi.Input[int]
|
|
2802
|
+
batch_size_percentage: pulumi.Input[_builtins.int]
|
|
2730
2803
|
"""
|
|
2731
2804
|
Sets the percentage of the instances to deploy in each batch.
|
|
2732
2805
|
"""
|
|
2733
|
-
batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
|
|
2806
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2734
2807
|
"""
|
|
2735
2808
|
Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
|
|
2736
2809
|
"""
|
|
2737
|
-
launch_spec_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2810
|
+
launch_spec_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2738
2811
|
"""
|
|
2739
2812
|
List of Virtual Node Group identifiers to be rolled.
|
|
2740
2813
|
"""
|
|
2741
|
-
respect_pdb: NotRequired[pulumi.Input[bool]]
|
|
2814
|
+
respect_pdb: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2742
2815
|
"""
|
|
2743
2816
|
Default: `false`. During the roll, if the parameter is set to `true` we honor PDB during the instance replacement.
|
|
2744
2817
|
"""
|
|
@@ -2748,15 +2821,15 @@ elif False:
|
|
|
2748
2821
|
@pulumi.input_type
|
|
2749
2822
|
class OceanImportUpdatePolicyRollConfigArgs:
|
|
2750
2823
|
def __init__(__self__, *,
|
|
2751
|
-
batch_size_percentage: pulumi.Input[int],
|
|
2752
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
2753
|
-
launch_spec_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2754
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None):
|
|
2824
|
+
batch_size_percentage: pulumi.Input[_builtins.int],
|
|
2825
|
+
batch_min_healthy_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2826
|
+
launch_spec_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2827
|
+
respect_pdb: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2755
2828
|
"""
|
|
2756
|
-
:param pulumi.Input[int] batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
|
|
2757
|
-
:param pulumi.Input[int] batch_min_healthy_percentage: Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
|
|
2758
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] launch_spec_ids: List of Virtual Node Group identifiers to be rolled.
|
|
2759
|
-
:param pulumi.Input[bool] respect_pdb: Default: `false`. During the roll, if the parameter is set to `true` we honor PDB during the instance replacement.
|
|
2829
|
+
:param pulumi.Input[_builtins.int] batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
|
|
2830
|
+
:param pulumi.Input[_builtins.int] batch_min_healthy_percentage: Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
|
|
2831
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] launch_spec_ids: List of Virtual Node Group identifiers to be rolled.
|
|
2832
|
+
:param pulumi.Input[_builtins.bool] respect_pdb: Default: `false`. During the roll, if the parameter is set to `true` we honor PDB during the instance replacement.
|
|
2760
2833
|
"""
|
|
2761
2834
|
pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
|
|
2762
2835
|
if batch_min_healthy_percentage is not None:
|
|
@@ -2766,70 +2839,70 @@ class OceanImportUpdatePolicyRollConfigArgs:
|
|
|
2766
2839
|
if respect_pdb is not None:
|
|
2767
2840
|
pulumi.set(__self__, "respect_pdb", respect_pdb)
|
|
2768
2841
|
|
|
2769
|
-
@property
|
|
2842
|
+
@_builtins.property
|
|
2770
2843
|
@pulumi.getter(name="batchSizePercentage")
|
|
2771
|
-
def batch_size_percentage(self) -> pulumi.Input[int]:
|
|
2844
|
+
def batch_size_percentage(self) -> pulumi.Input[_builtins.int]:
|
|
2772
2845
|
"""
|
|
2773
2846
|
Sets the percentage of the instances to deploy in each batch.
|
|
2774
2847
|
"""
|
|
2775
2848
|
return pulumi.get(self, "batch_size_percentage")
|
|
2776
2849
|
|
|
2777
2850
|
@batch_size_percentage.setter
|
|
2778
|
-
def batch_size_percentage(self, value: pulumi.Input[int]):
|
|
2851
|
+
def batch_size_percentage(self, value: pulumi.Input[_builtins.int]):
|
|
2779
2852
|
pulumi.set(self, "batch_size_percentage", value)
|
|
2780
2853
|
|
|
2781
|
-
@property
|
|
2854
|
+
@_builtins.property
|
|
2782
2855
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
2783
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2856
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2784
2857
|
"""
|
|
2785
2858
|
Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
|
|
2786
2859
|
"""
|
|
2787
2860
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
2788
2861
|
|
|
2789
2862
|
@batch_min_healthy_percentage.setter
|
|
2790
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2863
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2791
2864
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
2792
2865
|
|
|
2793
|
-
@property
|
|
2866
|
+
@_builtins.property
|
|
2794
2867
|
@pulumi.getter(name="launchSpecIds")
|
|
2795
|
-
def launch_spec_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2868
|
+
def launch_spec_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2796
2869
|
"""
|
|
2797
2870
|
List of Virtual Node Group identifiers to be rolled.
|
|
2798
2871
|
"""
|
|
2799
2872
|
return pulumi.get(self, "launch_spec_ids")
|
|
2800
2873
|
|
|
2801
2874
|
@launch_spec_ids.setter
|
|
2802
|
-
def launch_spec_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2875
|
+
def launch_spec_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2803
2876
|
pulumi.set(self, "launch_spec_ids", value)
|
|
2804
2877
|
|
|
2805
|
-
@property
|
|
2878
|
+
@_builtins.property
|
|
2806
2879
|
@pulumi.getter(name="respectPdb")
|
|
2807
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
2880
|
+
def respect_pdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2808
2881
|
"""
|
|
2809
2882
|
Default: `false`. During the roll, if the parameter is set to `true` we honor PDB during the instance replacement.
|
|
2810
2883
|
"""
|
|
2811
2884
|
return pulumi.get(self, "respect_pdb")
|
|
2812
2885
|
|
|
2813
2886
|
@respect_pdb.setter
|
|
2814
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
2887
|
+
def respect_pdb(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2815
2888
|
pulumi.set(self, "respect_pdb", value)
|
|
2816
2889
|
|
|
2817
2890
|
|
|
2818
2891
|
if not MYPY:
|
|
2819
2892
|
class OceanLaunchSpecAutoscaleHeadroomArgsDict(TypedDict):
|
|
2820
|
-
num_of_units: pulumi.Input[int]
|
|
2893
|
+
num_of_units: pulumi.Input[_builtins.int]
|
|
2821
2894
|
"""
|
|
2822
2895
|
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
2823
2896
|
"""
|
|
2824
|
-
cpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
2897
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2825
2898
|
"""
|
|
2826
2899
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2827
2900
|
"""
|
|
2828
|
-
gpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
2901
|
+
gpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2829
2902
|
"""
|
|
2830
2903
|
Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
2831
2904
|
"""
|
|
2832
|
-
memory_per_unit: NotRequired[pulumi.Input[int]]
|
|
2905
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2833
2906
|
"""
|
|
2834
2907
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
2835
2908
|
"""
|
|
@@ -2839,15 +2912,15 @@ elif False:
|
|
|
2839
2912
|
@pulumi.input_type
|
|
2840
2913
|
class OceanLaunchSpecAutoscaleHeadroomArgs:
|
|
2841
2914
|
def __init__(__self__, *,
|
|
2842
|
-
num_of_units: pulumi.Input[int],
|
|
2843
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
2844
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
2845
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None):
|
|
2915
|
+
num_of_units: pulumi.Input[_builtins.int],
|
|
2916
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2917
|
+
gpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2918
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2846
2919
|
"""
|
|
2847
|
-
:param pulumi.Input[int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
2848
|
-
:param pulumi.Input[int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2849
|
-
:param pulumi.Input[int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
2850
|
-
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
2920
|
+
:param pulumi.Input[_builtins.int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
2921
|
+
:param pulumi.Input[_builtins.int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2922
|
+
:param pulumi.Input[_builtins.int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
2923
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
2851
2924
|
"""
|
|
2852
2925
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
2853
2926
|
if cpu_per_unit is not None:
|
|
@@ -2857,58 +2930,58 @@ class OceanLaunchSpecAutoscaleHeadroomArgs:
|
|
|
2857
2930
|
if memory_per_unit is not None:
|
|
2858
2931
|
pulumi.set(__self__, "memory_per_unit", memory_per_unit)
|
|
2859
2932
|
|
|
2860
|
-
@property
|
|
2933
|
+
@_builtins.property
|
|
2861
2934
|
@pulumi.getter(name="numOfUnits")
|
|
2862
|
-
def num_of_units(self) -> pulumi.Input[int]:
|
|
2935
|
+
def num_of_units(self) -> pulumi.Input[_builtins.int]:
|
|
2863
2936
|
"""
|
|
2864
2937
|
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
2865
2938
|
"""
|
|
2866
2939
|
return pulumi.get(self, "num_of_units")
|
|
2867
2940
|
|
|
2868
2941
|
@num_of_units.setter
|
|
2869
|
-
def num_of_units(self, value: pulumi.Input[int]):
|
|
2942
|
+
def num_of_units(self, value: pulumi.Input[_builtins.int]):
|
|
2870
2943
|
pulumi.set(self, "num_of_units", value)
|
|
2871
2944
|
|
|
2872
|
-
@property
|
|
2945
|
+
@_builtins.property
|
|
2873
2946
|
@pulumi.getter(name="cpuPerUnit")
|
|
2874
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2947
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2875
2948
|
"""
|
|
2876
2949
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2877
2950
|
"""
|
|
2878
2951
|
return pulumi.get(self, "cpu_per_unit")
|
|
2879
2952
|
|
|
2880
2953
|
@cpu_per_unit.setter
|
|
2881
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2954
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2882
2955
|
pulumi.set(self, "cpu_per_unit", value)
|
|
2883
2956
|
|
|
2884
|
-
@property
|
|
2957
|
+
@_builtins.property
|
|
2885
2958
|
@pulumi.getter(name="gpuPerUnit")
|
|
2886
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2959
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2887
2960
|
"""
|
|
2888
2961
|
Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
2889
2962
|
"""
|
|
2890
2963
|
return pulumi.get(self, "gpu_per_unit")
|
|
2891
2964
|
|
|
2892
2965
|
@gpu_per_unit.setter
|
|
2893
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2966
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2894
2967
|
pulumi.set(self, "gpu_per_unit", value)
|
|
2895
2968
|
|
|
2896
|
-
@property
|
|
2969
|
+
@_builtins.property
|
|
2897
2970
|
@pulumi.getter(name="memoryPerUnit")
|
|
2898
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2971
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2899
2972
|
"""
|
|
2900
2973
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
2901
2974
|
"""
|
|
2902
2975
|
return pulumi.get(self, "memory_per_unit")
|
|
2903
2976
|
|
|
2904
2977
|
@memory_per_unit.setter
|
|
2905
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2978
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2906
2979
|
pulumi.set(self, "memory_per_unit", value)
|
|
2907
2980
|
|
|
2908
2981
|
|
|
2909
2982
|
if not MYPY:
|
|
2910
2983
|
class OceanLaunchSpecAutoscaleHeadroomsAutomaticArgsDict(TypedDict):
|
|
2911
|
-
auto_headroom_percentage: NotRequired[pulumi.Input[int]]
|
|
2984
|
+
auto_headroom_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2912
2985
|
"""
|
|
2913
2986
|
Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
|
|
2914
2987
|
"""
|
|
@@ -2918,29 +2991,29 @@ elif False:
|
|
|
2918
2991
|
@pulumi.input_type
|
|
2919
2992
|
class OceanLaunchSpecAutoscaleHeadroomsAutomaticArgs:
|
|
2920
2993
|
def __init__(__self__, *,
|
|
2921
|
-
auto_headroom_percentage: Optional[pulumi.Input[int]] = None):
|
|
2994
|
+
auto_headroom_percentage: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2922
2995
|
"""
|
|
2923
|
-
:param pulumi.Input[int] auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
|
|
2996
|
+
:param pulumi.Input[_builtins.int] auto_headroom_percentage: Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
|
|
2924
2997
|
"""
|
|
2925
2998
|
if auto_headroom_percentage is not None:
|
|
2926
2999
|
pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
|
|
2927
3000
|
|
|
2928
|
-
@property
|
|
3001
|
+
@_builtins.property
|
|
2929
3002
|
@pulumi.getter(name="autoHeadroomPercentage")
|
|
2930
|
-
def auto_headroom_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
3003
|
+
def auto_headroom_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2931
3004
|
"""
|
|
2932
3005
|
Number between 0-200 to control the headroom % of the specific Virtual Node Group. Effective when cluster.autoScaler.headroom.automatic.`is_enabled` = true is set on the Ocean cluster.
|
|
2933
3006
|
"""
|
|
2934
3007
|
return pulumi.get(self, "auto_headroom_percentage")
|
|
2935
3008
|
|
|
2936
3009
|
@auto_headroom_percentage.setter
|
|
2937
|
-
def auto_headroom_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
3010
|
+
def auto_headroom_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2938
3011
|
pulumi.set(self, "auto_headroom_percentage", value)
|
|
2939
3012
|
|
|
2940
3013
|
|
|
2941
3014
|
if not MYPY:
|
|
2942
3015
|
class OceanLaunchSpecCreateOptionsArgsDict(TypedDict):
|
|
2943
|
-
initial_nodes: NotRequired[pulumi.Input[int]]
|
|
3016
|
+
initial_nodes: NotRequired[pulumi.Input[_builtins.int]]
|
|
2944
3017
|
"""
|
|
2945
3018
|
When set to an integer greater than 0, a corresponding amount of nodes will be launched from the created Virtual Node Group.
|
|
2946
3019
|
"""
|
|
@@ -2950,33 +3023,165 @@ elif False:
|
|
|
2950
3023
|
@pulumi.input_type
|
|
2951
3024
|
class OceanLaunchSpecCreateOptionsArgs:
|
|
2952
3025
|
def __init__(__self__, *,
|
|
2953
|
-
initial_nodes: Optional[pulumi.Input[int]] = None):
|
|
3026
|
+
initial_nodes: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2954
3027
|
"""
|
|
2955
|
-
:param pulumi.Input[int] initial_nodes: When set to an integer greater than 0, a corresponding amount of nodes will be launched from the created Virtual Node Group.
|
|
3028
|
+
:param pulumi.Input[_builtins.int] initial_nodes: When set to an integer greater than 0, a corresponding amount of nodes will be launched from the created Virtual Node Group.
|
|
2956
3029
|
"""
|
|
2957
3030
|
if initial_nodes is not None:
|
|
2958
3031
|
pulumi.set(__self__, "initial_nodes", initial_nodes)
|
|
2959
3032
|
|
|
2960
|
-
@property
|
|
3033
|
+
@_builtins.property
|
|
2961
3034
|
@pulumi.getter(name="initialNodes")
|
|
2962
|
-
def initial_nodes(self) -> Optional[pulumi.Input[int]]:
|
|
3035
|
+
def initial_nodes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2963
3036
|
"""
|
|
2964
3037
|
When set to an integer greater than 0, a corresponding amount of nodes will be launched from the created Virtual Node Group.
|
|
2965
3038
|
"""
|
|
2966
3039
|
return pulumi.get(self, "initial_nodes")
|
|
2967
3040
|
|
|
2968
3041
|
@initial_nodes.setter
|
|
2969
|
-
def initial_nodes(self, value: Optional[pulumi.Input[int]]):
|
|
3042
|
+
def initial_nodes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2970
3043
|
pulumi.set(self, "initial_nodes", value)
|
|
2971
3044
|
|
|
2972
3045
|
|
|
3046
|
+
if not MYPY:
|
|
3047
|
+
class OceanLaunchSpecFiltersArgsDict(TypedDict):
|
|
3048
|
+
exclude_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
3049
|
+
"""
|
|
3050
|
+
Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
3051
|
+
"""
|
|
3052
|
+
include_families: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
3053
|
+
"""
|
|
3054
|
+
Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
3055
|
+
"""
|
|
3056
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
3057
|
+
"""
|
|
3058
|
+
Maximum amount of Memory (GiB).
|
|
3059
|
+
"""
|
|
3060
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
3061
|
+
"""
|
|
3062
|
+
Maximum number of vcpus available.
|
|
3063
|
+
"""
|
|
3064
|
+
min_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
3065
|
+
"""
|
|
3066
|
+
Minimum amount of Memory (GiB).
|
|
3067
|
+
"""
|
|
3068
|
+
min_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
3069
|
+
"""
|
|
3070
|
+
Minimum number of vcpus available.
|
|
3071
|
+
"""
|
|
3072
|
+
elif False:
|
|
3073
|
+
OceanLaunchSpecFiltersArgsDict: TypeAlias = Mapping[str, Any]
|
|
3074
|
+
|
|
3075
|
+
@pulumi.input_type
|
|
3076
|
+
class OceanLaunchSpecFiltersArgs:
|
|
3077
|
+
def __init__(__self__, *,
|
|
3078
|
+
exclude_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3079
|
+
include_families: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3080
|
+
max_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
3081
|
+
max_vcpu: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3082
|
+
min_memory_gib: Optional[pulumi.Input[_builtins.float]] = None,
|
|
3083
|
+
min_vcpu: Optional[pulumi.Input[_builtins.int]] = None):
|
|
3084
|
+
"""
|
|
3085
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_families: Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
3086
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] include_families: Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
3087
|
+
:param pulumi.Input[_builtins.float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
3088
|
+
:param pulumi.Input[_builtins.int] max_vcpu: Maximum number of vcpus available.
|
|
3089
|
+
:param pulumi.Input[_builtins.float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
3090
|
+
:param pulumi.Input[_builtins.int] min_vcpu: Minimum number of vcpus available.
|
|
3091
|
+
"""
|
|
3092
|
+
if exclude_families is not None:
|
|
3093
|
+
pulumi.set(__self__, "exclude_families", exclude_families)
|
|
3094
|
+
if include_families is not None:
|
|
3095
|
+
pulumi.set(__self__, "include_families", include_families)
|
|
3096
|
+
if max_memory_gib is not None:
|
|
3097
|
+
pulumi.set(__self__, "max_memory_gib", max_memory_gib)
|
|
3098
|
+
if max_vcpu is not None:
|
|
3099
|
+
pulumi.set(__self__, "max_vcpu", max_vcpu)
|
|
3100
|
+
if min_memory_gib is not None:
|
|
3101
|
+
pulumi.set(__self__, "min_memory_gib", min_memory_gib)
|
|
3102
|
+
if min_vcpu is not None:
|
|
3103
|
+
pulumi.set(__self__, "min_vcpu", min_vcpu)
|
|
3104
|
+
|
|
3105
|
+
@_builtins.property
|
|
3106
|
+
@pulumi.getter(name="excludeFamilies")
|
|
3107
|
+
def exclude_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
3108
|
+
"""
|
|
3109
|
+
Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
|
|
3110
|
+
"""
|
|
3111
|
+
return pulumi.get(self, "exclude_families")
|
|
3112
|
+
|
|
3113
|
+
@exclude_families.setter
|
|
3114
|
+
def exclude_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
3115
|
+
pulumi.set(self, "exclude_families", value)
|
|
3116
|
+
|
|
3117
|
+
@_builtins.property
|
|
3118
|
+
@pulumi.getter(name="includeFamilies")
|
|
3119
|
+
def include_families(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
3120
|
+
"""
|
|
3121
|
+
Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
|
|
3122
|
+
"""
|
|
3123
|
+
return pulumi.get(self, "include_families")
|
|
3124
|
+
|
|
3125
|
+
@include_families.setter
|
|
3126
|
+
def include_families(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
3127
|
+
pulumi.set(self, "include_families", value)
|
|
3128
|
+
|
|
3129
|
+
@_builtins.property
|
|
3130
|
+
@pulumi.getter(name="maxMemoryGib")
|
|
3131
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
3132
|
+
"""
|
|
3133
|
+
Maximum amount of Memory (GiB).
|
|
3134
|
+
"""
|
|
3135
|
+
return pulumi.get(self, "max_memory_gib")
|
|
3136
|
+
|
|
3137
|
+
@max_memory_gib.setter
|
|
3138
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
3139
|
+
pulumi.set(self, "max_memory_gib", value)
|
|
3140
|
+
|
|
3141
|
+
@_builtins.property
|
|
3142
|
+
@pulumi.getter(name="maxVcpu")
|
|
3143
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3144
|
+
"""
|
|
3145
|
+
Maximum number of vcpus available.
|
|
3146
|
+
"""
|
|
3147
|
+
return pulumi.get(self, "max_vcpu")
|
|
3148
|
+
|
|
3149
|
+
@max_vcpu.setter
|
|
3150
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3151
|
+
pulumi.set(self, "max_vcpu", value)
|
|
3152
|
+
|
|
3153
|
+
@_builtins.property
|
|
3154
|
+
@pulumi.getter(name="minMemoryGib")
|
|
3155
|
+
def min_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
3156
|
+
"""
|
|
3157
|
+
Minimum amount of Memory (GiB).
|
|
3158
|
+
"""
|
|
3159
|
+
return pulumi.get(self, "min_memory_gib")
|
|
3160
|
+
|
|
3161
|
+
@min_memory_gib.setter
|
|
3162
|
+
def min_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
3163
|
+
pulumi.set(self, "min_memory_gib", value)
|
|
3164
|
+
|
|
3165
|
+
@_builtins.property
|
|
3166
|
+
@pulumi.getter(name="minVcpu")
|
|
3167
|
+
def min_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3168
|
+
"""
|
|
3169
|
+
Minimum number of vcpus available.
|
|
3170
|
+
"""
|
|
3171
|
+
return pulumi.get(self, "min_vcpu")
|
|
3172
|
+
|
|
3173
|
+
@min_vcpu.setter
|
|
3174
|
+
def min_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3175
|
+
pulumi.set(self, "min_vcpu", value)
|
|
3176
|
+
|
|
3177
|
+
|
|
2973
3178
|
if not MYPY:
|
|
2974
3179
|
class OceanLaunchSpecLabelArgsDict(TypedDict):
|
|
2975
|
-
key: NotRequired[pulumi.Input[str]]
|
|
3180
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
2976
3181
|
"""
|
|
2977
3182
|
The label key.
|
|
2978
3183
|
"""
|
|
2979
|
-
value: NotRequired[pulumi.Input[str]]
|
|
3184
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
2980
3185
|
"""
|
|
2981
3186
|
The label value.
|
|
2982
3187
|
"""
|
|
@@ -2986,49 +3191,49 @@ elif False:
|
|
|
2986
3191
|
@pulumi.input_type
|
|
2987
3192
|
class OceanLaunchSpecLabelArgs:
|
|
2988
3193
|
def __init__(__self__, *,
|
|
2989
|
-
key: Optional[pulumi.Input[str]] = None,
|
|
2990
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
3194
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3195
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2991
3196
|
"""
|
|
2992
|
-
:param pulumi.Input[str] key: The label key.
|
|
2993
|
-
:param pulumi.Input[str] value: The label value.
|
|
3197
|
+
:param pulumi.Input[_builtins.str] key: The label key.
|
|
3198
|
+
:param pulumi.Input[_builtins.str] value: The label value.
|
|
2994
3199
|
"""
|
|
2995
3200
|
if key is not None:
|
|
2996
3201
|
pulumi.set(__self__, "key", key)
|
|
2997
3202
|
if value is not None:
|
|
2998
3203
|
pulumi.set(__self__, "value", value)
|
|
2999
3204
|
|
|
3000
|
-
@property
|
|
3205
|
+
@_builtins.property
|
|
3001
3206
|
@pulumi.getter
|
|
3002
|
-
def key(self) -> Optional[pulumi.Input[str]]:
|
|
3207
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3003
3208
|
"""
|
|
3004
3209
|
The label key.
|
|
3005
3210
|
"""
|
|
3006
3211
|
return pulumi.get(self, "key")
|
|
3007
3212
|
|
|
3008
3213
|
@key.setter
|
|
3009
|
-
def key(self, value: Optional[pulumi.Input[str]]):
|
|
3214
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3010
3215
|
pulumi.set(self, "key", value)
|
|
3011
3216
|
|
|
3012
|
-
@property
|
|
3217
|
+
@_builtins.property
|
|
3013
3218
|
@pulumi.getter
|
|
3014
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
3219
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3015
3220
|
"""
|
|
3016
3221
|
The label value.
|
|
3017
3222
|
"""
|
|
3018
3223
|
return pulumi.get(self, "value")
|
|
3019
3224
|
|
|
3020
3225
|
@value.setter
|
|
3021
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
3226
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3022
3227
|
pulumi.set(self, "value", value)
|
|
3023
3228
|
|
|
3024
3229
|
|
|
3025
3230
|
if not MYPY:
|
|
3026
3231
|
class OceanLaunchSpecMetadataArgsDict(TypedDict):
|
|
3027
|
-
key: NotRequired[pulumi.Input[str]]
|
|
3232
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
3028
3233
|
"""
|
|
3029
3234
|
The metadata key.
|
|
3030
3235
|
"""
|
|
3031
|
-
value: NotRequired[pulumi.Input[str]]
|
|
3236
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
3032
3237
|
"""
|
|
3033
3238
|
The metadata value.
|
|
3034
3239
|
"""
|
|
@@ -3038,45 +3243,45 @@ elif False:
|
|
|
3038
3243
|
@pulumi.input_type
|
|
3039
3244
|
class OceanLaunchSpecMetadataArgs:
|
|
3040
3245
|
def __init__(__self__, *,
|
|
3041
|
-
key: Optional[pulumi.Input[str]] = None,
|
|
3042
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
3246
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3247
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3043
3248
|
"""
|
|
3044
|
-
:param pulumi.Input[str] key: The metadata key.
|
|
3045
|
-
:param pulumi.Input[str] value: The metadata value.
|
|
3249
|
+
:param pulumi.Input[_builtins.str] key: The metadata key.
|
|
3250
|
+
:param pulumi.Input[_builtins.str] value: The metadata value.
|
|
3046
3251
|
"""
|
|
3047
3252
|
if key is not None:
|
|
3048
3253
|
pulumi.set(__self__, "key", key)
|
|
3049
3254
|
if value is not None:
|
|
3050
3255
|
pulumi.set(__self__, "value", value)
|
|
3051
3256
|
|
|
3052
|
-
@property
|
|
3257
|
+
@_builtins.property
|
|
3053
3258
|
@pulumi.getter
|
|
3054
|
-
def key(self) -> Optional[pulumi.Input[str]]:
|
|
3259
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3055
3260
|
"""
|
|
3056
3261
|
The metadata key.
|
|
3057
3262
|
"""
|
|
3058
3263
|
return pulumi.get(self, "key")
|
|
3059
3264
|
|
|
3060
3265
|
@key.setter
|
|
3061
|
-
def key(self, value: Optional[pulumi.Input[str]]):
|
|
3266
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3062
3267
|
pulumi.set(self, "key", value)
|
|
3063
3268
|
|
|
3064
|
-
@property
|
|
3269
|
+
@_builtins.property
|
|
3065
3270
|
@pulumi.getter
|
|
3066
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
3271
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3067
3272
|
"""
|
|
3068
3273
|
The metadata value.
|
|
3069
3274
|
"""
|
|
3070
3275
|
return pulumi.get(self, "value")
|
|
3071
3276
|
|
|
3072
3277
|
@value.setter
|
|
3073
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
3278
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3074
3279
|
pulumi.set(self, "value", value)
|
|
3075
3280
|
|
|
3076
3281
|
|
|
3077
3282
|
if not MYPY:
|
|
3078
3283
|
class OceanLaunchSpecNetworkInterfaceArgsDict(TypedDict):
|
|
3079
|
-
network: pulumi.Input[str]
|
|
3284
|
+
network: pulumi.Input[_builtins.str]
|
|
3080
3285
|
"""
|
|
3081
3286
|
The name of the network.
|
|
3082
3287
|
"""
|
|
@@ -3088,7 +3293,7 @@ if not MYPY:
|
|
|
3088
3293
|
"""
|
|
3089
3294
|
use the imported node pool’s associated aliasIpRange to assign secondary IP addresses to the nodes. Cannot be changed after VNG creation.
|
|
3090
3295
|
"""
|
|
3091
|
-
project_id: NotRequired[pulumi.Input[str]]
|
|
3296
|
+
project_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
3092
3297
|
"""
|
|
3093
3298
|
Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
|
|
3094
3299
|
"""
|
|
@@ -3098,15 +3303,15 @@ elif False:
|
|
|
3098
3303
|
@pulumi.input_type
|
|
3099
3304
|
class OceanLaunchSpecNetworkInterfaceArgs:
|
|
3100
3305
|
def __init__(__self__, *,
|
|
3101
|
-
network: pulumi.Input[str],
|
|
3306
|
+
network: pulumi.Input[_builtins.str],
|
|
3102
3307
|
access_configs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgs']]]] = None,
|
|
3103
3308
|
alias_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]]] = None,
|
|
3104
|
-
project_id: Optional[pulumi.Input[str]] = None):
|
|
3309
|
+
project_id: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3105
3310
|
"""
|
|
3106
|
-
:param pulumi.Input[str] network: The name of the network.
|
|
3311
|
+
:param pulumi.Input[_builtins.str] network: The name of the network.
|
|
3107
3312
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgs']]] access_configs: The network protocol of the VNG.
|
|
3108
3313
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]] alias_ip_ranges: use the imported node pool’s associated aliasIpRange to assign secondary IP addresses to the nodes. Cannot be changed after VNG creation.
|
|
3109
|
-
:param pulumi.Input[str] project_id: Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
|
|
3314
|
+
:param pulumi.Input[_builtins.str] project_id: Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
|
|
3110
3315
|
"""
|
|
3111
3316
|
pulumi.set(__self__, "network", network)
|
|
3112
3317
|
if access_configs is not None:
|
|
@@ -3116,19 +3321,19 @@ class OceanLaunchSpecNetworkInterfaceArgs:
|
|
|
3116
3321
|
if project_id is not None:
|
|
3117
3322
|
pulumi.set(__self__, "project_id", project_id)
|
|
3118
3323
|
|
|
3119
|
-
@property
|
|
3324
|
+
@_builtins.property
|
|
3120
3325
|
@pulumi.getter
|
|
3121
|
-
def network(self) -> pulumi.Input[str]:
|
|
3326
|
+
def network(self) -> pulumi.Input[_builtins.str]:
|
|
3122
3327
|
"""
|
|
3123
3328
|
The name of the network.
|
|
3124
3329
|
"""
|
|
3125
3330
|
return pulumi.get(self, "network")
|
|
3126
3331
|
|
|
3127
3332
|
@network.setter
|
|
3128
|
-
def network(self, value: pulumi.Input[str]):
|
|
3333
|
+
def network(self, value: pulumi.Input[_builtins.str]):
|
|
3129
3334
|
pulumi.set(self, "network", value)
|
|
3130
3335
|
|
|
3131
|
-
@property
|
|
3336
|
+
@_builtins.property
|
|
3132
3337
|
@pulumi.getter(name="accessConfigs")
|
|
3133
3338
|
def access_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgs']]]]:
|
|
3134
3339
|
"""
|
|
@@ -3140,7 +3345,7 @@ class OceanLaunchSpecNetworkInterfaceArgs:
|
|
|
3140
3345
|
def access_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAccessConfigArgs']]]]):
|
|
3141
3346
|
pulumi.set(self, "access_configs", value)
|
|
3142
3347
|
|
|
3143
|
-
@property
|
|
3348
|
+
@_builtins.property
|
|
3144
3349
|
@pulumi.getter(name="aliasIpRanges")
|
|
3145
3350
|
def alias_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]]]:
|
|
3146
3351
|
"""
|
|
@@ -3152,26 +3357,26 @@ class OceanLaunchSpecNetworkInterfaceArgs:
|
|
|
3152
3357
|
def alias_ip_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs']]]]):
|
|
3153
3358
|
pulumi.set(self, "alias_ip_ranges", value)
|
|
3154
3359
|
|
|
3155
|
-
@property
|
|
3360
|
+
@_builtins.property
|
|
3156
3361
|
@pulumi.getter(name="projectId")
|
|
3157
|
-
def project_id(self) -> Optional[pulumi.Input[str]]:
|
|
3362
|
+
def project_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3158
3363
|
"""
|
|
3159
3364
|
Use a network resource from a different project. Set the project identifier to use its network resource. This parameter is relevant only if the network resource is in a different project.
|
|
3160
3365
|
"""
|
|
3161
3366
|
return pulumi.get(self, "project_id")
|
|
3162
3367
|
|
|
3163
3368
|
@project_id.setter
|
|
3164
|
-
def project_id(self, value: Optional[pulumi.Input[str]]):
|
|
3369
|
+
def project_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3165
3370
|
pulumi.set(self, "project_id", value)
|
|
3166
3371
|
|
|
3167
3372
|
|
|
3168
3373
|
if not MYPY:
|
|
3169
3374
|
class OceanLaunchSpecNetworkInterfaceAccessConfigArgsDict(TypedDict):
|
|
3170
|
-
name: NotRequired[pulumi.Input[str]]
|
|
3375
|
+
name: NotRequired[pulumi.Input[_builtins.str]]
|
|
3171
3376
|
"""
|
|
3172
3377
|
The name of the access configuration.
|
|
3173
3378
|
"""
|
|
3174
|
-
type: NotRequired[pulumi.Input[str]]
|
|
3379
|
+
type: NotRequired[pulumi.Input[_builtins.str]]
|
|
3175
3380
|
"""
|
|
3176
3381
|
The type of the access configuration.
|
|
3177
3382
|
"""
|
|
@@ -3181,49 +3386,49 @@ elif False:
|
|
|
3181
3386
|
@pulumi.input_type
|
|
3182
3387
|
class OceanLaunchSpecNetworkInterfaceAccessConfigArgs:
|
|
3183
3388
|
def __init__(__self__, *,
|
|
3184
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
3185
|
-
type: Optional[pulumi.Input[str]] = None):
|
|
3389
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3390
|
+
type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3186
3391
|
"""
|
|
3187
|
-
:param pulumi.Input[str] name: The name of the access configuration.
|
|
3188
|
-
:param pulumi.Input[str] type: The type of the access configuration.
|
|
3392
|
+
:param pulumi.Input[_builtins.str] name: The name of the access configuration.
|
|
3393
|
+
:param pulumi.Input[_builtins.str] type: The type of the access configuration.
|
|
3189
3394
|
"""
|
|
3190
3395
|
if name is not None:
|
|
3191
3396
|
pulumi.set(__self__, "name", name)
|
|
3192
3397
|
if type is not None:
|
|
3193
3398
|
pulumi.set(__self__, "type", type)
|
|
3194
3399
|
|
|
3195
|
-
@property
|
|
3400
|
+
@_builtins.property
|
|
3196
3401
|
@pulumi.getter
|
|
3197
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
3402
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3198
3403
|
"""
|
|
3199
3404
|
The name of the access configuration.
|
|
3200
3405
|
"""
|
|
3201
3406
|
return pulumi.get(self, "name")
|
|
3202
3407
|
|
|
3203
3408
|
@name.setter
|
|
3204
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
3409
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3205
3410
|
pulumi.set(self, "name", value)
|
|
3206
3411
|
|
|
3207
|
-
@property
|
|
3412
|
+
@_builtins.property
|
|
3208
3413
|
@pulumi.getter
|
|
3209
|
-
def type(self) -> Optional[pulumi.Input[str]]:
|
|
3414
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3210
3415
|
"""
|
|
3211
3416
|
The type of the access configuration.
|
|
3212
3417
|
"""
|
|
3213
3418
|
return pulumi.get(self, "type")
|
|
3214
3419
|
|
|
3215
3420
|
@type.setter
|
|
3216
|
-
def type(self, value: Optional[pulumi.Input[str]]):
|
|
3421
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3217
3422
|
pulumi.set(self, "type", value)
|
|
3218
3423
|
|
|
3219
3424
|
|
|
3220
3425
|
if not MYPY:
|
|
3221
3426
|
class OceanLaunchSpecNetworkInterfaceAliasIpRangeArgsDict(TypedDict):
|
|
3222
|
-
ip_cidr_range: pulumi.Input[str]
|
|
3427
|
+
ip_cidr_range: pulumi.Input[_builtins.str]
|
|
3223
3428
|
"""
|
|
3224
3429
|
specify the IP address range in CIDR notation that can be used for the alias IP addresses associated with the imported node pool.
|
|
3225
3430
|
"""
|
|
3226
|
-
subnetwork_range_name: pulumi.Input[str]
|
|
3431
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]
|
|
3227
3432
|
"""
|
|
3228
3433
|
specify the IP address range for the subnet secondary IP range.
|
|
3229
3434
|
"""
|
|
@@ -3233,47 +3438,47 @@ elif False:
|
|
|
3233
3438
|
@pulumi.input_type
|
|
3234
3439
|
class OceanLaunchSpecNetworkInterfaceAliasIpRangeArgs:
|
|
3235
3440
|
def __init__(__self__, *,
|
|
3236
|
-
ip_cidr_range: pulumi.Input[str],
|
|
3237
|
-
subnetwork_range_name: pulumi.Input[str]):
|
|
3441
|
+
ip_cidr_range: pulumi.Input[_builtins.str],
|
|
3442
|
+
subnetwork_range_name: pulumi.Input[_builtins.str]):
|
|
3238
3443
|
"""
|
|
3239
|
-
:param pulumi.Input[str] ip_cidr_range: specify the IP address range in CIDR notation that can be used for the alias IP addresses associated with the imported node pool.
|
|
3240
|
-
:param pulumi.Input[str] subnetwork_range_name: specify the IP address range for the subnet secondary IP range.
|
|
3444
|
+
:param pulumi.Input[_builtins.str] ip_cidr_range: specify the IP address range in CIDR notation that can be used for the alias IP addresses associated with the imported node pool.
|
|
3445
|
+
:param pulumi.Input[_builtins.str] subnetwork_range_name: specify the IP address range for the subnet secondary IP range.
|
|
3241
3446
|
"""
|
|
3242
3447
|
pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
|
|
3243
3448
|
pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
|
|
3244
3449
|
|
|
3245
|
-
@property
|
|
3450
|
+
@_builtins.property
|
|
3246
3451
|
@pulumi.getter(name="ipCidrRange")
|
|
3247
|
-
def ip_cidr_range(self) -> pulumi.Input[str]:
|
|
3452
|
+
def ip_cidr_range(self) -> pulumi.Input[_builtins.str]:
|
|
3248
3453
|
"""
|
|
3249
3454
|
specify the IP address range in CIDR notation that can be used for the alias IP addresses associated with the imported node pool.
|
|
3250
3455
|
"""
|
|
3251
3456
|
return pulumi.get(self, "ip_cidr_range")
|
|
3252
3457
|
|
|
3253
3458
|
@ip_cidr_range.setter
|
|
3254
|
-
def ip_cidr_range(self, value: pulumi.Input[str]):
|
|
3459
|
+
def ip_cidr_range(self, value: pulumi.Input[_builtins.str]):
|
|
3255
3460
|
pulumi.set(self, "ip_cidr_range", value)
|
|
3256
3461
|
|
|
3257
|
-
@property
|
|
3462
|
+
@_builtins.property
|
|
3258
3463
|
@pulumi.getter(name="subnetworkRangeName")
|
|
3259
|
-
def subnetwork_range_name(self) -> pulumi.Input[str]:
|
|
3464
|
+
def subnetwork_range_name(self) -> pulumi.Input[_builtins.str]:
|
|
3260
3465
|
"""
|
|
3261
3466
|
specify the IP address range for the subnet secondary IP range.
|
|
3262
3467
|
"""
|
|
3263
3468
|
return pulumi.get(self, "subnetwork_range_name")
|
|
3264
3469
|
|
|
3265
3470
|
@subnetwork_range_name.setter
|
|
3266
|
-
def subnetwork_range_name(self, value: pulumi.Input[str]):
|
|
3471
|
+
def subnetwork_range_name(self, value: pulumi.Input[_builtins.str]):
|
|
3267
3472
|
pulumi.set(self, "subnetwork_range_name", value)
|
|
3268
3473
|
|
|
3269
3474
|
|
|
3270
3475
|
if not MYPY:
|
|
3271
3476
|
class OceanLaunchSpecResourceLimitsArgsDict(TypedDict):
|
|
3272
|
-
max_instance_count: NotRequired[pulumi.Input[int]]
|
|
3477
|
+
max_instance_count: NotRequired[pulumi.Input[_builtins.int]]
|
|
3273
3478
|
"""
|
|
3274
3479
|
Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3275
3480
|
"""
|
|
3276
|
-
min_instance_count: NotRequired[pulumi.Input[int]]
|
|
3481
|
+
min_instance_count: NotRequired[pulumi.Input[_builtins.int]]
|
|
3277
3482
|
"""
|
|
3278
3483
|
Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3279
3484
|
"""
|
|
@@ -3283,53 +3488,53 @@ elif False:
|
|
|
3283
3488
|
@pulumi.input_type
|
|
3284
3489
|
class OceanLaunchSpecResourceLimitsArgs:
|
|
3285
3490
|
def __init__(__self__, *,
|
|
3286
|
-
max_instance_count: Optional[pulumi.Input[int]] = None,
|
|
3287
|
-
min_instance_count: Optional[pulumi.Input[int]] = None):
|
|
3491
|
+
max_instance_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3492
|
+
min_instance_count: Optional[pulumi.Input[_builtins.int]] = None):
|
|
3288
3493
|
"""
|
|
3289
|
-
:param pulumi.Input[int] max_instance_count: Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3290
|
-
:param pulumi.Input[int] min_instance_count: Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3494
|
+
:param pulumi.Input[_builtins.int] max_instance_count: Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3495
|
+
:param pulumi.Input[_builtins.int] min_instance_count: Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3291
3496
|
"""
|
|
3292
3497
|
if max_instance_count is not None:
|
|
3293
3498
|
pulumi.set(__self__, "max_instance_count", max_instance_count)
|
|
3294
3499
|
if min_instance_count is not None:
|
|
3295
3500
|
pulumi.set(__self__, "min_instance_count", min_instance_count)
|
|
3296
3501
|
|
|
3297
|
-
@property
|
|
3502
|
+
@_builtins.property
|
|
3298
3503
|
@pulumi.getter(name="maxInstanceCount")
|
|
3299
|
-
def max_instance_count(self) -> Optional[pulumi.Input[int]]:
|
|
3504
|
+
def max_instance_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3300
3505
|
"""
|
|
3301
3506
|
Option to set a maximum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3302
3507
|
"""
|
|
3303
3508
|
return pulumi.get(self, "max_instance_count")
|
|
3304
3509
|
|
|
3305
3510
|
@max_instance_count.setter
|
|
3306
|
-
def max_instance_count(self, value: Optional[pulumi.Input[int]]):
|
|
3511
|
+
def max_instance_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3307
3512
|
pulumi.set(self, "max_instance_count", value)
|
|
3308
3513
|
|
|
3309
|
-
@property
|
|
3514
|
+
@_builtins.property
|
|
3310
3515
|
@pulumi.getter(name="minInstanceCount")
|
|
3311
|
-
def min_instance_count(self) -> Optional[pulumi.Input[int]]:
|
|
3516
|
+
def min_instance_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3312
3517
|
"""
|
|
3313
3518
|
Option to set a minimum number of instances per virtual node group. Can be null. If set, the value must be greater than or equal to 0.
|
|
3314
3519
|
"""
|
|
3315
3520
|
return pulumi.get(self, "min_instance_count")
|
|
3316
3521
|
|
|
3317
3522
|
@min_instance_count.setter
|
|
3318
|
-
def min_instance_count(self, value: Optional[pulumi.Input[int]]):
|
|
3523
|
+
def min_instance_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3319
3524
|
pulumi.set(self, "min_instance_count", value)
|
|
3320
3525
|
|
|
3321
3526
|
|
|
3322
3527
|
if not MYPY:
|
|
3323
3528
|
class OceanLaunchSpecSchedulingTaskArgsDict(TypedDict):
|
|
3324
|
-
cron_expression: pulumi.Input[str]
|
|
3529
|
+
cron_expression: pulumi.Input[_builtins.str]
|
|
3325
3530
|
"""
|
|
3326
3531
|
A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
3327
3532
|
"""
|
|
3328
|
-
is_enabled: pulumi.Input[bool]
|
|
3533
|
+
is_enabled: pulumi.Input[_builtins.bool]
|
|
3329
3534
|
"""
|
|
3330
3535
|
Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
3331
3536
|
"""
|
|
3332
|
-
task_type: pulumi.Input[str]
|
|
3537
|
+
task_type: pulumi.Input[_builtins.str]
|
|
3333
3538
|
"""
|
|
3334
3539
|
The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
3335
3540
|
"""
|
|
@@ -3343,14 +3548,14 @@ elif False:
|
|
|
3343
3548
|
@pulumi.input_type
|
|
3344
3549
|
class OceanLaunchSpecSchedulingTaskArgs:
|
|
3345
3550
|
def __init__(__self__, *,
|
|
3346
|
-
cron_expression: pulumi.Input[str],
|
|
3347
|
-
is_enabled: pulumi.Input[bool],
|
|
3348
|
-
task_type: pulumi.Input[str],
|
|
3551
|
+
cron_expression: pulumi.Input[_builtins.str],
|
|
3552
|
+
is_enabled: pulumi.Input[_builtins.bool],
|
|
3553
|
+
task_type: pulumi.Input[_builtins.str],
|
|
3349
3554
|
task_headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]]] = None):
|
|
3350
3555
|
"""
|
|
3351
|
-
:param pulumi.Input[str] cron_expression: A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
3352
|
-
:param pulumi.Input[bool] is_enabled: Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
3353
|
-
:param pulumi.Input[str] task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
3556
|
+
:param pulumi.Input[_builtins.str] cron_expression: A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
3557
|
+
:param pulumi.Input[_builtins.bool] is_enabled: Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
3558
|
+
:param pulumi.Input[_builtins.str] task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
3354
3559
|
:param pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
|
|
3355
3560
|
"""
|
|
3356
3561
|
pulumi.set(__self__, "cron_expression", cron_expression)
|
|
@@ -3359,43 +3564,43 @@ class OceanLaunchSpecSchedulingTaskArgs:
|
|
|
3359
3564
|
if task_headrooms is not None:
|
|
3360
3565
|
pulumi.set(__self__, "task_headrooms", task_headrooms)
|
|
3361
3566
|
|
|
3362
|
-
@property
|
|
3567
|
+
@_builtins.property
|
|
3363
3568
|
@pulumi.getter(name="cronExpression")
|
|
3364
|
-
def cron_expression(self) -> pulumi.Input[str]:
|
|
3569
|
+
def cron_expression(self) -> pulumi.Input[_builtins.str]:
|
|
3365
3570
|
"""
|
|
3366
3571
|
A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
|
|
3367
3572
|
"""
|
|
3368
3573
|
return pulumi.get(self, "cron_expression")
|
|
3369
3574
|
|
|
3370
3575
|
@cron_expression.setter
|
|
3371
|
-
def cron_expression(self, value: pulumi.Input[str]):
|
|
3576
|
+
def cron_expression(self, value: pulumi.Input[_builtins.str]):
|
|
3372
3577
|
pulumi.set(self, "cron_expression", value)
|
|
3373
3578
|
|
|
3374
|
-
@property
|
|
3579
|
+
@_builtins.property
|
|
3375
3580
|
@pulumi.getter(name="isEnabled")
|
|
3376
|
-
def is_enabled(self) -> pulumi.Input[bool]:
|
|
3581
|
+
def is_enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
3377
3582
|
"""
|
|
3378
3583
|
Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
|
|
3379
3584
|
"""
|
|
3380
3585
|
return pulumi.get(self, "is_enabled")
|
|
3381
3586
|
|
|
3382
3587
|
@is_enabled.setter
|
|
3383
|
-
def is_enabled(self, value: pulumi.Input[bool]):
|
|
3588
|
+
def is_enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
3384
3589
|
pulumi.set(self, "is_enabled", value)
|
|
3385
3590
|
|
|
3386
|
-
@property
|
|
3591
|
+
@_builtins.property
|
|
3387
3592
|
@pulumi.getter(name="taskType")
|
|
3388
|
-
def task_type(self) -> pulumi.Input[str]:
|
|
3593
|
+
def task_type(self) -> pulumi.Input[_builtins.str]:
|
|
3389
3594
|
"""
|
|
3390
3595
|
The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
|
|
3391
3596
|
"""
|
|
3392
3597
|
return pulumi.get(self, "task_type")
|
|
3393
3598
|
|
|
3394
3599
|
@task_type.setter
|
|
3395
|
-
def task_type(self, value: pulumi.Input[str]):
|
|
3600
|
+
def task_type(self, value: pulumi.Input[_builtins.str]):
|
|
3396
3601
|
pulumi.set(self, "task_type", value)
|
|
3397
3602
|
|
|
3398
|
-
@property
|
|
3603
|
+
@_builtins.property
|
|
3399
3604
|
@pulumi.getter(name="taskHeadrooms")
|
|
3400
3605
|
def task_headrooms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs']]]]:
|
|
3401
3606
|
"""
|
|
@@ -3410,19 +3615,19 @@ class OceanLaunchSpecSchedulingTaskArgs:
|
|
|
3410
3615
|
|
|
3411
3616
|
if not MYPY:
|
|
3412
3617
|
class OceanLaunchSpecSchedulingTaskTaskHeadroomArgsDict(TypedDict):
|
|
3413
|
-
num_of_units: pulumi.Input[int]
|
|
3618
|
+
num_of_units: pulumi.Input[_builtins.int]
|
|
3414
3619
|
"""
|
|
3415
3620
|
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
3416
3621
|
"""
|
|
3417
|
-
cpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
3622
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
3418
3623
|
"""
|
|
3419
3624
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
3420
3625
|
"""
|
|
3421
|
-
gpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
3626
|
+
gpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
3422
3627
|
"""
|
|
3423
3628
|
Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
3424
3629
|
"""
|
|
3425
|
-
memory_per_unit: NotRequired[pulumi.Input[int]]
|
|
3630
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
3426
3631
|
"""
|
|
3427
3632
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
3428
3633
|
"""
|
|
@@ -3432,15 +3637,15 @@ elif False:
|
|
|
3432
3637
|
@pulumi.input_type
|
|
3433
3638
|
class OceanLaunchSpecSchedulingTaskTaskHeadroomArgs:
|
|
3434
3639
|
def __init__(__self__, *,
|
|
3435
|
-
num_of_units: pulumi.Input[int],
|
|
3436
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
3437
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
3438
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None):
|
|
3640
|
+
num_of_units: pulumi.Input[_builtins.int],
|
|
3641
|
+
cpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3642
|
+
gpu_per_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3643
|
+
memory_per_unit: Optional[pulumi.Input[_builtins.int]] = None):
|
|
3439
3644
|
"""
|
|
3440
|
-
:param pulumi.Input[int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
3441
|
-
:param pulumi.Input[int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
3442
|
-
:param pulumi.Input[int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
3443
|
-
:param pulumi.Input[int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
3645
|
+
:param pulumi.Input[_builtins.int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
3646
|
+
:param pulumi.Input[_builtins.int] cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
3647
|
+
:param pulumi.Input[_builtins.int] gpu_per_unit: Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
3648
|
+
:param pulumi.Input[_builtins.int] memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
3444
3649
|
"""
|
|
3445
3650
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
3446
3651
|
if cpu_per_unit is not None:
|
|
@@ -3450,62 +3655,62 @@ class OceanLaunchSpecSchedulingTaskTaskHeadroomArgs:
|
|
|
3450
3655
|
if memory_per_unit is not None:
|
|
3451
3656
|
pulumi.set(__self__, "memory_per_unit", memory_per_unit)
|
|
3452
3657
|
|
|
3453
|
-
@property
|
|
3658
|
+
@_builtins.property
|
|
3454
3659
|
@pulumi.getter(name="numOfUnits")
|
|
3455
|
-
def num_of_units(self) -> pulumi.Input[int]:
|
|
3660
|
+
def num_of_units(self) -> pulumi.Input[_builtins.int]:
|
|
3456
3661
|
"""
|
|
3457
3662
|
The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
|
|
3458
3663
|
"""
|
|
3459
3664
|
return pulumi.get(self, "num_of_units")
|
|
3460
3665
|
|
|
3461
3666
|
@num_of_units.setter
|
|
3462
|
-
def num_of_units(self, value: pulumi.Input[int]):
|
|
3667
|
+
def num_of_units(self, value: pulumi.Input[_builtins.int]):
|
|
3463
3668
|
pulumi.set(self, "num_of_units", value)
|
|
3464
3669
|
|
|
3465
|
-
@property
|
|
3670
|
+
@_builtins.property
|
|
3466
3671
|
@pulumi.getter(name="cpuPerUnit")
|
|
3467
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
3672
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3468
3673
|
"""
|
|
3469
3674
|
Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
3470
3675
|
"""
|
|
3471
3676
|
return pulumi.get(self, "cpu_per_unit")
|
|
3472
3677
|
|
|
3473
3678
|
@cpu_per_unit.setter
|
|
3474
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
3679
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3475
3680
|
pulumi.set(self, "cpu_per_unit", value)
|
|
3476
3681
|
|
|
3477
|
-
@property
|
|
3682
|
+
@_builtins.property
|
|
3478
3683
|
@pulumi.getter(name="gpuPerUnit")
|
|
3479
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
3684
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3480
3685
|
"""
|
|
3481
3686
|
Optionally configure the number of GPUS to allocate for each headroom unit.
|
|
3482
3687
|
"""
|
|
3483
3688
|
return pulumi.get(self, "gpu_per_unit")
|
|
3484
3689
|
|
|
3485
3690
|
@gpu_per_unit.setter
|
|
3486
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
3691
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3487
3692
|
pulumi.set(self, "gpu_per_unit", value)
|
|
3488
3693
|
|
|
3489
|
-
@property
|
|
3694
|
+
@_builtins.property
|
|
3490
3695
|
@pulumi.getter(name="memoryPerUnit")
|
|
3491
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
3696
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3492
3697
|
"""
|
|
3493
3698
|
Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
|
|
3494
3699
|
"""
|
|
3495
3700
|
return pulumi.get(self, "memory_per_unit")
|
|
3496
3701
|
|
|
3497
3702
|
@memory_per_unit.setter
|
|
3498
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
3703
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3499
3704
|
pulumi.set(self, "memory_per_unit", value)
|
|
3500
3705
|
|
|
3501
3706
|
|
|
3502
3707
|
if not MYPY:
|
|
3503
3708
|
class OceanLaunchSpecShieldedInstanceConfigArgsDict(TypedDict):
|
|
3504
|
-
enable_integrity_monitoring: NotRequired[pulumi.Input[bool]]
|
|
3709
|
+
enable_integrity_monitoring: NotRequired[pulumi.Input[_builtins.bool]]
|
|
3505
3710
|
"""
|
|
3506
3711
|
Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
3507
3712
|
"""
|
|
3508
|
-
enable_secure_boot: NotRequired[pulumi.Input[bool]]
|
|
3713
|
+
enable_secure_boot: NotRequired[pulumi.Input[_builtins.bool]]
|
|
3509
3714
|
"""
|
|
3510
3715
|
Boolean. Enable the secure boot parameter on the GCP instances.
|
|
3511
3716
|
"""
|
|
@@ -3515,45 +3720,45 @@ elif False:
|
|
|
3515
3720
|
@pulumi.input_type
|
|
3516
3721
|
class OceanLaunchSpecShieldedInstanceConfigArgs:
|
|
3517
3722
|
def __init__(__self__, *,
|
|
3518
|
-
enable_integrity_monitoring: Optional[pulumi.Input[bool]] = None,
|
|
3519
|
-
enable_secure_boot: Optional[pulumi.Input[bool]] = None):
|
|
3723
|
+
enable_integrity_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3724
|
+
enable_secure_boot: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
3520
3725
|
"""
|
|
3521
|
-
:param pulumi.Input[bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
3522
|
-
:param pulumi.Input[bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
|
|
3726
|
+
:param pulumi.Input[_builtins.bool] enable_integrity_monitoring: Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
3727
|
+
:param pulumi.Input[_builtins.bool] enable_secure_boot: Boolean. Enable the secure boot parameter on the GCP instances.
|
|
3523
3728
|
"""
|
|
3524
3729
|
if enable_integrity_monitoring is not None:
|
|
3525
3730
|
pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
|
|
3526
3731
|
if enable_secure_boot is not None:
|
|
3527
3732
|
pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
|
|
3528
3733
|
|
|
3529
|
-
@property
|
|
3734
|
+
@_builtins.property
|
|
3530
3735
|
@pulumi.getter(name="enableIntegrityMonitoring")
|
|
3531
|
-
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
3736
|
+
def enable_integrity_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
3532
3737
|
"""
|
|
3533
3738
|
Boolean. Enable the integrity monitoring parameter on the GCP instances.
|
|
3534
3739
|
"""
|
|
3535
3740
|
return pulumi.get(self, "enable_integrity_monitoring")
|
|
3536
3741
|
|
|
3537
3742
|
@enable_integrity_monitoring.setter
|
|
3538
|
-
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
3743
|
+
def enable_integrity_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
3539
3744
|
pulumi.set(self, "enable_integrity_monitoring", value)
|
|
3540
3745
|
|
|
3541
|
-
@property
|
|
3746
|
+
@_builtins.property
|
|
3542
3747
|
@pulumi.getter(name="enableSecureBoot")
|
|
3543
|
-
def enable_secure_boot(self) -> Optional[pulumi.Input[bool]]:
|
|
3748
|
+
def enable_secure_boot(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
3544
3749
|
"""
|
|
3545
3750
|
Boolean. Enable the secure boot parameter on the GCP instances.
|
|
3546
3751
|
"""
|
|
3547
3752
|
return pulumi.get(self, "enable_secure_boot")
|
|
3548
3753
|
|
|
3549
3754
|
@enable_secure_boot.setter
|
|
3550
|
-
def enable_secure_boot(self, value: Optional[pulumi.Input[bool]]):
|
|
3755
|
+
def enable_secure_boot(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
3551
3756
|
pulumi.set(self, "enable_secure_boot", value)
|
|
3552
3757
|
|
|
3553
3758
|
|
|
3554
3759
|
if not MYPY:
|
|
3555
3760
|
class OceanLaunchSpecStorageArgsDict(TypedDict):
|
|
3556
|
-
local_ssd_count: NotRequired[pulumi.Input[int]]
|
|
3761
|
+
local_ssd_count: NotRequired[pulumi.Input[_builtins.int]]
|
|
3557
3762
|
"""
|
|
3558
3763
|
Defines the number of local SSDs to be attached per node for this VNG.
|
|
3559
3764
|
"""
|
|
@@ -3563,69 +3768,89 @@ elif False:
|
|
|
3563
3768
|
@pulumi.input_type
|
|
3564
3769
|
class OceanLaunchSpecStorageArgs:
|
|
3565
3770
|
def __init__(__self__, *,
|
|
3566
|
-
local_ssd_count: Optional[pulumi.Input[int]] = None):
|
|
3771
|
+
local_ssd_count: Optional[pulumi.Input[_builtins.int]] = None):
|
|
3567
3772
|
"""
|
|
3568
|
-
:param pulumi.Input[int] local_ssd_count: Defines the number of local SSDs to be attached per node for this VNG.
|
|
3773
|
+
:param pulumi.Input[_builtins.int] local_ssd_count: Defines the number of local SSDs to be attached per node for this VNG.
|
|
3569
3774
|
"""
|
|
3570
3775
|
if local_ssd_count is not None:
|
|
3571
3776
|
pulumi.set(__self__, "local_ssd_count", local_ssd_count)
|
|
3572
3777
|
|
|
3573
|
-
@property
|
|
3778
|
+
@_builtins.property
|
|
3574
3779
|
@pulumi.getter(name="localSsdCount")
|
|
3575
|
-
def local_ssd_count(self) -> Optional[pulumi.Input[int]]:
|
|
3780
|
+
def local_ssd_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3576
3781
|
"""
|
|
3577
3782
|
Defines the number of local SSDs to be attached per node for this VNG.
|
|
3578
3783
|
"""
|
|
3579
3784
|
return pulumi.get(self, "local_ssd_count")
|
|
3580
3785
|
|
|
3581
3786
|
@local_ssd_count.setter
|
|
3582
|
-
def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
|
|
3787
|
+
def local_ssd_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3583
3788
|
pulumi.set(self, "local_ssd_count", value)
|
|
3584
3789
|
|
|
3585
3790
|
|
|
3586
3791
|
if not MYPY:
|
|
3587
3792
|
class OceanLaunchSpecStrategyArgsDict(TypedDict):
|
|
3588
|
-
preemptible_percentage: NotRequired[pulumi.Input[int]]
|
|
3793
|
+
preemptible_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
3589
3794
|
"""
|
|
3590
3795
|
Defines the desired preemptible percentage for this launch specification.
|
|
3591
3796
|
"""
|
|
3797
|
+
scaling_orientation: NotRequired[pulumi.Input[_builtins.str]]
|
|
3798
|
+
"""
|
|
3799
|
+
Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
3800
|
+
"""
|
|
3592
3801
|
elif False:
|
|
3593
3802
|
OceanLaunchSpecStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
3594
3803
|
|
|
3595
3804
|
@pulumi.input_type
|
|
3596
3805
|
class OceanLaunchSpecStrategyArgs:
|
|
3597
3806
|
def __init__(__self__, *,
|
|
3598
|
-
preemptible_percentage: Optional[pulumi.Input[int]] = None
|
|
3807
|
+
preemptible_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3808
|
+
scaling_orientation: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3599
3809
|
"""
|
|
3600
|
-
:param pulumi.Input[int] preemptible_percentage: Defines the desired preemptible percentage for this launch specification.
|
|
3810
|
+
:param pulumi.Input[_builtins.int] preemptible_percentage: Defines the desired preemptible percentage for this launch specification.
|
|
3811
|
+
:param pulumi.Input[_builtins.str] scaling_orientation: Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
3601
3812
|
"""
|
|
3602
3813
|
if preemptible_percentage is not None:
|
|
3603
3814
|
pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
|
|
3815
|
+
if scaling_orientation is not None:
|
|
3816
|
+
pulumi.set(__self__, "scaling_orientation", scaling_orientation)
|
|
3604
3817
|
|
|
3605
|
-
@property
|
|
3818
|
+
@_builtins.property
|
|
3606
3819
|
@pulumi.getter(name="preemptiblePercentage")
|
|
3607
|
-
def preemptible_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
3820
|
+
def preemptible_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3608
3821
|
"""
|
|
3609
3822
|
Defines the desired preemptible percentage for this launch specification.
|
|
3610
3823
|
"""
|
|
3611
3824
|
return pulumi.get(self, "preemptible_percentage")
|
|
3612
3825
|
|
|
3613
3826
|
@preemptible_percentage.setter
|
|
3614
|
-
def preemptible_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
3827
|
+
def preemptible_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3615
3828
|
pulumi.set(self, "preemptible_percentage", value)
|
|
3616
3829
|
|
|
3830
|
+
@_builtins.property
|
|
3831
|
+
@pulumi.getter(name="scalingOrientation")
|
|
3832
|
+
def scaling_orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3833
|
+
"""
|
|
3834
|
+
Valid Values: `"cost", "availability", "balanced"`. Set this value to control the approach that Ocean takes when launching nodes.
|
|
3835
|
+
"""
|
|
3836
|
+
return pulumi.get(self, "scaling_orientation")
|
|
3837
|
+
|
|
3838
|
+
@scaling_orientation.setter
|
|
3839
|
+
def scaling_orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3840
|
+
pulumi.set(self, "scaling_orientation", value)
|
|
3841
|
+
|
|
3617
3842
|
|
|
3618
3843
|
if not MYPY:
|
|
3619
3844
|
class OceanLaunchSpecTaintArgsDict(TypedDict):
|
|
3620
|
-
effect: NotRequired[pulumi.Input[str]]
|
|
3845
|
+
effect: NotRequired[pulumi.Input[_builtins.str]]
|
|
3621
3846
|
"""
|
|
3622
3847
|
The effect of the taint. Valid values: `"NoSchedule"`, `"PreferNoSchedule"`, `"NoExecute"`.
|
|
3623
3848
|
"""
|
|
3624
|
-
key: NotRequired[pulumi.Input[str]]
|
|
3849
|
+
key: NotRequired[pulumi.Input[_builtins.str]]
|
|
3625
3850
|
"""
|
|
3626
3851
|
The taint key.
|
|
3627
3852
|
"""
|
|
3628
|
-
value: NotRequired[pulumi.Input[str]]
|
|
3853
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
3629
3854
|
"""
|
|
3630
3855
|
The taint value.
|
|
3631
3856
|
"""
|
|
@@ -3635,13 +3860,13 @@ elif False:
|
|
|
3635
3860
|
@pulumi.input_type
|
|
3636
3861
|
class OceanLaunchSpecTaintArgs:
|
|
3637
3862
|
def __init__(__self__, *,
|
|
3638
|
-
effect: Optional[pulumi.Input[str]] = None,
|
|
3639
|
-
key: Optional[pulumi.Input[str]] = None,
|
|
3640
|
-
value: Optional[pulumi.Input[str]] = None):
|
|
3863
|
+
effect: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3864
|
+
key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3865
|
+
value: Optional[pulumi.Input[_builtins.str]] = None):
|
|
3641
3866
|
"""
|
|
3642
|
-
:param pulumi.Input[str] effect: The effect of the taint. Valid values: `"NoSchedule"`, `"PreferNoSchedule"`, `"NoExecute"`.
|
|
3643
|
-
:param pulumi.Input[str] key: The taint key.
|
|
3644
|
-
:param pulumi.Input[str] value: The taint value.
|
|
3867
|
+
:param pulumi.Input[_builtins.str] effect: The effect of the taint. Valid values: `"NoSchedule"`, `"PreferNoSchedule"`, `"NoExecute"`.
|
|
3868
|
+
:param pulumi.Input[_builtins.str] key: The taint key.
|
|
3869
|
+
:param pulumi.Input[_builtins.str] value: The taint value.
|
|
3645
3870
|
"""
|
|
3646
3871
|
if effect is not None:
|
|
3647
3872
|
pulumi.set(__self__, "effect", effect)
|
|
@@ -3650,46 +3875,46 @@ class OceanLaunchSpecTaintArgs:
|
|
|
3650
3875
|
if value is not None:
|
|
3651
3876
|
pulumi.set(__self__, "value", value)
|
|
3652
3877
|
|
|
3653
|
-
@property
|
|
3878
|
+
@_builtins.property
|
|
3654
3879
|
@pulumi.getter
|
|
3655
|
-
def effect(self) -> Optional[pulumi.Input[str]]:
|
|
3880
|
+
def effect(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3656
3881
|
"""
|
|
3657
3882
|
The effect of the taint. Valid values: `"NoSchedule"`, `"PreferNoSchedule"`, `"NoExecute"`.
|
|
3658
3883
|
"""
|
|
3659
3884
|
return pulumi.get(self, "effect")
|
|
3660
3885
|
|
|
3661
3886
|
@effect.setter
|
|
3662
|
-
def effect(self, value: Optional[pulumi.Input[str]]):
|
|
3887
|
+
def effect(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3663
3888
|
pulumi.set(self, "effect", value)
|
|
3664
3889
|
|
|
3665
|
-
@property
|
|
3890
|
+
@_builtins.property
|
|
3666
3891
|
@pulumi.getter
|
|
3667
|
-
def key(self) -> Optional[pulumi.Input[str]]:
|
|
3892
|
+
def key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3668
3893
|
"""
|
|
3669
3894
|
The taint key.
|
|
3670
3895
|
"""
|
|
3671
3896
|
return pulumi.get(self, "key")
|
|
3672
3897
|
|
|
3673
3898
|
@key.setter
|
|
3674
|
-
def key(self, value: Optional[pulumi.Input[str]]):
|
|
3899
|
+
def key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3675
3900
|
pulumi.set(self, "key", value)
|
|
3676
3901
|
|
|
3677
|
-
@property
|
|
3902
|
+
@_builtins.property
|
|
3678
3903
|
@pulumi.getter
|
|
3679
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
3904
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3680
3905
|
"""
|
|
3681
3906
|
The taint value.
|
|
3682
3907
|
"""
|
|
3683
3908
|
return pulumi.get(self, "value")
|
|
3684
3909
|
|
|
3685
3910
|
@value.setter
|
|
3686
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
3911
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3687
3912
|
pulumi.set(self, "value", value)
|
|
3688
3913
|
|
|
3689
3914
|
|
|
3690
3915
|
if not MYPY:
|
|
3691
3916
|
class OceanLaunchSpecUpdatePolicyArgsDict(TypedDict):
|
|
3692
|
-
should_roll: pulumi.Input[bool]
|
|
3917
|
+
should_roll: pulumi.Input[_builtins.bool]
|
|
3693
3918
|
"""
|
|
3694
3919
|
Enables the roll.
|
|
3695
3920
|
"""
|
|
@@ -3703,29 +3928,29 @@ elif False:
|
|
|
3703
3928
|
@pulumi.input_type
|
|
3704
3929
|
class OceanLaunchSpecUpdatePolicyArgs:
|
|
3705
3930
|
def __init__(__self__, *,
|
|
3706
|
-
should_roll: pulumi.Input[bool],
|
|
3931
|
+
should_roll: pulumi.Input[_builtins.bool],
|
|
3707
3932
|
roll_config: Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs']] = None):
|
|
3708
3933
|
"""
|
|
3709
|
-
:param pulumi.Input[bool] should_roll: Enables the roll.
|
|
3934
|
+
:param pulumi.Input[_builtins.bool] should_roll: Enables the roll.
|
|
3710
3935
|
:param pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs'] roll_config: Holds the roll configuration.
|
|
3711
3936
|
"""
|
|
3712
3937
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
3713
3938
|
if roll_config is not None:
|
|
3714
3939
|
pulumi.set(__self__, "roll_config", roll_config)
|
|
3715
3940
|
|
|
3716
|
-
@property
|
|
3941
|
+
@_builtins.property
|
|
3717
3942
|
@pulumi.getter(name="shouldRoll")
|
|
3718
|
-
def should_roll(self) -> pulumi.Input[bool]:
|
|
3943
|
+
def should_roll(self) -> pulumi.Input[_builtins.bool]:
|
|
3719
3944
|
"""
|
|
3720
3945
|
Enables the roll.
|
|
3721
3946
|
"""
|
|
3722
3947
|
return pulumi.get(self, "should_roll")
|
|
3723
3948
|
|
|
3724
3949
|
@should_roll.setter
|
|
3725
|
-
def should_roll(self, value: pulumi.Input[bool]):
|
|
3950
|
+
def should_roll(self, value: pulumi.Input[_builtins.bool]):
|
|
3726
3951
|
pulumi.set(self, "should_roll", value)
|
|
3727
3952
|
|
|
3728
|
-
@property
|
|
3953
|
+
@_builtins.property
|
|
3729
3954
|
@pulumi.getter(name="rollConfig")
|
|
3730
3955
|
def roll_config(self) -> Optional[pulumi.Input['OceanLaunchSpecUpdatePolicyRollConfigArgs']]:
|
|
3731
3956
|
"""
|
|
@@ -3740,7 +3965,7 @@ class OceanLaunchSpecUpdatePolicyArgs:
|
|
|
3740
3965
|
|
|
3741
3966
|
if not MYPY:
|
|
3742
3967
|
class OceanLaunchSpecUpdatePolicyRollConfigArgsDict(TypedDict):
|
|
3743
|
-
batch_size_percentage: pulumi.Input[int]
|
|
3968
|
+
batch_size_percentage: pulumi.Input[_builtins.int]
|
|
3744
3969
|
"""
|
|
3745
3970
|
Sets the percentage of the instances to deploy in each batch.
|
|
3746
3971
|
"""
|
|
@@ -3750,22 +3975,22 @@ elif False:
|
|
|
3750
3975
|
@pulumi.input_type
|
|
3751
3976
|
class OceanLaunchSpecUpdatePolicyRollConfigArgs:
|
|
3752
3977
|
def __init__(__self__, *,
|
|
3753
|
-
batch_size_percentage: pulumi.Input[int]):
|
|
3978
|
+
batch_size_percentage: pulumi.Input[_builtins.int]):
|
|
3754
3979
|
"""
|
|
3755
|
-
:param pulumi.Input[int] batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
|
|
3980
|
+
:param pulumi.Input[_builtins.int] batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
|
|
3756
3981
|
"""
|
|
3757
3982
|
pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
|
|
3758
3983
|
|
|
3759
|
-
@property
|
|
3984
|
+
@_builtins.property
|
|
3760
3985
|
@pulumi.getter(name="batchSizePercentage")
|
|
3761
|
-
def batch_size_percentage(self) -> pulumi.Input[int]:
|
|
3986
|
+
def batch_size_percentage(self) -> pulumi.Input[_builtins.int]:
|
|
3762
3987
|
"""
|
|
3763
3988
|
Sets the percentage of the instances to deploy in each batch.
|
|
3764
3989
|
"""
|
|
3765
3990
|
return pulumi.get(self, "batch_size_percentage")
|
|
3766
3991
|
|
|
3767
3992
|
@batch_size_percentage.setter
|
|
3768
|
-
def batch_size_percentage(self, value: pulumi.Input[int]):
|
|
3993
|
+
def batch_size_percentage(self, value: pulumi.Input[_builtins.int]):
|
|
3769
3994
|
pulumi.set(self, "batch_size_percentage", value)
|
|
3770
3995
|
|
|
3771
3996
|
|