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