pulumi-spotinst 3.117.0a1743575538__py3-none-any.whl → 3.117.0a1744266805__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.0a1743575538.dist-info → pulumi_spotinst-3.117.0a1744266805.dist-info}/METADATA +1 -1
- pulumi_spotinst-3.117.0a1744266805.dist-info/RECORD +76 -0
- pulumi_spotinst-3.117.0a1743575538.dist-info/RECORD +0 -76
- {pulumi_spotinst-3.117.0a1743575538.dist-info → pulumi_spotinst-3.117.0a1744266805.dist-info}/WHEEL +0 -0
- {pulumi_spotinst-3.117.0a1743575538.dist-info → pulumi_spotinst-3.117.0a1744266805.dist-info}/top_level.txt +0 -0
pulumi_spotinst/azure/_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
|
|
@@ -99,7 +100,7 @@ if not MYPY:
|
|
|
99
100
|
"""
|
|
100
101
|
Spare resource capacity management enabling fast assignment of pods without waiting for new resources to launch.
|
|
101
102
|
"""
|
|
102
|
-
autoscale_is_enabled: NotRequired[pulumi.Input[bool]]
|
|
103
|
+
autoscale_is_enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
103
104
|
"""
|
|
104
105
|
Enable the Ocean Kubernetes Autoscaler.
|
|
105
106
|
"""
|
|
@@ -115,12 +116,12 @@ class OceanNpAutoscalerArgs:
|
|
|
115
116
|
def __init__(__self__, *,
|
|
116
117
|
autoscale_down: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleDownArgs']] = None,
|
|
117
118
|
autoscale_headroom: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs']] = None,
|
|
118
|
-
autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
119
|
+
autoscale_is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
|
|
119
120
|
resource_limits: Optional[pulumi.Input['OceanNpAutoscalerResourceLimitsArgs']] = None):
|
|
120
121
|
"""
|
|
121
122
|
:param pulumi.Input['OceanNpAutoscalerAutoscaleDownArgs'] autoscale_down: Auto Scaling scale down operations.
|
|
122
123
|
:param pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs'] autoscale_headroom: Spare resource capacity management enabling fast assignment of pods without waiting for new resources to launch.
|
|
123
|
-
:param pulumi.Input[bool] autoscale_is_enabled: Enable the Ocean Kubernetes Autoscaler.
|
|
124
|
+
:param pulumi.Input[builtins.bool] autoscale_is_enabled: Enable the Ocean Kubernetes Autoscaler.
|
|
124
125
|
:param pulumi.Input['OceanNpAutoscalerResourceLimitsArgs'] resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
|
|
125
126
|
"""
|
|
126
127
|
if autoscale_down is not None:
|
|
@@ -158,14 +159,14 @@ class OceanNpAutoscalerArgs:
|
|
|
158
159
|
|
|
159
160
|
@property
|
|
160
161
|
@pulumi.getter(name="autoscaleIsEnabled")
|
|
161
|
-
def autoscale_is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
162
|
+
def autoscale_is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
162
163
|
"""
|
|
163
164
|
Enable the Ocean Kubernetes Autoscaler.
|
|
164
165
|
"""
|
|
165
166
|
return pulumi.get(self, "autoscale_is_enabled")
|
|
166
167
|
|
|
167
168
|
@autoscale_is_enabled.setter
|
|
168
|
-
def autoscale_is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
169
|
+
def autoscale_is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
169
170
|
pulumi.set(self, "autoscale_is_enabled", value)
|
|
170
171
|
|
|
171
172
|
@property
|
|
@@ -183,7 +184,7 @@ class OceanNpAutoscalerArgs:
|
|
|
183
184
|
|
|
184
185
|
if not MYPY:
|
|
185
186
|
class OceanNpAutoscalerAutoscaleDownArgsDict(TypedDict):
|
|
186
|
-
max_scale_down_percentage: NotRequired[pulumi.Input[int]]
|
|
187
|
+
max_scale_down_percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
187
188
|
"""
|
|
188
189
|
The maximum percentage allowed to scale down in a single scaling action.
|
|
189
190
|
"""
|
|
@@ -193,23 +194,23 @@ elif False:
|
|
|
193
194
|
@pulumi.input_type
|
|
194
195
|
class OceanNpAutoscalerAutoscaleDownArgs:
|
|
195
196
|
def __init__(__self__, *,
|
|
196
|
-
max_scale_down_percentage: Optional[pulumi.Input[int]] = None):
|
|
197
|
+
max_scale_down_percentage: Optional[pulumi.Input[builtins.int]] = None):
|
|
197
198
|
"""
|
|
198
|
-
:param pulumi.Input[int] max_scale_down_percentage: The maximum percentage allowed to scale down in a single scaling action.
|
|
199
|
+
:param pulumi.Input[builtins.int] max_scale_down_percentage: The maximum percentage allowed to scale down in a single scaling action.
|
|
199
200
|
"""
|
|
200
201
|
if max_scale_down_percentage is not None:
|
|
201
202
|
pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
|
|
202
203
|
|
|
203
204
|
@property
|
|
204
205
|
@pulumi.getter(name="maxScaleDownPercentage")
|
|
205
|
-
def max_scale_down_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
206
|
+
def max_scale_down_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
206
207
|
"""
|
|
207
208
|
The maximum percentage allowed to scale down in a single scaling action.
|
|
208
209
|
"""
|
|
209
210
|
return pulumi.get(self, "max_scale_down_percentage")
|
|
210
211
|
|
|
211
212
|
@max_scale_down_percentage.setter
|
|
212
|
-
def max_scale_down_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
213
|
+
def max_scale_down_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
213
214
|
pulumi.set(self, "max_scale_down_percentage", value)
|
|
214
215
|
|
|
215
216
|
|
|
@@ -247,11 +248,11 @@ class OceanNpAutoscalerAutoscaleHeadroomArgs:
|
|
|
247
248
|
|
|
248
249
|
if not MYPY:
|
|
249
250
|
class OceanNpAutoscalerAutoscaleHeadroomAutomaticArgsDict(TypedDict):
|
|
250
|
-
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
251
|
+
is_enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
251
252
|
"""
|
|
252
253
|
Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
|
|
253
254
|
"""
|
|
254
|
-
percentage: NotRequired[pulumi.Input[int]]
|
|
255
|
+
percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
255
256
|
"""
|
|
256
257
|
Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
|
|
257
258
|
"""
|
|
@@ -261,11 +262,11 @@ elif False:
|
|
|
261
262
|
@pulumi.input_type
|
|
262
263
|
class OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs:
|
|
263
264
|
def __init__(__self__, *,
|
|
264
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
265
|
-
percentage: Optional[pulumi.Input[int]] = None):
|
|
265
|
+
is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
|
|
266
|
+
percentage: Optional[pulumi.Input[builtins.int]] = None):
|
|
266
267
|
"""
|
|
267
|
-
:param pulumi.Input[bool] is_enabled: Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
|
|
268
|
-
:param pulumi.Input[int] percentage: Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
|
|
268
|
+
:param pulumi.Input[builtins.bool] is_enabled: Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
|
|
269
|
+
:param pulumi.Input[builtins.int] percentage: Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
|
|
269
270
|
"""
|
|
270
271
|
if is_enabled is not None:
|
|
271
272
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
@@ -274,36 +275,36 @@ class OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs:
|
|
|
274
275
|
|
|
275
276
|
@property
|
|
276
277
|
@pulumi.getter(name="isEnabled")
|
|
277
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
278
|
+
def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
278
279
|
"""
|
|
279
280
|
Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
|
|
280
281
|
"""
|
|
281
282
|
return pulumi.get(self, "is_enabled")
|
|
282
283
|
|
|
283
284
|
@is_enabled.setter
|
|
284
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
285
|
+
def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
285
286
|
pulumi.set(self, "is_enabled", value)
|
|
286
287
|
|
|
287
288
|
@property
|
|
288
289
|
@pulumi.getter
|
|
289
|
-
def percentage(self) -> Optional[pulumi.Input[int]]:
|
|
290
|
+
def percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
290
291
|
"""
|
|
291
292
|
Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
|
|
292
293
|
"""
|
|
293
294
|
return pulumi.get(self, "percentage")
|
|
294
295
|
|
|
295
296
|
@percentage.setter
|
|
296
|
-
def percentage(self, value: Optional[pulumi.Input[int]]):
|
|
297
|
+
def percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
297
298
|
pulumi.set(self, "percentage", value)
|
|
298
299
|
|
|
299
300
|
|
|
300
301
|
if not MYPY:
|
|
301
302
|
class OceanNpAutoscalerResourceLimitsArgsDict(TypedDict):
|
|
302
|
-
max_memory_gib: NotRequired[pulumi.Input[int]]
|
|
303
|
+
max_memory_gib: NotRequired[pulumi.Input[builtins.int]]
|
|
303
304
|
"""
|
|
304
305
|
The maximum memory in GiB units that can be allocated to the cluster.
|
|
305
306
|
"""
|
|
306
|
-
max_vcpu: NotRequired[pulumi.Input[int]]
|
|
307
|
+
max_vcpu: NotRequired[pulumi.Input[builtins.int]]
|
|
307
308
|
"""
|
|
308
309
|
The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
309
310
|
"""
|
|
@@ -313,11 +314,11 @@ elif False:
|
|
|
313
314
|
@pulumi.input_type
|
|
314
315
|
class OceanNpAutoscalerResourceLimitsArgs:
|
|
315
316
|
def __init__(__self__, *,
|
|
316
|
-
max_memory_gib: Optional[pulumi.Input[int]] = None,
|
|
317
|
-
max_vcpu: Optional[pulumi.Input[int]] = None):
|
|
317
|
+
max_memory_gib: Optional[pulumi.Input[builtins.int]] = None,
|
|
318
|
+
max_vcpu: Optional[pulumi.Input[builtins.int]] = None):
|
|
318
319
|
"""
|
|
319
|
-
:param pulumi.Input[int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
|
|
320
|
-
:param pulumi.Input[int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
320
|
+
:param pulumi.Input[builtins.int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
|
|
321
|
+
:param pulumi.Input[builtins.int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
321
322
|
"""
|
|
322
323
|
if max_memory_gib is not None:
|
|
323
324
|
pulumi.set(__self__, "max_memory_gib", max_memory_gib)
|
|
@@ -326,88 +327,88 @@ class OceanNpAutoscalerResourceLimitsArgs:
|
|
|
326
327
|
|
|
327
328
|
@property
|
|
328
329
|
@pulumi.getter(name="maxMemoryGib")
|
|
329
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[int]]:
|
|
330
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
330
331
|
"""
|
|
331
332
|
The maximum memory in GiB units that can be allocated to the cluster.
|
|
332
333
|
"""
|
|
333
334
|
return pulumi.get(self, "max_memory_gib")
|
|
334
335
|
|
|
335
336
|
@max_memory_gib.setter
|
|
336
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[int]]):
|
|
337
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
337
338
|
pulumi.set(self, "max_memory_gib", value)
|
|
338
339
|
|
|
339
340
|
@property
|
|
340
341
|
@pulumi.getter(name="maxVcpu")
|
|
341
|
-
def max_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
342
|
+
def max_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
342
343
|
"""
|
|
343
344
|
The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
344
345
|
"""
|
|
345
346
|
return pulumi.get(self, "max_vcpu")
|
|
346
347
|
|
|
347
348
|
@max_vcpu.setter
|
|
348
|
-
def max_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
349
|
+
def max_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
349
350
|
pulumi.set(self, "max_vcpu", value)
|
|
350
351
|
|
|
351
352
|
|
|
352
353
|
if not MYPY:
|
|
353
354
|
class OceanNpFiltersArgsDict(TypedDict):
|
|
354
|
-
accelerated_networking: NotRequired[pulumi.Input[str]]
|
|
355
|
+
accelerated_networking: NotRequired[pulumi.Input[builtins.str]]
|
|
355
356
|
"""
|
|
356
357
|
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
357
358
|
"""
|
|
358
|
-
architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
359
|
+
architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
359
360
|
"""
|
|
360
361
|
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
361
362
|
"""
|
|
362
|
-
disk_performance: NotRequired[pulumi.Input[str]]
|
|
363
|
+
disk_performance: NotRequired[pulumi.Input[builtins.str]]
|
|
363
364
|
"""
|
|
364
365
|
The filtered vm sizes will support at least one of the classes from this list.
|
|
365
366
|
"""
|
|
366
|
-
exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
367
|
+
exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
367
368
|
"""
|
|
368
369
|
Vm sizes belonging to a series from the list will not be available for scaling
|
|
369
370
|
"""
|
|
370
|
-
gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
371
|
+
gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
371
372
|
"""
|
|
372
373
|
The filtered gpu types will belong to one of the gpu types from this list.
|
|
373
374
|
"""
|
|
374
|
-
max_gpu: NotRequired[pulumi.Input[float]]
|
|
375
|
+
max_gpu: NotRequired[pulumi.Input[builtins.float]]
|
|
375
376
|
"""
|
|
376
377
|
Maximum number of GPUs available.
|
|
377
378
|
"""
|
|
378
|
-
max_memory_gib: NotRequired[pulumi.Input[float]]
|
|
379
|
+
max_memory_gib: NotRequired[pulumi.Input[builtins.float]]
|
|
379
380
|
"""
|
|
380
381
|
Maximum amount of Memory (GiB).
|
|
381
382
|
"""
|
|
382
|
-
max_vcpu: NotRequired[pulumi.Input[int]]
|
|
383
|
+
max_vcpu: NotRequired[pulumi.Input[builtins.int]]
|
|
383
384
|
"""
|
|
384
385
|
Maximum number of vcpus available.
|
|
385
386
|
"""
|
|
386
|
-
min_disk: NotRequired[pulumi.Input[int]]
|
|
387
|
+
min_disk: NotRequired[pulumi.Input[builtins.int]]
|
|
387
388
|
"""
|
|
388
389
|
Minimum number of data disks available.
|
|
389
390
|
"""
|
|
390
|
-
min_gpu: NotRequired[pulumi.Input[float]]
|
|
391
|
+
min_gpu: NotRequired[pulumi.Input[builtins.float]]
|
|
391
392
|
"""
|
|
392
393
|
Minimum number of GPUs available.
|
|
393
394
|
"""
|
|
394
|
-
min_memory_gib: NotRequired[pulumi.Input[float]]
|
|
395
|
+
min_memory_gib: NotRequired[pulumi.Input[builtins.float]]
|
|
395
396
|
"""
|
|
396
397
|
Minimum amount of Memory (GiB).
|
|
397
398
|
"""
|
|
398
|
-
min_nics: NotRequired[pulumi.Input[int]]
|
|
399
|
+
min_nics: NotRequired[pulumi.Input[builtins.int]]
|
|
399
400
|
"""
|
|
400
401
|
Minimum number of network interfaces.
|
|
401
402
|
"""
|
|
402
|
-
min_vcpu: NotRequired[pulumi.Input[int]]
|
|
403
|
+
min_vcpu: NotRequired[pulumi.Input[builtins.int]]
|
|
403
404
|
"""
|
|
404
405
|
Minimum number of vcpus available.
|
|
405
406
|
"""
|
|
406
|
-
series: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
407
|
+
series: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
407
408
|
"""
|
|
408
409
|
Vm sizes belonging to a series from the list will be available for scaling. We can specify include list and series can be specified with capital or small letters, with space, without space or with underscore '_' . For example all of these "DSv2", "Ds v2", "ds_v2" refer to same DS_v2 series.
|
|
409
410
|
"""
|
|
410
|
-
vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
411
|
+
vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
411
412
|
"""
|
|
412
413
|
The filtered vm types will belong to one of the vm types from this list.
|
|
413
414
|
"""
|
|
@@ -417,37 +418,37 @@ elif False:
|
|
|
417
418
|
@pulumi.input_type
|
|
418
419
|
class OceanNpFiltersArgs:
|
|
419
420
|
def __init__(__self__, *,
|
|
420
|
-
accelerated_networking: Optional[pulumi.Input[str]] = None,
|
|
421
|
-
architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
422
|
-
disk_performance: Optional[pulumi.Input[str]] = None,
|
|
423
|
-
exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
424
|
-
gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
425
|
-
max_gpu: Optional[pulumi.Input[float]] = None,
|
|
426
|
-
max_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
427
|
-
max_vcpu: Optional[pulumi.Input[int]] = None,
|
|
428
|
-
min_disk: Optional[pulumi.Input[int]] = None,
|
|
429
|
-
min_gpu: Optional[pulumi.Input[float]] = None,
|
|
430
|
-
min_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
431
|
-
min_nics: Optional[pulumi.Input[int]] = None,
|
|
432
|
-
min_vcpu: Optional[pulumi.Input[int]] = None,
|
|
433
|
-
series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
434
|
-
vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
435
|
-
"""
|
|
436
|
-
:param pulumi.Input[str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
437
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] architectures: The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
438
|
-
:param pulumi.Input[str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
|
|
439
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling
|
|
440
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
|
|
441
|
-
:param pulumi.Input[float] max_gpu: Maximum number of GPUs available.
|
|
442
|
-
:param pulumi.Input[float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
443
|
-
:param pulumi.Input[int] max_vcpu: Maximum number of vcpus available.
|
|
444
|
-
:param pulumi.Input[int] min_disk: Minimum number of data disks available.
|
|
445
|
-
:param pulumi.Input[float] min_gpu: Minimum number of GPUs available.
|
|
446
|
-
:param pulumi.Input[float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
447
|
-
:param pulumi.Input[int] min_nics: Minimum number of network interfaces.
|
|
448
|
-
:param pulumi.Input[int] min_vcpu: Minimum number of vcpus available.
|
|
449
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] series: Vm sizes belonging to a series from the list will be available for scaling. We can specify include list and series can be specified with capital or small letters, with space, without space or with underscore '_' . For example all of these "DSv2", "Ds v2", "ds_v2" refer to same DS_v2 series.
|
|
450
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] vm_types: The filtered vm types will belong to one of the vm types from this list.
|
|
421
|
+
accelerated_networking: Optional[pulumi.Input[builtins.str]] = None,
|
|
422
|
+
architectures: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
423
|
+
disk_performance: Optional[pulumi.Input[builtins.str]] = None,
|
|
424
|
+
exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
425
|
+
gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
426
|
+
max_gpu: Optional[pulumi.Input[builtins.float]] = None,
|
|
427
|
+
max_memory_gib: Optional[pulumi.Input[builtins.float]] = None,
|
|
428
|
+
max_vcpu: Optional[pulumi.Input[builtins.int]] = None,
|
|
429
|
+
min_disk: Optional[pulumi.Input[builtins.int]] = None,
|
|
430
|
+
min_gpu: Optional[pulumi.Input[builtins.float]] = None,
|
|
431
|
+
min_memory_gib: Optional[pulumi.Input[builtins.float]] = None,
|
|
432
|
+
min_nics: Optional[pulumi.Input[builtins.int]] = None,
|
|
433
|
+
min_vcpu: Optional[pulumi.Input[builtins.int]] = None,
|
|
434
|
+
series: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
435
|
+
vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
436
|
+
"""
|
|
437
|
+
:param pulumi.Input[builtins.str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
438
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] architectures: The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
439
|
+
:param pulumi.Input[builtins.str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
|
|
440
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling
|
|
441
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
|
|
442
|
+
:param pulumi.Input[builtins.float] max_gpu: Maximum number of GPUs available.
|
|
443
|
+
:param pulumi.Input[builtins.float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
444
|
+
:param pulumi.Input[builtins.int] max_vcpu: Maximum number of vcpus available.
|
|
445
|
+
:param pulumi.Input[builtins.int] min_disk: Minimum number of data disks available.
|
|
446
|
+
:param pulumi.Input[builtins.float] min_gpu: Minimum number of GPUs available.
|
|
447
|
+
:param pulumi.Input[builtins.float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
448
|
+
:param pulumi.Input[builtins.int] min_nics: Minimum number of network interfaces.
|
|
449
|
+
:param pulumi.Input[builtins.int] min_vcpu: Minimum number of vcpus available.
|
|
450
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] series: Vm sizes belonging to a series from the list will be available for scaling. We can specify include list and series can be specified with capital or small letters, with space, without space or with underscore '_' . For example all of these "DSv2", "Ds v2", "ds_v2" refer to same DS_v2 series.
|
|
451
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vm_types: The filtered vm types will belong to one of the vm types from this list.
|
|
451
452
|
"""
|
|
452
453
|
if accelerated_networking is not None:
|
|
453
454
|
pulumi.set(__self__, "accelerated_networking", accelerated_networking)
|
|
@@ -482,200 +483,200 @@ class OceanNpFiltersArgs:
|
|
|
482
483
|
|
|
483
484
|
@property
|
|
484
485
|
@pulumi.getter(name="acceleratedNetworking")
|
|
485
|
-
def accelerated_networking(self) -> Optional[pulumi.Input[str]]:
|
|
486
|
+
def accelerated_networking(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
486
487
|
"""
|
|
487
488
|
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
488
489
|
"""
|
|
489
490
|
return pulumi.get(self, "accelerated_networking")
|
|
490
491
|
|
|
491
492
|
@accelerated_networking.setter
|
|
492
|
-
def accelerated_networking(self, value: Optional[pulumi.Input[str]]):
|
|
493
|
+
def accelerated_networking(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
493
494
|
pulumi.set(self, "accelerated_networking", value)
|
|
494
495
|
|
|
495
496
|
@property
|
|
496
497
|
@pulumi.getter
|
|
497
|
-
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
498
|
+
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
498
499
|
"""
|
|
499
500
|
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
500
501
|
"""
|
|
501
502
|
return pulumi.get(self, "architectures")
|
|
502
503
|
|
|
503
504
|
@architectures.setter
|
|
504
|
-
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
505
|
+
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
505
506
|
pulumi.set(self, "architectures", value)
|
|
506
507
|
|
|
507
508
|
@property
|
|
508
509
|
@pulumi.getter(name="diskPerformance")
|
|
509
|
-
def disk_performance(self) -> Optional[pulumi.Input[str]]:
|
|
510
|
+
def disk_performance(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
510
511
|
"""
|
|
511
512
|
The filtered vm sizes will support at least one of the classes from this list.
|
|
512
513
|
"""
|
|
513
514
|
return pulumi.get(self, "disk_performance")
|
|
514
515
|
|
|
515
516
|
@disk_performance.setter
|
|
516
|
-
def disk_performance(self, value: Optional[pulumi.Input[str]]):
|
|
517
|
+
def disk_performance(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
517
518
|
pulumi.set(self, "disk_performance", value)
|
|
518
519
|
|
|
519
520
|
@property
|
|
520
521
|
@pulumi.getter(name="excludeSeries")
|
|
521
|
-
def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
522
|
+
def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
522
523
|
"""
|
|
523
524
|
Vm sizes belonging to a series from the list will not be available for scaling
|
|
524
525
|
"""
|
|
525
526
|
return pulumi.get(self, "exclude_series")
|
|
526
527
|
|
|
527
528
|
@exclude_series.setter
|
|
528
|
-
def exclude_series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
529
|
+
def exclude_series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
529
530
|
pulumi.set(self, "exclude_series", value)
|
|
530
531
|
|
|
531
532
|
@property
|
|
532
533
|
@pulumi.getter(name="gpuTypes")
|
|
533
|
-
def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
534
|
+
def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
534
535
|
"""
|
|
535
536
|
The filtered gpu types will belong to one of the gpu types from this list.
|
|
536
537
|
"""
|
|
537
538
|
return pulumi.get(self, "gpu_types")
|
|
538
539
|
|
|
539
540
|
@gpu_types.setter
|
|
540
|
-
def gpu_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
541
|
+
def gpu_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
541
542
|
pulumi.set(self, "gpu_types", value)
|
|
542
543
|
|
|
543
544
|
@property
|
|
544
545
|
@pulumi.getter(name="maxGpu")
|
|
545
|
-
def max_gpu(self) -> Optional[pulumi.Input[float]]:
|
|
546
|
+
def max_gpu(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
546
547
|
"""
|
|
547
548
|
Maximum number of GPUs available.
|
|
548
549
|
"""
|
|
549
550
|
return pulumi.get(self, "max_gpu")
|
|
550
551
|
|
|
551
552
|
@max_gpu.setter
|
|
552
|
-
def max_gpu(self, value: Optional[pulumi.Input[float]]):
|
|
553
|
+
def max_gpu(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
553
554
|
pulumi.set(self, "max_gpu", value)
|
|
554
555
|
|
|
555
556
|
@property
|
|
556
557
|
@pulumi.getter(name="maxMemoryGib")
|
|
557
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
558
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
558
559
|
"""
|
|
559
560
|
Maximum amount of Memory (GiB).
|
|
560
561
|
"""
|
|
561
562
|
return pulumi.get(self, "max_memory_gib")
|
|
562
563
|
|
|
563
564
|
@max_memory_gib.setter
|
|
564
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
565
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
565
566
|
pulumi.set(self, "max_memory_gib", value)
|
|
566
567
|
|
|
567
568
|
@property
|
|
568
569
|
@pulumi.getter(name="maxVcpu")
|
|
569
|
-
def max_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
570
|
+
def max_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
570
571
|
"""
|
|
571
572
|
Maximum number of vcpus available.
|
|
572
573
|
"""
|
|
573
574
|
return pulumi.get(self, "max_vcpu")
|
|
574
575
|
|
|
575
576
|
@max_vcpu.setter
|
|
576
|
-
def max_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
577
|
+
def max_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
577
578
|
pulumi.set(self, "max_vcpu", value)
|
|
578
579
|
|
|
579
580
|
@property
|
|
580
581
|
@pulumi.getter(name="minDisk")
|
|
581
|
-
def min_disk(self) -> Optional[pulumi.Input[int]]:
|
|
582
|
+
def min_disk(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
582
583
|
"""
|
|
583
584
|
Minimum number of data disks available.
|
|
584
585
|
"""
|
|
585
586
|
return pulumi.get(self, "min_disk")
|
|
586
587
|
|
|
587
588
|
@min_disk.setter
|
|
588
|
-
def min_disk(self, value: Optional[pulumi.Input[int]]):
|
|
589
|
+
def min_disk(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
589
590
|
pulumi.set(self, "min_disk", value)
|
|
590
591
|
|
|
591
592
|
@property
|
|
592
593
|
@pulumi.getter(name="minGpu")
|
|
593
|
-
def min_gpu(self) -> Optional[pulumi.Input[float]]:
|
|
594
|
+
def min_gpu(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
594
595
|
"""
|
|
595
596
|
Minimum number of GPUs available.
|
|
596
597
|
"""
|
|
597
598
|
return pulumi.get(self, "min_gpu")
|
|
598
599
|
|
|
599
600
|
@min_gpu.setter
|
|
600
|
-
def min_gpu(self, value: Optional[pulumi.Input[float]]):
|
|
601
|
+
def min_gpu(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
601
602
|
pulumi.set(self, "min_gpu", value)
|
|
602
603
|
|
|
603
604
|
@property
|
|
604
605
|
@pulumi.getter(name="minMemoryGib")
|
|
605
|
-
def min_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
606
|
+
def min_memory_gib(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
606
607
|
"""
|
|
607
608
|
Minimum amount of Memory (GiB).
|
|
608
609
|
"""
|
|
609
610
|
return pulumi.get(self, "min_memory_gib")
|
|
610
611
|
|
|
611
612
|
@min_memory_gib.setter
|
|
612
|
-
def min_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
613
|
+
def min_memory_gib(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
613
614
|
pulumi.set(self, "min_memory_gib", value)
|
|
614
615
|
|
|
615
616
|
@property
|
|
616
617
|
@pulumi.getter(name="minNics")
|
|
617
|
-
def min_nics(self) -> Optional[pulumi.Input[int]]:
|
|
618
|
+
def min_nics(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
618
619
|
"""
|
|
619
620
|
Minimum number of network interfaces.
|
|
620
621
|
"""
|
|
621
622
|
return pulumi.get(self, "min_nics")
|
|
622
623
|
|
|
623
624
|
@min_nics.setter
|
|
624
|
-
def min_nics(self, value: Optional[pulumi.Input[int]]):
|
|
625
|
+
def min_nics(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
625
626
|
pulumi.set(self, "min_nics", value)
|
|
626
627
|
|
|
627
628
|
@property
|
|
628
629
|
@pulumi.getter(name="minVcpu")
|
|
629
|
-
def min_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
630
|
+
def min_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
630
631
|
"""
|
|
631
632
|
Minimum number of vcpus available.
|
|
632
633
|
"""
|
|
633
634
|
return pulumi.get(self, "min_vcpu")
|
|
634
635
|
|
|
635
636
|
@min_vcpu.setter
|
|
636
|
-
def min_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
637
|
+
def min_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
637
638
|
pulumi.set(self, "min_vcpu", value)
|
|
638
639
|
|
|
639
640
|
@property
|
|
640
641
|
@pulumi.getter
|
|
641
|
-
def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
642
|
+
def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
642
643
|
"""
|
|
643
644
|
Vm sizes belonging to a series from the list will be available for scaling. We can specify include list and series can be specified with capital or small letters, with space, without space or with underscore '_' . For example all of these "DSv2", "Ds v2", "ds_v2" refer to same DS_v2 series.
|
|
644
645
|
"""
|
|
645
646
|
return pulumi.get(self, "series")
|
|
646
647
|
|
|
647
648
|
@series.setter
|
|
648
|
-
def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
649
|
+
def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
649
650
|
pulumi.set(self, "series", value)
|
|
650
651
|
|
|
651
652
|
@property
|
|
652
653
|
@pulumi.getter(name="vmTypes")
|
|
653
|
-
def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
654
|
+
def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
654
655
|
"""
|
|
655
656
|
The filtered vm types will belong to one of the vm types from this list.
|
|
656
657
|
"""
|
|
657
658
|
return pulumi.get(self, "vm_types")
|
|
658
659
|
|
|
659
660
|
@vm_types.setter
|
|
660
|
-
def vm_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
661
|
+
def vm_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
661
662
|
pulumi.set(self, "vm_types", value)
|
|
662
663
|
|
|
663
664
|
|
|
664
665
|
if not MYPY:
|
|
665
666
|
class OceanNpHeadroomArgsDict(TypedDict):
|
|
666
|
-
cpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
667
|
+
cpu_per_unit: NotRequired[pulumi.Input[builtins.int]]
|
|
667
668
|
"""
|
|
668
669
|
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
669
670
|
"""
|
|
670
|
-
gpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
671
|
+
gpu_per_unit: NotRequired[pulumi.Input[builtins.int]]
|
|
671
672
|
"""
|
|
672
673
|
Amount of GPU to allocate for headroom unit.
|
|
673
674
|
"""
|
|
674
|
-
memory_per_unit: NotRequired[pulumi.Input[int]]
|
|
675
|
+
memory_per_unit: NotRequired[pulumi.Input[builtins.int]]
|
|
675
676
|
"""
|
|
676
677
|
Configure the amount of memory (MiB) to allocate the headroom.
|
|
677
678
|
"""
|
|
678
|
-
num_of_units: NotRequired[pulumi.Input[int]]
|
|
679
|
+
num_of_units: NotRequired[pulumi.Input[builtins.int]]
|
|
679
680
|
"""
|
|
680
681
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
681
682
|
"""
|
|
@@ -685,15 +686,15 @@ elif False:
|
|
|
685
686
|
@pulumi.input_type
|
|
686
687
|
class OceanNpHeadroomArgs:
|
|
687
688
|
def __init__(__self__, *,
|
|
688
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
689
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
690
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None,
|
|
691
|
-
num_of_units: Optional[pulumi.Input[int]] = None):
|
|
689
|
+
cpu_per_unit: Optional[pulumi.Input[builtins.int]] = None,
|
|
690
|
+
gpu_per_unit: Optional[pulumi.Input[builtins.int]] = None,
|
|
691
|
+
memory_per_unit: Optional[pulumi.Input[builtins.int]] = None,
|
|
692
|
+
num_of_units: Optional[pulumi.Input[builtins.int]] = None):
|
|
692
693
|
"""
|
|
693
|
-
:param pulumi.Input[int] cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
694
|
-
:param pulumi.Input[int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
|
|
695
|
-
:param pulumi.Input[int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
|
|
696
|
-
: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.
|
|
694
|
+
:param pulumi.Input[builtins.int] cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
695
|
+
:param pulumi.Input[builtins.int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
|
|
696
|
+
:param pulumi.Input[builtins.int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
|
|
697
|
+
: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.
|
|
697
698
|
"""
|
|
698
699
|
if cpu_per_unit is not None:
|
|
699
700
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -706,56 +707,56 @@ class OceanNpHeadroomArgs:
|
|
|
706
707
|
|
|
707
708
|
@property
|
|
708
709
|
@pulumi.getter(name="cpuPerUnit")
|
|
709
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
710
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
710
711
|
"""
|
|
711
712
|
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
712
713
|
"""
|
|
713
714
|
return pulumi.get(self, "cpu_per_unit")
|
|
714
715
|
|
|
715
716
|
@cpu_per_unit.setter
|
|
716
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
717
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
717
718
|
pulumi.set(self, "cpu_per_unit", value)
|
|
718
719
|
|
|
719
720
|
@property
|
|
720
721
|
@pulumi.getter(name="gpuPerUnit")
|
|
721
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
722
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
722
723
|
"""
|
|
723
724
|
Amount of GPU to allocate for headroom unit.
|
|
724
725
|
"""
|
|
725
726
|
return pulumi.get(self, "gpu_per_unit")
|
|
726
727
|
|
|
727
728
|
@gpu_per_unit.setter
|
|
728
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
729
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
729
730
|
pulumi.set(self, "gpu_per_unit", value)
|
|
730
731
|
|
|
731
732
|
@property
|
|
732
733
|
@pulumi.getter(name="memoryPerUnit")
|
|
733
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
734
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
734
735
|
"""
|
|
735
736
|
Configure the amount of memory (MiB) to allocate the headroom.
|
|
736
737
|
"""
|
|
737
738
|
return pulumi.get(self, "memory_per_unit")
|
|
738
739
|
|
|
739
740
|
@memory_per_unit.setter
|
|
740
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
741
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
741
742
|
pulumi.set(self, "memory_per_unit", value)
|
|
742
743
|
|
|
743
744
|
@property
|
|
744
745
|
@pulumi.getter(name="numOfUnits")
|
|
745
|
-
def num_of_units(self) -> Optional[pulumi.Input[int]]:
|
|
746
|
+
def num_of_units(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
746
747
|
"""
|
|
747
748
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
748
749
|
"""
|
|
749
750
|
return pulumi.get(self, "num_of_units")
|
|
750
751
|
|
|
751
752
|
@num_of_units.setter
|
|
752
|
-
def num_of_units(self, value: Optional[pulumi.Input[int]]):
|
|
753
|
+
def num_of_units(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
753
754
|
pulumi.set(self, "num_of_units", value)
|
|
754
755
|
|
|
755
756
|
|
|
756
757
|
if not MYPY:
|
|
757
758
|
class OceanNpHealthArgsDict(TypedDict):
|
|
758
|
-
grace_period: NotRequired[pulumi.Input[int]]
|
|
759
|
+
grace_period: NotRequired[pulumi.Input[builtins.int]]
|
|
759
760
|
"""
|
|
760
761
|
The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
|
|
761
762
|
"""
|
|
@@ -765,23 +766,23 @@ elif False:
|
|
|
765
766
|
@pulumi.input_type
|
|
766
767
|
class OceanNpHealthArgs:
|
|
767
768
|
def __init__(__self__, *,
|
|
768
|
-
grace_period: Optional[pulumi.Input[int]] = None):
|
|
769
|
+
grace_period: Optional[pulumi.Input[builtins.int]] = None):
|
|
769
770
|
"""
|
|
770
|
-
:param pulumi.Input[int] grace_period: The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
|
|
771
|
+
:param pulumi.Input[builtins.int] grace_period: The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
|
|
771
772
|
"""
|
|
772
773
|
if grace_period is not None:
|
|
773
774
|
pulumi.set(__self__, "grace_period", grace_period)
|
|
774
775
|
|
|
775
776
|
@property
|
|
776
777
|
@pulumi.getter(name="gracePeriod")
|
|
777
|
-
def grace_period(self) -> Optional[pulumi.Input[int]]:
|
|
778
|
+
def grace_period(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
778
779
|
"""
|
|
779
780
|
The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
|
|
780
781
|
"""
|
|
781
782
|
return pulumi.get(self, "grace_period")
|
|
782
783
|
|
|
783
784
|
@grace_period.setter
|
|
784
|
-
def grace_period(self, value: Optional[pulumi.Input[int]]):
|
|
785
|
+
def grace_period(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
785
786
|
pulumi.set(self, "grace_period", value)
|
|
786
787
|
|
|
787
788
|
|
|
@@ -819,7 +820,7 @@ class OceanNpLinuxOsConfigArgs:
|
|
|
819
820
|
|
|
820
821
|
if not MYPY:
|
|
821
822
|
class OceanNpLinuxOsConfigSysctlArgsDict(TypedDict):
|
|
822
|
-
vm_max_map_count: NotRequired[pulumi.Input[int]]
|
|
823
|
+
vm_max_map_count: NotRequired[pulumi.Input[builtins.int]]
|
|
823
824
|
"""
|
|
824
825
|
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
825
826
|
"""
|
|
@@ -829,23 +830,23 @@ elif False:
|
|
|
829
830
|
@pulumi.input_type
|
|
830
831
|
class OceanNpLinuxOsConfigSysctlArgs:
|
|
831
832
|
def __init__(__self__, *,
|
|
832
|
-
vm_max_map_count: Optional[pulumi.Input[int]] = None):
|
|
833
|
+
vm_max_map_count: Optional[pulumi.Input[builtins.int]] = None):
|
|
833
834
|
"""
|
|
834
|
-
:param pulumi.Input[int] vm_max_map_count: Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
835
|
+
:param pulumi.Input[builtins.int] vm_max_map_count: Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
835
836
|
"""
|
|
836
837
|
if vm_max_map_count is not None:
|
|
837
838
|
pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
|
|
838
839
|
|
|
839
840
|
@property
|
|
840
841
|
@pulumi.getter(name="vmMaxMapCount")
|
|
841
|
-
def vm_max_map_count(self) -> Optional[pulumi.Input[int]]:
|
|
842
|
+
def vm_max_map_count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
842
843
|
"""
|
|
843
844
|
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
844
845
|
"""
|
|
845
846
|
return pulumi.get(self, "vm_max_map_count")
|
|
846
847
|
|
|
847
848
|
@vm_max_map_count.setter
|
|
848
|
-
def vm_max_map_count(self, value: Optional[pulumi.Input[int]]):
|
|
849
|
+
def vm_max_map_count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
849
850
|
pulumi.set(self, "vm_max_map_count", value)
|
|
850
851
|
|
|
851
852
|
|
|
@@ -915,7 +916,7 @@ class OceanNpLoggingExportArgs:
|
|
|
915
916
|
|
|
916
917
|
if not MYPY:
|
|
917
918
|
class OceanNpLoggingExportAzureBlobArgsDict(TypedDict):
|
|
918
|
-
id: NotRequired[pulumi.Input[str]]
|
|
919
|
+
id: NotRequired[pulumi.Input[builtins.str]]
|
|
919
920
|
"""
|
|
920
921
|
The identifier of The Azure Blob data integration to export the logs to.
|
|
921
922
|
"""
|
|
@@ -925,23 +926,23 @@ elif False:
|
|
|
925
926
|
@pulumi.input_type
|
|
926
927
|
class OceanNpLoggingExportAzureBlobArgs:
|
|
927
928
|
def __init__(__self__, *,
|
|
928
|
-
id: Optional[pulumi.Input[str]] = None):
|
|
929
|
+
id: Optional[pulumi.Input[builtins.str]] = None):
|
|
929
930
|
"""
|
|
930
|
-
:param pulumi.Input[str] id: The identifier of The Azure Blob data integration to export the logs to.
|
|
931
|
+
:param pulumi.Input[builtins.str] id: The identifier of The Azure Blob data integration to export the logs to.
|
|
931
932
|
"""
|
|
932
933
|
if id is not None:
|
|
933
934
|
pulumi.set(__self__, "id", id)
|
|
934
935
|
|
|
935
936
|
@property
|
|
936
937
|
@pulumi.getter
|
|
937
|
-
def id(self) -> Optional[pulumi.Input[str]]:
|
|
938
|
+
def id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
938
939
|
"""
|
|
939
940
|
The identifier of The Azure Blob data integration to export the logs to.
|
|
940
941
|
"""
|
|
941
942
|
return pulumi.get(self, "id")
|
|
942
943
|
|
|
943
944
|
@id.setter
|
|
944
|
-
def id(self, value: Optional[pulumi.Input[str]]):
|
|
945
|
+
def id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
945
946
|
pulumi.set(self, "id", value)
|
|
946
947
|
|
|
947
948
|
|
|
@@ -1005,8 +1006,8 @@ class OceanNpSchedulingArgs:
|
|
|
1005
1006
|
|
|
1006
1007
|
if not MYPY:
|
|
1007
1008
|
class OceanNpSchedulingShutdownHoursArgsDict(TypedDict):
|
|
1008
|
-
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
1009
|
-
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1009
|
+
is_enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
1010
|
+
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1010
1011
|
"""
|
|
1011
1012
|
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1012
1013
|
"""
|
|
@@ -1016,10 +1017,10 @@ elif False:
|
|
|
1016
1017
|
@pulumi.input_type
|
|
1017
1018
|
class OceanNpSchedulingShutdownHoursArgs:
|
|
1018
1019
|
def __init__(__self__, *,
|
|
1019
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1020
|
-
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1020
|
+
is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1021
|
+
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1021
1022
|
"""
|
|
1022
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1023
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1023
1024
|
"""
|
|
1024
1025
|
if is_enabled is not None:
|
|
1025
1026
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
@@ -1028,30 +1029,30 @@ class OceanNpSchedulingShutdownHoursArgs:
|
|
|
1028
1029
|
|
|
1029
1030
|
@property
|
|
1030
1031
|
@pulumi.getter(name="isEnabled")
|
|
1031
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1032
|
+
def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1032
1033
|
return pulumi.get(self, "is_enabled")
|
|
1033
1034
|
|
|
1034
1035
|
@is_enabled.setter
|
|
1035
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1036
|
+
def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1036
1037
|
pulumi.set(self, "is_enabled", value)
|
|
1037
1038
|
|
|
1038
1039
|
@property
|
|
1039
1040
|
@pulumi.getter(name="timeWindows")
|
|
1040
|
-
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1041
|
+
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1041
1042
|
"""
|
|
1042
1043
|
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1043
1044
|
"""
|
|
1044
1045
|
return pulumi.get(self, "time_windows")
|
|
1045
1046
|
|
|
1046
1047
|
@time_windows.setter
|
|
1047
|
-
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1048
|
+
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1048
1049
|
pulumi.set(self, "time_windows", value)
|
|
1049
1050
|
|
|
1050
1051
|
|
|
1051
1052
|
if not MYPY:
|
|
1052
1053
|
class OceanNpSchedulingSuspensionHoursArgsDict(TypedDict):
|
|
1053
|
-
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
1054
|
-
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1054
|
+
is_enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
1055
|
+
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1055
1056
|
"""
|
|
1056
1057
|
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1057
1058
|
"""
|
|
@@ -1061,10 +1062,10 @@ elif False:
|
|
|
1061
1062
|
@pulumi.input_type
|
|
1062
1063
|
class OceanNpSchedulingSuspensionHoursArgs:
|
|
1063
1064
|
def __init__(__self__, *,
|
|
1064
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
1065
|
-
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1065
|
+
is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1066
|
+
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1066
1067
|
"""
|
|
1067
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1068
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1068
1069
|
"""
|
|
1069
1070
|
if is_enabled is not None:
|
|
1070
1071
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
@@ -1073,31 +1074,31 @@ class OceanNpSchedulingSuspensionHoursArgs:
|
|
|
1073
1074
|
|
|
1074
1075
|
@property
|
|
1075
1076
|
@pulumi.getter(name="isEnabled")
|
|
1076
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1077
|
+
def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1077
1078
|
return pulumi.get(self, "is_enabled")
|
|
1078
1079
|
|
|
1079
1080
|
@is_enabled.setter
|
|
1080
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1081
|
+
def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1081
1082
|
pulumi.set(self, "is_enabled", value)
|
|
1082
1083
|
|
|
1083
1084
|
@property
|
|
1084
1085
|
@pulumi.getter(name="timeWindows")
|
|
1085
|
-
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1086
|
+
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1086
1087
|
"""
|
|
1087
1088
|
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1088
1089
|
"""
|
|
1089
1090
|
return pulumi.get(self, "time_windows")
|
|
1090
1091
|
|
|
1091
1092
|
@time_windows.setter
|
|
1092
|
-
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1093
|
+
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1093
1094
|
pulumi.set(self, "time_windows", value)
|
|
1094
1095
|
|
|
1095
1096
|
|
|
1096
1097
|
if not MYPY:
|
|
1097
1098
|
class OceanNpSchedulingTaskArgsDict(TypedDict):
|
|
1098
|
-
cron_expression: pulumi.Input[str]
|
|
1099
|
-
is_enabled: pulumi.Input[bool]
|
|
1100
|
-
task_type: pulumi.Input[str]
|
|
1099
|
+
cron_expression: pulumi.Input[builtins.str]
|
|
1100
|
+
is_enabled: pulumi.Input[builtins.bool]
|
|
1101
|
+
task_type: pulumi.Input[builtins.str]
|
|
1101
1102
|
parameters: NotRequired[pulumi.Input['OceanNpSchedulingTaskParametersArgsDict']]
|
|
1102
1103
|
elif False:
|
|
1103
1104
|
OceanNpSchedulingTaskArgsDict: TypeAlias = Mapping[str, Any]
|
|
@@ -1105,9 +1106,9 @@ elif False:
|
|
|
1105
1106
|
@pulumi.input_type
|
|
1106
1107
|
class OceanNpSchedulingTaskArgs:
|
|
1107
1108
|
def __init__(__self__, *,
|
|
1108
|
-
cron_expression: pulumi.Input[str],
|
|
1109
|
-
is_enabled: pulumi.Input[bool],
|
|
1110
|
-
task_type: pulumi.Input[str],
|
|
1109
|
+
cron_expression: pulumi.Input[builtins.str],
|
|
1110
|
+
is_enabled: pulumi.Input[builtins.bool],
|
|
1111
|
+
task_type: pulumi.Input[builtins.str],
|
|
1111
1112
|
parameters: Optional[pulumi.Input['OceanNpSchedulingTaskParametersArgs']] = None):
|
|
1112
1113
|
pulumi.set(__self__, "cron_expression", cron_expression)
|
|
1113
1114
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
@@ -1117,29 +1118,29 @@ class OceanNpSchedulingTaskArgs:
|
|
|
1117
1118
|
|
|
1118
1119
|
@property
|
|
1119
1120
|
@pulumi.getter(name="cronExpression")
|
|
1120
|
-
def cron_expression(self) -> pulumi.Input[str]:
|
|
1121
|
+
def cron_expression(self) -> pulumi.Input[builtins.str]:
|
|
1121
1122
|
return pulumi.get(self, "cron_expression")
|
|
1122
1123
|
|
|
1123
1124
|
@cron_expression.setter
|
|
1124
|
-
def cron_expression(self, value: pulumi.Input[str]):
|
|
1125
|
+
def cron_expression(self, value: pulumi.Input[builtins.str]):
|
|
1125
1126
|
pulumi.set(self, "cron_expression", value)
|
|
1126
1127
|
|
|
1127
1128
|
@property
|
|
1128
1129
|
@pulumi.getter(name="isEnabled")
|
|
1129
|
-
def is_enabled(self) -> pulumi.Input[bool]:
|
|
1130
|
+
def is_enabled(self) -> pulumi.Input[builtins.bool]:
|
|
1130
1131
|
return pulumi.get(self, "is_enabled")
|
|
1131
1132
|
|
|
1132
1133
|
@is_enabled.setter
|
|
1133
|
-
def is_enabled(self, value: pulumi.Input[bool]):
|
|
1134
|
+
def is_enabled(self, value: pulumi.Input[builtins.bool]):
|
|
1134
1135
|
pulumi.set(self, "is_enabled", value)
|
|
1135
1136
|
|
|
1136
1137
|
@property
|
|
1137
1138
|
@pulumi.getter(name="taskType")
|
|
1138
|
-
def task_type(self) -> pulumi.Input[str]:
|
|
1139
|
+
def task_type(self) -> pulumi.Input[builtins.str]:
|
|
1139
1140
|
return pulumi.get(self, "task_type")
|
|
1140
1141
|
|
|
1141
1142
|
@task_type.setter
|
|
1142
|
-
def task_type(self, value: pulumi.Input[str]):
|
|
1143
|
+
def task_type(self, value: pulumi.Input[builtins.str]):
|
|
1143
1144
|
pulumi.set(self, "task_type", value)
|
|
1144
1145
|
|
|
1145
1146
|
@property
|
|
@@ -1190,27 +1191,27 @@ class OceanNpSchedulingTaskParametersArgs:
|
|
|
1190
1191
|
|
|
1191
1192
|
if not MYPY:
|
|
1192
1193
|
class OceanNpSchedulingTaskParametersParametersClusterRollArgsDict(TypedDict):
|
|
1193
|
-
batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
|
|
1194
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
1194
1195
|
"""
|
|
1195
1196
|
Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1196
1197
|
"""
|
|
1197
|
-
batch_size_percentage: NotRequired[pulumi.Input[int]]
|
|
1198
|
+
batch_size_percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
1198
1199
|
"""
|
|
1199
1200
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
|
|
1200
1201
|
"""
|
|
1201
|
-
comment: NotRequired[pulumi.Input[str]]
|
|
1202
|
+
comment: NotRequired[pulumi.Input[builtins.str]]
|
|
1202
1203
|
"""
|
|
1203
1204
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1204
1205
|
"""
|
|
1205
|
-
respect_pdb: NotRequired[pulumi.Input[bool]]
|
|
1206
|
+
respect_pdb: NotRequired[pulumi.Input[builtins.bool]]
|
|
1206
1207
|
"""
|
|
1207
1208
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1208
1209
|
"""
|
|
1209
|
-
respect_restrict_scale_down: NotRequired[pulumi.Input[bool]]
|
|
1210
|
+
respect_restrict_scale_down: NotRequired[pulumi.Input[builtins.bool]]
|
|
1210
1211
|
"""
|
|
1211
1212
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1212
1213
|
"""
|
|
1213
|
-
vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1214
|
+
vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1214
1215
|
"""
|
|
1215
1216
|
List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
1216
1217
|
"""
|
|
@@ -1220,19 +1221,19 @@ elif False:
|
|
|
1220
1221
|
@pulumi.input_type
|
|
1221
1222
|
class OceanNpSchedulingTaskParametersParametersClusterRollArgs:
|
|
1222
1223
|
def __init__(__self__, *,
|
|
1223
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
1224
|
-
batch_size_percentage: Optional[pulumi.Input[int]] = None,
|
|
1225
|
-
comment: Optional[pulumi.Input[str]] = None,
|
|
1226
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None,
|
|
1227
|
-
respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None,
|
|
1228
|
-
vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1229
|
-
"""
|
|
1230
|
-
:param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1231
|
-
: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. In case of null as value, the default value in the backend will be 20%.
|
|
1232
|
-
:param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1233
|
-
:param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1234
|
-
:param pulumi.Input[bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1235
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
1224
|
+
batch_min_healthy_percentage: Optional[pulumi.Input[builtins.int]] = None,
|
|
1225
|
+
batch_size_percentage: Optional[pulumi.Input[builtins.int]] = None,
|
|
1226
|
+
comment: Optional[pulumi.Input[builtins.str]] = None,
|
|
1227
|
+
respect_pdb: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1228
|
+
respect_restrict_scale_down: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1229
|
+
vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1230
|
+
"""
|
|
1231
|
+
:param pulumi.Input[builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1232
|
+
: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. In case of null as value, the default value in the backend will be 20%.
|
|
1233
|
+
:param pulumi.Input[builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1234
|
+
:param pulumi.Input[builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1235
|
+
:param pulumi.Input[builtins.bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1236
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
1236
1237
|
"""
|
|
1237
1238
|
if batch_min_healthy_percentage is not None:
|
|
1238
1239
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -1249,91 +1250,91 @@ class OceanNpSchedulingTaskParametersParametersClusterRollArgs:
|
|
|
1249
1250
|
|
|
1250
1251
|
@property
|
|
1251
1252
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1252
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1253
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1253
1254
|
"""
|
|
1254
1255
|
Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1255
1256
|
"""
|
|
1256
1257
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1257
1258
|
|
|
1258
1259
|
@batch_min_healthy_percentage.setter
|
|
1259
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1260
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1260
1261
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
1261
1262
|
|
|
1262
1263
|
@property
|
|
1263
1264
|
@pulumi.getter(name="batchSizePercentage")
|
|
1264
|
-
def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1265
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1265
1266
|
"""
|
|
1266
1267
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
|
|
1267
1268
|
"""
|
|
1268
1269
|
return pulumi.get(self, "batch_size_percentage")
|
|
1269
1270
|
|
|
1270
1271
|
@batch_size_percentage.setter
|
|
1271
|
-
def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1272
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1272
1273
|
pulumi.set(self, "batch_size_percentage", value)
|
|
1273
1274
|
|
|
1274
1275
|
@property
|
|
1275
1276
|
@pulumi.getter
|
|
1276
|
-
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
1277
|
+
def comment(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1277
1278
|
"""
|
|
1278
1279
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1279
1280
|
"""
|
|
1280
1281
|
return pulumi.get(self, "comment")
|
|
1281
1282
|
|
|
1282
1283
|
@comment.setter
|
|
1283
|
-
def comment(self, value: Optional[pulumi.Input[str]]):
|
|
1284
|
+
def comment(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1284
1285
|
pulumi.set(self, "comment", value)
|
|
1285
1286
|
|
|
1286
1287
|
@property
|
|
1287
1288
|
@pulumi.getter(name="respectPdb")
|
|
1288
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
1289
|
+
def respect_pdb(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1289
1290
|
"""
|
|
1290
1291
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1291
1292
|
"""
|
|
1292
1293
|
return pulumi.get(self, "respect_pdb")
|
|
1293
1294
|
|
|
1294
1295
|
@respect_pdb.setter
|
|
1295
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
1296
|
+
def respect_pdb(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1296
1297
|
pulumi.set(self, "respect_pdb", value)
|
|
1297
1298
|
|
|
1298
1299
|
@property
|
|
1299
1300
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
1300
|
-
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
|
|
1301
|
+
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1301
1302
|
"""
|
|
1302
1303
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1303
1304
|
"""
|
|
1304
1305
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
1305
1306
|
|
|
1306
1307
|
@respect_restrict_scale_down.setter
|
|
1307
|
-
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
|
|
1308
|
+
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1308
1309
|
pulumi.set(self, "respect_restrict_scale_down", value)
|
|
1309
1310
|
|
|
1310
1311
|
@property
|
|
1311
1312
|
@pulumi.getter(name="vngIds")
|
|
1312
|
-
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1313
|
+
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1313
1314
|
"""
|
|
1314
1315
|
List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
1315
1316
|
"""
|
|
1316
1317
|
return pulumi.get(self, "vng_ids")
|
|
1317
1318
|
|
|
1318
1319
|
@vng_ids.setter
|
|
1319
|
-
def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1320
|
+
def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1320
1321
|
pulumi.set(self, "vng_ids", value)
|
|
1321
1322
|
|
|
1322
1323
|
|
|
1323
1324
|
if not MYPY:
|
|
1324
1325
|
class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgsDict(TypedDict):
|
|
1325
|
-
apply_roll: NotRequired[pulumi.Input[bool]]
|
|
1326
|
+
apply_roll: NotRequired[pulumi.Input[builtins.bool]]
|
|
1326
1327
|
roll_parameters: NotRequired[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgsDict']]
|
|
1327
|
-
scope_version: NotRequired[pulumi.Input[str]]
|
|
1328
|
+
scope_version: NotRequired[pulumi.Input[builtins.str]]
|
|
1328
1329
|
elif False:
|
|
1329
1330
|
OceanNpSchedulingTaskParametersParametersUpgradeConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
1330
1331
|
|
|
1331
1332
|
@pulumi.input_type
|
|
1332
1333
|
class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs:
|
|
1333
1334
|
def __init__(__self__, *,
|
|
1334
|
-
apply_roll: Optional[pulumi.Input[bool]] = None,
|
|
1335
|
+
apply_roll: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1335
1336
|
roll_parameters: Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs']] = None,
|
|
1336
|
-
scope_version: Optional[pulumi.Input[str]] = None):
|
|
1337
|
+
scope_version: Optional[pulumi.Input[builtins.str]] = None):
|
|
1337
1338
|
if apply_roll is not None:
|
|
1338
1339
|
pulumi.set(__self__, "apply_roll", apply_roll)
|
|
1339
1340
|
if roll_parameters is not None:
|
|
@@ -1343,11 +1344,11 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs:
|
|
|
1343
1344
|
|
|
1344
1345
|
@property
|
|
1345
1346
|
@pulumi.getter(name="applyRoll")
|
|
1346
|
-
def apply_roll(self) -> Optional[pulumi.Input[bool]]:
|
|
1347
|
+
def apply_roll(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1347
1348
|
return pulumi.get(self, "apply_roll")
|
|
1348
1349
|
|
|
1349
1350
|
@apply_roll.setter
|
|
1350
|
-
def apply_roll(self, value: Optional[pulumi.Input[bool]]):
|
|
1351
|
+
def apply_roll(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1351
1352
|
pulumi.set(self, "apply_roll", value)
|
|
1352
1353
|
|
|
1353
1354
|
@property
|
|
@@ -1361,33 +1362,33 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs:
|
|
|
1361
1362
|
|
|
1362
1363
|
@property
|
|
1363
1364
|
@pulumi.getter(name="scopeVersion")
|
|
1364
|
-
def scope_version(self) -> Optional[pulumi.Input[str]]:
|
|
1365
|
+
def scope_version(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1365
1366
|
return pulumi.get(self, "scope_version")
|
|
1366
1367
|
|
|
1367
1368
|
@scope_version.setter
|
|
1368
|
-
def scope_version(self, value: Optional[pulumi.Input[str]]):
|
|
1369
|
+
def scope_version(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1369
1370
|
pulumi.set(self, "scope_version", value)
|
|
1370
1371
|
|
|
1371
1372
|
|
|
1372
1373
|
if not MYPY:
|
|
1373
1374
|
class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgsDict(TypedDict):
|
|
1374
|
-
batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
|
|
1375
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
1375
1376
|
"""
|
|
1376
1377
|
Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1377
1378
|
"""
|
|
1378
|
-
batch_size_percentage: NotRequired[pulumi.Input[int]]
|
|
1379
|
+
batch_size_percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
1379
1380
|
"""
|
|
1380
1381
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
|
|
1381
1382
|
"""
|
|
1382
|
-
comment: NotRequired[pulumi.Input[str]]
|
|
1383
|
+
comment: NotRequired[pulumi.Input[builtins.str]]
|
|
1383
1384
|
"""
|
|
1384
1385
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1385
1386
|
"""
|
|
1386
|
-
respect_pdb: NotRequired[pulumi.Input[bool]]
|
|
1387
|
+
respect_pdb: NotRequired[pulumi.Input[builtins.bool]]
|
|
1387
1388
|
"""
|
|
1388
1389
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1389
1390
|
"""
|
|
1390
|
-
respect_restrict_scale_down: NotRequired[pulumi.Input[bool]]
|
|
1391
|
+
respect_restrict_scale_down: NotRequired[pulumi.Input[builtins.bool]]
|
|
1391
1392
|
"""
|
|
1392
1393
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1393
1394
|
"""
|
|
@@ -1397,17 +1398,17 @@ elif False:
|
|
|
1397
1398
|
@pulumi.input_type
|
|
1398
1399
|
class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs:
|
|
1399
1400
|
def __init__(__self__, *,
|
|
1400
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
1401
|
-
batch_size_percentage: Optional[pulumi.Input[int]] = None,
|
|
1402
|
-
comment: Optional[pulumi.Input[str]] = None,
|
|
1403
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None,
|
|
1404
|
-
respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None):
|
|
1405
|
-
"""
|
|
1406
|
-
:param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1407
|
-
: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. In case of null as value, the default value in the backend will be 20%.
|
|
1408
|
-
:param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1409
|
-
:param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1410
|
-
:param pulumi.Input[bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1401
|
+
batch_min_healthy_percentage: Optional[pulumi.Input[builtins.int]] = None,
|
|
1402
|
+
batch_size_percentage: Optional[pulumi.Input[builtins.int]] = None,
|
|
1403
|
+
comment: Optional[pulumi.Input[builtins.str]] = None,
|
|
1404
|
+
respect_pdb: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1405
|
+
respect_restrict_scale_down: Optional[pulumi.Input[builtins.bool]] = None):
|
|
1406
|
+
"""
|
|
1407
|
+
:param pulumi.Input[builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1408
|
+
: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. In case of null as value, the default value in the backend will be 20%.
|
|
1409
|
+
:param pulumi.Input[builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1410
|
+
:param pulumi.Input[builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1411
|
+
:param pulumi.Input[builtins.bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1411
1412
|
"""
|
|
1412
1413
|
if batch_min_healthy_percentage is not None:
|
|
1413
1414
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -1422,76 +1423,76 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs:
|
|
|
1422
1423
|
|
|
1423
1424
|
@property
|
|
1424
1425
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1425
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1426
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1426
1427
|
"""
|
|
1427
1428
|
Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1428
1429
|
"""
|
|
1429
1430
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1430
1431
|
|
|
1431
1432
|
@batch_min_healthy_percentage.setter
|
|
1432
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1433
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1433
1434
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
1434
1435
|
|
|
1435
1436
|
@property
|
|
1436
1437
|
@pulumi.getter(name="batchSizePercentage")
|
|
1437
|
-
def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1438
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1438
1439
|
"""
|
|
1439
1440
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
|
|
1440
1441
|
"""
|
|
1441
1442
|
return pulumi.get(self, "batch_size_percentage")
|
|
1442
1443
|
|
|
1443
1444
|
@batch_size_percentage.setter
|
|
1444
|
-
def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1445
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1445
1446
|
pulumi.set(self, "batch_size_percentage", value)
|
|
1446
1447
|
|
|
1447
1448
|
@property
|
|
1448
1449
|
@pulumi.getter
|
|
1449
|
-
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
1450
|
+
def comment(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1450
1451
|
"""
|
|
1451
1452
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1452
1453
|
"""
|
|
1453
1454
|
return pulumi.get(self, "comment")
|
|
1454
1455
|
|
|
1455
1456
|
@comment.setter
|
|
1456
|
-
def comment(self, value: Optional[pulumi.Input[str]]):
|
|
1457
|
+
def comment(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1457
1458
|
pulumi.set(self, "comment", value)
|
|
1458
1459
|
|
|
1459
1460
|
@property
|
|
1460
1461
|
@pulumi.getter(name="respectPdb")
|
|
1461
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
1462
|
+
def respect_pdb(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1462
1463
|
"""
|
|
1463
1464
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1464
1465
|
"""
|
|
1465
1466
|
return pulumi.get(self, "respect_pdb")
|
|
1466
1467
|
|
|
1467
1468
|
@respect_pdb.setter
|
|
1468
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
1469
|
+
def respect_pdb(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1469
1470
|
pulumi.set(self, "respect_pdb", value)
|
|
1470
1471
|
|
|
1471
1472
|
@property
|
|
1472
1473
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
1473
|
-
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
|
|
1474
|
+
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1474
1475
|
"""
|
|
1475
1476
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1476
1477
|
"""
|
|
1477
1478
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
1478
1479
|
|
|
1479
1480
|
@respect_restrict_scale_down.setter
|
|
1480
|
-
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
|
|
1481
|
+
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1481
1482
|
pulumi.set(self, "respect_restrict_scale_down", value)
|
|
1482
1483
|
|
|
1483
1484
|
|
|
1484
1485
|
if not MYPY:
|
|
1485
1486
|
class OceanNpTaintArgsDict(TypedDict):
|
|
1486
|
-
effect: pulumi.Input[str]
|
|
1487
|
+
effect: pulumi.Input[builtins.str]
|
|
1487
1488
|
"""
|
|
1488
1489
|
Set taint effect.
|
|
1489
1490
|
"""
|
|
1490
|
-
key: pulumi.Input[str]
|
|
1491
|
+
key: pulumi.Input[builtins.str]
|
|
1491
1492
|
"""
|
|
1492
1493
|
Set taint key. The following taint keys are not allowed: ["node.kubernetes.io/not-ready", "node.kubernetes.io/unreachable", "node.kubernetes.io/unschedulable", "node.kubernetes.io/memory-pressure", "node.kubernetes.io/disk-pressure", "node.kubernetes.io/network-unavailable", "node.kubernetes.io/pid-pressure", "node.kubernetes.io/out-of-service", "node.cloudprovider.kubernetes.io/uninitialized", "node.cloudprovider.kubernetes.io/shutdown", "kubernetes.azure.com/scalesetpriority"]
|
|
1493
1494
|
"""
|
|
1494
|
-
value: pulumi.Input[str]
|
|
1495
|
+
value: pulumi.Input[builtins.str]
|
|
1495
1496
|
"""
|
|
1496
1497
|
Set taint value.
|
|
1497
1498
|
"""
|
|
@@ -1501,13 +1502,13 @@ elif False:
|
|
|
1501
1502
|
@pulumi.input_type
|
|
1502
1503
|
class OceanNpTaintArgs:
|
|
1503
1504
|
def __init__(__self__, *,
|
|
1504
|
-
effect: pulumi.Input[str],
|
|
1505
|
-
key: pulumi.Input[str],
|
|
1506
|
-
value: pulumi.Input[str]):
|
|
1505
|
+
effect: pulumi.Input[builtins.str],
|
|
1506
|
+
key: pulumi.Input[builtins.str],
|
|
1507
|
+
value: pulumi.Input[builtins.str]):
|
|
1507
1508
|
"""
|
|
1508
|
-
:param pulumi.Input[str] effect: Set taint effect.
|
|
1509
|
-
:param pulumi.Input[str] key: Set taint key. The following taint keys are not allowed: ["node.kubernetes.io/not-ready", "node.kubernetes.io/unreachable", "node.kubernetes.io/unschedulable", "node.kubernetes.io/memory-pressure", "node.kubernetes.io/disk-pressure", "node.kubernetes.io/network-unavailable", "node.kubernetes.io/pid-pressure", "node.kubernetes.io/out-of-service", "node.cloudprovider.kubernetes.io/uninitialized", "node.cloudprovider.kubernetes.io/shutdown", "kubernetes.azure.com/scalesetpriority"]
|
|
1510
|
-
:param pulumi.Input[str] value: Set taint value.
|
|
1509
|
+
:param pulumi.Input[builtins.str] effect: Set taint effect.
|
|
1510
|
+
:param pulumi.Input[builtins.str] key: Set taint key. The following taint keys are not allowed: ["node.kubernetes.io/not-ready", "node.kubernetes.io/unreachable", "node.kubernetes.io/unschedulable", "node.kubernetes.io/memory-pressure", "node.kubernetes.io/disk-pressure", "node.kubernetes.io/network-unavailable", "node.kubernetes.io/pid-pressure", "node.kubernetes.io/out-of-service", "node.cloudprovider.kubernetes.io/uninitialized", "node.cloudprovider.kubernetes.io/shutdown", "kubernetes.azure.com/scalesetpriority"]
|
|
1511
|
+
:param pulumi.Input[builtins.str] value: Set taint value.
|
|
1511
1512
|
"""
|
|
1512
1513
|
pulumi.set(__self__, "effect", effect)
|
|
1513
1514
|
pulumi.set(__self__, "key", key)
|
|
@@ -1515,48 +1516,48 @@ class OceanNpTaintArgs:
|
|
|
1515
1516
|
|
|
1516
1517
|
@property
|
|
1517
1518
|
@pulumi.getter
|
|
1518
|
-
def effect(self) -> pulumi.Input[str]:
|
|
1519
|
+
def effect(self) -> pulumi.Input[builtins.str]:
|
|
1519
1520
|
"""
|
|
1520
1521
|
Set taint effect.
|
|
1521
1522
|
"""
|
|
1522
1523
|
return pulumi.get(self, "effect")
|
|
1523
1524
|
|
|
1524
1525
|
@effect.setter
|
|
1525
|
-
def effect(self, value: pulumi.Input[str]):
|
|
1526
|
+
def effect(self, value: pulumi.Input[builtins.str]):
|
|
1526
1527
|
pulumi.set(self, "effect", value)
|
|
1527
1528
|
|
|
1528
1529
|
@property
|
|
1529
1530
|
@pulumi.getter
|
|
1530
|
-
def key(self) -> pulumi.Input[str]:
|
|
1531
|
+
def key(self) -> pulumi.Input[builtins.str]:
|
|
1531
1532
|
"""
|
|
1532
1533
|
Set taint key. The following taint keys are not allowed: ["node.kubernetes.io/not-ready", "node.kubernetes.io/unreachable", "node.kubernetes.io/unschedulable", "node.kubernetes.io/memory-pressure", "node.kubernetes.io/disk-pressure", "node.kubernetes.io/network-unavailable", "node.kubernetes.io/pid-pressure", "node.kubernetes.io/out-of-service", "node.cloudprovider.kubernetes.io/uninitialized", "node.cloudprovider.kubernetes.io/shutdown", "kubernetes.azure.com/scalesetpriority"]
|
|
1533
1534
|
"""
|
|
1534
1535
|
return pulumi.get(self, "key")
|
|
1535
1536
|
|
|
1536
1537
|
@key.setter
|
|
1537
|
-
def key(self, value: pulumi.Input[str]):
|
|
1538
|
+
def key(self, value: pulumi.Input[builtins.str]):
|
|
1538
1539
|
pulumi.set(self, "key", value)
|
|
1539
1540
|
|
|
1540
1541
|
@property
|
|
1541
1542
|
@pulumi.getter
|
|
1542
|
-
def value(self) -> pulumi.Input[str]:
|
|
1543
|
+
def value(self) -> pulumi.Input[builtins.str]:
|
|
1543
1544
|
"""
|
|
1544
1545
|
Set taint value.
|
|
1545
1546
|
"""
|
|
1546
1547
|
return pulumi.get(self, "value")
|
|
1547
1548
|
|
|
1548
1549
|
@value.setter
|
|
1549
|
-
def value(self, value: pulumi.Input[str]):
|
|
1550
|
+
def value(self, value: pulumi.Input[builtins.str]):
|
|
1550
1551
|
pulumi.set(self, "value", value)
|
|
1551
1552
|
|
|
1552
1553
|
|
|
1553
1554
|
if not MYPY:
|
|
1554
1555
|
class OceanNpUpdatePolicyArgsDict(TypedDict):
|
|
1555
|
-
should_roll: pulumi.Input[bool]
|
|
1556
|
+
should_roll: pulumi.Input[builtins.bool]
|
|
1556
1557
|
"""
|
|
1557
1558
|
If set to true along with the cluster update, roll will be triggered.
|
|
1558
1559
|
"""
|
|
1559
|
-
conditioned_roll: NotRequired[pulumi.Input[bool]]
|
|
1560
|
+
conditioned_roll: NotRequired[pulumi.Input[builtins.bool]]
|
|
1560
1561
|
"""
|
|
1561
1562
|
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 availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
|
|
1562
1563
|
"""
|
|
@@ -1570,12 +1571,12 @@ elif False:
|
|
|
1570
1571
|
@pulumi.input_type
|
|
1571
1572
|
class OceanNpUpdatePolicyArgs:
|
|
1572
1573
|
def __init__(__self__, *,
|
|
1573
|
-
should_roll: pulumi.Input[bool],
|
|
1574
|
-
conditioned_roll: Optional[pulumi.Input[bool]] = None,
|
|
1574
|
+
should_roll: pulumi.Input[builtins.bool],
|
|
1575
|
+
conditioned_roll: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1575
1576
|
roll_config: Optional[pulumi.Input['OceanNpUpdatePolicyRollConfigArgs']] = None):
|
|
1576
1577
|
"""
|
|
1577
|
-
:param pulumi.Input[bool] should_roll: If set to true along with the cluster update, roll will be triggered.
|
|
1578
|
-
: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 availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
|
|
1578
|
+
:param pulumi.Input[builtins.bool] should_roll: If set to true along with the cluster update, roll will be triggered.
|
|
1579
|
+
: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 availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
|
|
1579
1580
|
:param pulumi.Input['OceanNpUpdatePolicyRollConfigArgs'] roll_config: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
1580
1581
|
"""
|
|
1581
1582
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
@@ -1586,26 +1587,26 @@ class OceanNpUpdatePolicyArgs:
|
|
|
1586
1587
|
|
|
1587
1588
|
@property
|
|
1588
1589
|
@pulumi.getter(name="shouldRoll")
|
|
1589
|
-
def should_roll(self) -> pulumi.Input[bool]:
|
|
1590
|
+
def should_roll(self) -> pulumi.Input[builtins.bool]:
|
|
1590
1591
|
"""
|
|
1591
1592
|
If set to true along with the cluster update, roll will be triggered.
|
|
1592
1593
|
"""
|
|
1593
1594
|
return pulumi.get(self, "should_roll")
|
|
1594
1595
|
|
|
1595
1596
|
@should_roll.setter
|
|
1596
|
-
def should_roll(self, value: pulumi.Input[bool]):
|
|
1597
|
+
def should_roll(self, value: pulumi.Input[builtins.bool]):
|
|
1597
1598
|
pulumi.set(self, "should_roll", value)
|
|
1598
1599
|
|
|
1599
1600
|
@property
|
|
1600
1601
|
@pulumi.getter(name="conditionedRoll")
|
|
1601
|
-
def conditioned_roll(self) -> Optional[pulumi.Input[bool]]:
|
|
1602
|
+
def conditioned_roll(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1602
1603
|
"""
|
|
1603
1604
|
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 availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
|
|
1604
1605
|
"""
|
|
1605
1606
|
return pulumi.get(self, "conditioned_roll")
|
|
1606
1607
|
|
|
1607
1608
|
@conditioned_roll.setter
|
|
1608
|
-
def conditioned_roll(self, value: Optional[pulumi.Input[bool]]):
|
|
1609
|
+
def conditioned_roll(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1609
1610
|
pulumi.set(self, "conditioned_roll", value)
|
|
1610
1611
|
|
|
1611
1612
|
@property
|
|
@@ -1623,35 +1624,35 @@ class OceanNpUpdatePolicyArgs:
|
|
|
1623
1624
|
|
|
1624
1625
|
if not MYPY:
|
|
1625
1626
|
class OceanNpUpdatePolicyRollConfigArgsDict(TypedDict):
|
|
1626
|
-
batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
|
|
1627
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
1627
1628
|
"""
|
|
1628
1629
|
Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1629
1630
|
"""
|
|
1630
|
-
batch_size_percentage: NotRequired[pulumi.Input[int]]
|
|
1631
|
+
batch_size_percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
1631
1632
|
"""
|
|
1632
1633
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
|
|
1633
1634
|
"""
|
|
1634
|
-
comment: NotRequired[pulumi.Input[str]]
|
|
1635
|
+
comment: NotRequired[pulumi.Input[builtins.str]]
|
|
1635
1636
|
"""
|
|
1636
1637
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1637
1638
|
"""
|
|
1638
|
-
node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1639
|
+
node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1639
1640
|
"""
|
|
1640
1641
|
List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
|
|
1641
1642
|
"""
|
|
1642
|
-
node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1643
|
+
node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1643
1644
|
"""
|
|
1644
1645
|
List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
|
|
1645
1646
|
"""
|
|
1646
|
-
respect_pdb: NotRequired[pulumi.Input[bool]]
|
|
1647
|
+
respect_pdb: NotRequired[pulumi.Input[builtins.bool]]
|
|
1647
1648
|
"""
|
|
1648
1649
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1649
1650
|
"""
|
|
1650
|
-
respect_restrict_scale_down: NotRequired[pulumi.Input[bool]]
|
|
1651
|
+
respect_restrict_scale_down: NotRequired[pulumi.Input[builtins.bool]]
|
|
1651
1652
|
"""
|
|
1652
1653
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1653
1654
|
"""
|
|
1654
|
-
vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1655
|
+
vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1655
1656
|
"""
|
|
1656
1657
|
List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
1657
1658
|
"""
|
|
@@ -1661,23 +1662,23 @@ elif False:
|
|
|
1661
1662
|
@pulumi.input_type
|
|
1662
1663
|
class OceanNpUpdatePolicyRollConfigArgs:
|
|
1663
1664
|
def __init__(__self__, *,
|
|
1664
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
1665
|
-
batch_size_percentage: Optional[pulumi.Input[int]] = None,
|
|
1666
|
-
comment: Optional[pulumi.Input[str]] = None,
|
|
1667
|
-
node_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1668
|
-
node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1669
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None,
|
|
1670
|
-
respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None,
|
|
1671
|
-
vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1672
|
-
"""
|
|
1673
|
-
:param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1674
|
-
: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. In case of null as value, the default value in the backend will be 20%.
|
|
1675
|
-
:param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1676
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] node_names: List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
|
|
1677
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] node_pool_names: List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
|
|
1678
|
-
:param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1679
|
-
:param pulumi.Input[bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1680
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
1665
|
+
batch_min_healthy_percentage: Optional[pulumi.Input[builtins.int]] = None,
|
|
1666
|
+
batch_size_percentage: Optional[pulumi.Input[builtins.int]] = None,
|
|
1667
|
+
comment: Optional[pulumi.Input[builtins.str]] = None,
|
|
1668
|
+
node_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1669
|
+
node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1670
|
+
respect_pdb: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1671
|
+
respect_restrict_scale_down: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1672
|
+
vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1673
|
+
"""
|
|
1674
|
+
:param pulumi.Input[builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1675
|
+
: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. In case of null as value, the default value in the backend will be 20%.
|
|
1676
|
+
:param pulumi.Input[builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1677
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_names: List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
|
|
1678
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_pool_names: List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
|
|
1679
|
+
:param pulumi.Input[builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1680
|
+
:param pulumi.Input[builtins.bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1681
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
1681
1682
|
"""
|
|
1682
1683
|
if batch_min_healthy_percentage is not None:
|
|
1683
1684
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -1698,160 +1699,160 @@ class OceanNpUpdatePolicyRollConfigArgs:
|
|
|
1698
1699
|
|
|
1699
1700
|
@property
|
|
1700
1701
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1701
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1702
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1702
1703
|
"""
|
|
1703
1704
|
Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
1704
1705
|
"""
|
|
1705
1706
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1706
1707
|
|
|
1707
1708
|
@batch_min_healthy_percentage.setter
|
|
1708
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1709
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1709
1710
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
1710
1711
|
|
|
1711
1712
|
@property
|
|
1712
1713
|
@pulumi.getter(name="batchSizePercentage")
|
|
1713
|
-
def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1714
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1714
1715
|
"""
|
|
1715
1716
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
|
|
1716
1717
|
"""
|
|
1717
1718
|
return pulumi.get(self, "batch_size_percentage")
|
|
1718
1719
|
|
|
1719
1720
|
@batch_size_percentage.setter
|
|
1720
|
-
def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1721
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1721
1722
|
pulumi.set(self, "batch_size_percentage", value)
|
|
1722
1723
|
|
|
1723
1724
|
@property
|
|
1724
1725
|
@pulumi.getter
|
|
1725
|
-
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
1726
|
+
def comment(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1726
1727
|
"""
|
|
1727
1728
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1728
1729
|
"""
|
|
1729
1730
|
return pulumi.get(self, "comment")
|
|
1730
1731
|
|
|
1731
1732
|
@comment.setter
|
|
1732
|
-
def comment(self, value: Optional[pulumi.Input[str]]):
|
|
1733
|
+
def comment(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1733
1734
|
pulumi.set(self, "comment", value)
|
|
1734
1735
|
|
|
1735
1736
|
@property
|
|
1736
1737
|
@pulumi.getter(name="nodeNames")
|
|
1737
|
-
def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1738
|
+
def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1738
1739
|
"""
|
|
1739
1740
|
List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
|
|
1740
1741
|
"""
|
|
1741
1742
|
return pulumi.get(self, "node_names")
|
|
1742
1743
|
|
|
1743
1744
|
@node_names.setter
|
|
1744
|
-
def node_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1745
|
+
def node_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1745
1746
|
pulumi.set(self, "node_names", value)
|
|
1746
1747
|
|
|
1747
1748
|
@property
|
|
1748
1749
|
@pulumi.getter(name="nodePoolNames")
|
|
1749
|
-
def node_pool_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1750
|
+
def node_pool_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1750
1751
|
"""
|
|
1751
1752
|
List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
|
|
1752
1753
|
"""
|
|
1753
1754
|
return pulumi.get(self, "node_pool_names")
|
|
1754
1755
|
|
|
1755
1756
|
@node_pool_names.setter
|
|
1756
|
-
def node_pool_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1757
|
+
def node_pool_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1757
1758
|
pulumi.set(self, "node_pool_names", value)
|
|
1758
1759
|
|
|
1759
1760
|
@property
|
|
1760
1761
|
@pulumi.getter(name="respectPdb")
|
|
1761
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
1762
|
+
def respect_pdb(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1762
1763
|
"""
|
|
1763
1764
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1764
1765
|
"""
|
|
1765
1766
|
return pulumi.get(self, "respect_pdb")
|
|
1766
1767
|
|
|
1767
1768
|
@respect_pdb.setter
|
|
1768
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
1769
|
+
def respect_pdb(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1769
1770
|
pulumi.set(self, "respect_pdb", value)
|
|
1770
1771
|
|
|
1771
1772
|
@property
|
|
1772
1773
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
1773
|
-
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
|
|
1774
|
+
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1774
1775
|
"""
|
|
1775
1776
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1776
1777
|
"""
|
|
1777
1778
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
1778
1779
|
|
|
1779
1780
|
@respect_restrict_scale_down.setter
|
|
1780
|
-
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
|
|
1781
|
+
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1781
1782
|
pulumi.set(self, "respect_restrict_scale_down", value)
|
|
1782
1783
|
|
|
1783
1784
|
@property
|
|
1784
1785
|
@pulumi.getter(name="vngIds")
|
|
1785
|
-
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1786
|
+
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1786
1787
|
"""
|
|
1787
1788
|
List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
1788
1789
|
"""
|
|
1789
1790
|
return pulumi.get(self, "vng_ids")
|
|
1790
1791
|
|
|
1791
1792
|
@vng_ids.setter
|
|
1792
|
-
def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1793
|
+
def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1793
1794
|
pulumi.set(self, "vng_ids", value)
|
|
1794
1795
|
|
|
1795
1796
|
|
|
1796
1797
|
if not MYPY:
|
|
1797
1798
|
class OceanNpVirtualNodeGroupFiltersArgsDict(TypedDict):
|
|
1798
|
-
accelerated_networking: NotRequired[pulumi.Input[str]]
|
|
1799
|
+
accelerated_networking: NotRequired[pulumi.Input[builtins.str]]
|
|
1799
1800
|
"""
|
|
1800
1801
|
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
1801
1802
|
"""
|
|
1802
|
-
architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1803
|
+
architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1803
1804
|
"""
|
|
1804
1805
|
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
1805
1806
|
"""
|
|
1806
|
-
disk_performance: NotRequired[pulumi.Input[str]]
|
|
1807
|
+
disk_performance: NotRequired[pulumi.Input[builtins.str]]
|
|
1807
1808
|
"""
|
|
1808
1809
|
The filtered vm sizes will support at least one of the classes from this list.
|
|
1809
1810
|
"""
|
|
1810
|
-
exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1811
|
+
exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1811
1812
|
"""
|
|
1812
1813
|
Vm sizes belonging to a series from the list will not be available for scaling.
|
|
1813
1814
|
"""
|
|
1814
|
-
gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1815
|
+
gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1815
1816
|
"""
|
|
1816
1817
|
The filtered gpu types will belong to one of the gpu types from this list.
|
|
1817
1818
|
"""
|
|
1818
|
-
max_gpu: NotRequired[pulumi.Input[float]]
|
|
1819
|
+
max_gpu: NotRequired[pulumi.Input[builtins.float]]
|
|
1819
1820
|
"""
|
|
1820
1821
|
Maximum number of GPUs available.
|
|
1821
1822
|
"""
|
|
1822
|
-
max_memory_gib: NotRequired[pulumi.Input[float]]
|
|
1823
|
+
max_memory_gib: NotRequired[pulumi.Input[builtins.float]]
|
|
1823
1824
|
"""
|
|
1824
1825
|
Maximum amount of Memory (GiB).
|
|
1825
1826
|
"""
|
|
1826
|
-
max_vcpu: NotRequired[pulumi.Input[int]]
|
|
1827
|
+
max_vcpu: NotRequired[pulumi.Input[builtins.int]]
|
|
1827
1828
|
"""
|
|
1828
1829
|
Maximum number of vcpus available.
|
|
1829
1830
|
"""
|
|
1830
|
-
min_disk: NotRequired[pulumi.Input[int]]
|
|
1831
|
+
min_disk: NotRequired[pulumi.Input[builtins.int]]
|
|
1831
1832
|
"""
|
|
1832
1833
|
Minimum number of data disks available.
|
|
1833
1834
|
"""
|
|
1834
|
-
min_gpu: NotRequired[pulumi.Input[float]]
|
|
1835
|
+
min_gpu: NotRequired[pulumi.Input[builtins.float]]
|
|
1835
1836
|
"""
|
|
1836
1837
|
Minimum number of GPUs available.
|
|
1837
1838
|
"""
|
|
1838
|
-
min_memory_gib: NotRequired[pulumi.Input[float]]
|
|
1839
|
+
min_memory_gib: NotRequired[pulumi.Input[builtins.float]]
|
|
1839
1840
|
"""
|
|
1840
1841
|
Minimum amount of Memory (GiB).
|
|
1841
1842
|
"""
|
|
1842
|
-
min_nics: NotRequired[pulumi.Input[int]]
|
|
1843
|
+
min_nics: NotRequired[pulumi.Input[builtins.int]]
|
|
1843
1844
|
"""
|
|
1844
1845
|
Minimum number of network interfaces.
|
|
1845
1846
|
"""
|
|
1846
|
-
min_vcpu: NotRequired[pulumi.Input[int]]
|
|
1847
|
+
min_vcpu: NotRequired[pulumi.Input[builtins.int]]
|
|
1847
1848
|
"""
|
|
1848
1849
|
Minimum number of vcpus available.
|
|
1849
1850
|
"""
|
|
1850
|
-
series: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1851
|
+
series: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1851
1852
|
"""
|
|
1852
1853
|
Vm sizes belonging to a series from the list will be available for scaling.
|
|
1853
1854
|
"""
|
|
1854
|
-
vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1855
|
+
vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
1855
1856
|
"""
|
|
1856
1857
|
The filtered vm types will belong to one of the vm types from this list.
|
|
1857
1858
|
"""
|
|
@@ -1861,37 +1862,37 @@ elif False:
|
|
|
1861
1862
|
@pulumi.input_type
|
|
1862
1863
|
class OceanNpVirtualNodeGroupFiltersArgs:
|
|
1863
1864
|
def __init__(__self__, *,
|
|
1864
|
-
accelerated_networking: Optional[pulumi.Input[str]] = None,
|
|
1865
|
-
architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1866
|
-
disk_performance: Optional[pulumi.Input[str]] = None,
|
|
1867
|
-
exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1868
|
-
gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1869
|
-
max_gpu: Optional[pulumi.Input[float]] = None,
|
|
1870
|
-
max_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
1871
|
-
max_vcpu: Optional[pulumi.Input[int]] = None,
|
|
1872
|
-
min_disk: Optional[pulumi.Input[int]] = None,
|
|
1873
|
-
min_gpu: Optional[pulumi.Input[float]] = None,
|
|
1874
|
-
min_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
1875
|
-
min_nics: Optional[pulumi.Input[int]] = None,
|
|
1876
|
-
min_vcpu: Optional[pulumi.Input[int]] = None,
|
|
1877
|
-
series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1878
|
-
vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1879
|
-
"""
|
|
1880
|
-
:param pulumi.Input[str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
1881
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] architectures: The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
1882
|
-
:param pulumi.Input[str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
|
|
1883
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling.
|
|
1884
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
|
|
1885
|
-
:param pulumi.Input[float] max_gpu: Maximum number of GPUs available.
|
|
1886
|
-
:param pulumi.Input[float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
1887
|
-
:param pulumi.Input[int] max_vcpu: Maximum number of vcpus available.
|
|
1888
|
-
:param pulumi.Input[int] min_disk: Minimum number of data disks available.
|
|
1889
|
-
:param pulumi.Input[float] min_gpu: Minimum number of GPUs available.
|
|
1890
|
-
:param pulumi.Input[float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
1891
|
-
:param pulumi.Input[int] min_nics: Minimum number of network interfaces.
|
|
1892
|
-
:param pulumi.Input[int] min_vcpu: Minimum number of vcpus available.
|
|
1893
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] series: Vm sizes belonging to a series from the list will be available for scaling.
|
|
1894
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] vm_types: The filtered vm types will belong to one of the vm types from this list.
|
|
1865
|
+
accelerated_networking: Optional[pulumi.Input[builtins.str]] = None,
|
|
1866
|
+
architectures: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1867
|
+
disk_performance: Optional[pulumi.Input[builtins.str]] = None,
|
|
1868
|
+
exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1869
|
+
gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1870
|
+
max_gpu: Optional[pulumi.Input[builtins.float]] = None,
|
|
1871
|
+
max_memory_gib: Optional[pulumi.Input[builtins.float]] = None,
|
|
1872
|
+
max_vcpu: Optional[pulumi.Input[builtins.int]] = None,
|
|
1873
|
+
min_disk: Optional[pulumi.Input[builtins.int]] = None,
|
|
1874
|
+
min_gpu: Optional[pulumi.Input[builtins.float]] = None,
|
|
1875
|
+
min_memory_gib: Optional[pulumi.Input[builtins.float]] = None,
|
|
1876
|
+
min_nics: Optional[pulumi.Input[builtins.int]] = None,
|
|
1877
|
+
min_vcpu: Optional[pulumi.Input[builtins.int]] = None,
|
|
1878
|
+
series: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1879
|
+
vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1880
|
+
"""
|
|
1881
|
+
:param pulumi.Input[builtins.str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
1882
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] architectures: The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
1883
|
+
:param pulumi.Input[builtins.str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
|
|
1884
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling.
|
|
1885
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
|
|
1886
|
+
:param pulumi.Input[builtins.float] max_gpu: Maximum number of GPUs available.
|
|
1887
|
+
:param pulumi.Input[builtins.float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
1888
|
+
:param pulumi.Input[builtins.int] max_vcpu: Maximum number of vcpus available.
|
|
1889
|
+
:param pulumi.Input[builtins.int] min_disk: Minimum number of data disks available.
|
|
1890
|
+
:param pulumi.Input[builtins.float] min_gpu: Minimum number of GPUs available.
|
|
1891
|
+
:param pulumi.Input[builtins.float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
1892
|
+
:param pulumi.Input[builtins.int] min_nics: Minimum number of network interfaces.
|
|
1893
|
+
:param pulumi.Input[builtins.int] min_vcpu: Minimum number of vcpus available.
|
|
1894
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] series: Vm sizes belonging to a series from the list will be available for scaling.
|
|
1895
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vm_types: The filtered vm types will belong to one of the vm types from this list.
|
|
1895
1896
|
"""
|
|
1896
1897
|
if accelerated_networking is not None:
|
|
1897
1898
|
pulumi.set(__self__, "accelerated_networking", accelerated_networking)
|
|
@@ -1926,200 +1927,200 @@ class OceanNpVirtualNodeGroupFiltersArgs:
|
|
|
1926
1927
|
|
|
1927
1928
|
@property
|
|
1928
1929
|
@pulumi.getter(name="acceleratedNetworking")
|
|
1929
|
-
def accelerated_networking(self) -> Optional[pulumi.Input[str]]:
|
|
1930
|
+
def accelerated_networking(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1930
1931
|
"""
|
|
1931
1932
|
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
1932
1933
|
"""
|
|
1933
1934
|
return pulumi.get(self, "accelerated_networking")
|
|
1934
1935
|
|
|
1935
1936
|
@accelerated_networking.setter
|
|
1936
|
-
def accelerated_networking(self, value: Optional[pulumi.Input[str]]):
|
|
1937
|
+
def accelerated_networking(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1937
1938
|
pulumi.set(self, "accelerated_networking", value)
|
|
1938
1939
|
|
|
1939
1940
|
@property
|
|
1940
1941
|
@pulumi.getter
|
|
1941
|
-
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1942
|
+
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1942
1943
|
"""
|
|
1943
1944
|
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
1944
1945
|
"""
|
|
1945
1946
|
return pulumi.get(self, "architectures")
|
|
1946
1947
|
|
|
1947
1948
|
@architectures.setter
|
|
1948
|
-
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1949
|
+
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1949
1950
|
pulumi.set(self, "architectures", value)
|
|
1950
1951
|
|
|
1951
1952
|
@property
|
|
1952
1953
|
@pulumi.getter(name="diskPerformance")
|
|
1953
|
-
def disk_performance(self) -> Optional[pulumi.Input[str]]:
|
|
1954
|
+
def disk_performance(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1954
1955
|
"""
|
|
1955
1956
|
The filtered vm sizes will support at least one of the classes from this list.
|
|
1956
1957
|
"""
|
|
1957
1958
|
return pulumi.get(self, "disk_performance")
|
|
1958
1959
|
|
|
1959
1960
|
@disk_performance.setter
|
|
1960
|
-
def disk_performance(self, value: Optional[pulumi.Input[str]]):
|
|
1961
|
+
def disk_performance(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1961
1962
|
pulumi.set(self, "disk_performance", value)
|
|
1962
1963
|
|
|
1963
1964
|
@property
|
|
1964
1965
|
@pulumi.getter(name="excludeSeries")
|
|
1965
|
-
def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1966
|
+
def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1966
1967
|
"""
|
|
1967
1968
|
Vm sizes belonging to a series from the list will not be available for scaling.
|
|
1968
1969
|
"""
|
|
1969
1970
|
return pulumi.get(self, "exclude_series")
|
|
1970
1971
|
|
|
1971
1972
|
@exclude_series.setter
|
|
1972
|
-
def exclude_series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1973
|
+
def exclude_series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1973
1974
|
pulumi.set(self, "exclude_series", value)
|
|
1974
1975
|
|
|
1975
1976
|
@property
|
|
1976
1977
|
@pulumi.getter(name="gpuTypes")
|
|
1977
|
-
def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1978
|
+
def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1978
1979
|
"""
|
|
1979
1980
|
The filtered gpu types will belong to one of the gpu types from this list.
|
|
1980
1981
|
"""
|
|
1981
1982
|
return pulumi.get(self, "gpu_types")
|
|
1982
1983
|
|
|
1983
1984
|
@gpu_types.setter
|
|
1984
|
-
def gpu_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1985
|
+
def gpu_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1985
1986
|
pulumi.set(self, "gpu_types", value)
|
|
1986
1987
|
|
|
1987
1988
|
@property
|
|
1988
1989
|
@pulumi.getter(name="maxGpu")
|
|
1989
|
-
def max_gpu(self) -> Optional[pulumi.Input[float]]:
|
|
1990
|
+
def max_gpu(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
1990
1991
|
"""
|
|
1991
1992
|
Maximum number of GPUs available.
|
|
1992
1993
|
"""
|
|
1993
1994
|
return pulumi.get(self, "max_gpu")
|
|
1994
1995
|
|
|
1995
1996
|
@max_gpu.setter
|
|
1996
|
-
def max_gpu(self, value: Optional[pulumi.Input[float]]):
|
|
1997
|
+
def max_gpu(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
1997
1998
|
pulumi.set(self, "max_gpu", value)
|
|
1998
1999
|
|
|
1999
2000
|
@property
|
|
2000
2001
|
@pulumi.getter(name="maxMemoryGib")
|
|
2001
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
2002
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
2002
2003
|
"""
|
|
2003
2004
|
Maximum amount of Memory (GiB).
|
|
2004
2005
|
"""
|
|
2005
2006
|
return pulumi.get(self, "max_memory_gib")
|
|
2006
2007
|
|
|
2007
2008
|
@max_memory_gib.setter
|
|
2008
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
2009
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
2009
2010
|
pulumi.set(self, "max_memory_gib", value)
|
|
2010
2011
|
|
|
2011
2012
|
@property
|
|
2012
2013
|
@pulumi.getter(name="maxVcpu")
|
|
2013
|
-
def max_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
2014
|
+
def max_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2014
2015
|
"""
|
|
2015
2016
|
Maximum number of vcpus available.
|
|
2016
2017
|
"""
|
|
2017
2018
|
return pulumi.get(self, "max_vcpu")
|
|
2018
2019
|
|
|
2019
2020
|
@max_vcpu.setter
|
|
2020
|
-
def max_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
2021
|
+
def max_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2021
2022
|
pulumi.set(self, "max_vcpu", value)
|
|
2022
2023
|
|
|
2023
2024
|
@property
|
|
2024
2025
|
@pulumi.getter(name="minDisk")
|
|
2025
|
-
def min_disk(self) -> Optional[pulumi.Input[int]]:
|
|
2026
|
+
def min_disk(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2026
2027
|
"""
|
|
2027
2028
|
Minimum number of data disks available.
|
|
2028
2029
|
"""
|
|
2029
2030
|
return pulumi.get(self, "min_disk")
|
|
2030
2031
|
|
|
2031
2032
|
@min_disk.setter
|
|
2032
|
-
def min_disk(self, value: Optional[pulumi.Input[int]]):
|
|
2033
|
+
def min_disk(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2033
2034
|
pulumi.set(self, "min_disk", value)
|
|
2034
2035
|
|
|
2035
2036
|
@property
|
|
2036
2037
|
@pulumi.getter(name="minGpu")
|
|
2037
|
-
def min_gpu(self) -> Optional[pulumi.Input[float]]:
|
|
2038
|
+
def min_gpu(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
2038
2039
|
"""
|
|
2039
2040
|
Minimum number of GPUs available.
|
|
2040
2041
|
"""
|
|
2041
2042
|
return pulumi.get(self, "min_gpu")
|
|
2042
2043
|
|
|
2043
2044
|
@min_gpu.setter
|
|
2044
|
-
def min_gpu(self, value: Optional[pulumi.Input[float]]):
|
|
2045
|
+
def min_gpu(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
2045
2046
|
pulumi.set(self, "min_gpu", value)
|
|
2046
2047
|
|
|
2047
2048
|
@property
|
|
2048
2049
|
@pulumi.getter(name="minMemoryGib")
|
|
2049
|
-
def min_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
2050
|
+
def min_memory_gib(self) -> Optional[pulumi.Input[builtins.float]]:
|
|
2050
2051
|
"""
|
|
2051
2052
|
Minimum amount of Memory (GiB).
|
|
2052
2053
|
"""
|
|
2053
2054
|
return pulumi.get(self, "min_memory_gib")
|
|
2054
2055
|
|
|
2055
2056
|
@min_memory_gib.setter
|
|
2056
|
-
def min_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
2057
|
+
def min_memory_gib(self, value: Optional[pulumi.Input[builtins.float]]):
|
|
2057
2058
|
pulumi.set(self, "min_memory_gib", value)
|
|
2058
2059
|
|
|
2059
2060
|
@property
|
|
2060
2061
|
@pulumi.getter(name="minNics")
|
|
2061
|
-
def min_nics(self) -> Optional[pulumi.Input[int]]:
|
|
2062
|
+
def min_nics(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2062
2063
|
"""
|
|
2063
2064
|
Minimum number of network interfaces.
|
|
2064
2065
|
"""
|
|
2065
2066
|
return pulumi.get(self, "min_nics")
|
|
2066
2067
|
|
|
2067
2068
|
@min_nics.setter
|
|
2068
|
-
def min_nics(self, value: Optional[pulumi.Input[int]]):
|
|
2069
|
+
def min_nics(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2069
2070
|
pulumi.set(self, "min_nics", value)
|
|
2070
2071
|
|
|
2071
2072
|
@property
|
|
2072
2073
|
@pulumi.getter(name="minVcpu")
|
|
2073
|
-
def min_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
2074
|
+
def min_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2074
2075
|
"""
|
|
2075
2076
|
Minimum number of vcpus available.
|
|
2076
2077
|
"""
|
|
2077
2078
|
return pulumi.get(self, "min_vcpu")
|
|
2078
2079
|
|
|
2079
2080
|
@min_vcpu.setter
|
|
2080
|
-
def min_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
2081
|
+
def min_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2081
2082
|
pulumi.set(self, "min_vcpu", value)
|
|
2082
2083
|
|
|
2083
2084
|
@property
|
|
2084
2085
|
@pulumi.getter
|
|
2085
|
-
def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2086
|
+
def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2086
2087
|
"""
|
|
2087
2088
|
Vm sizes belonging to a series from the list will be available for scaling.
|
|
2088
2089
|
"""
|
|
2089
2090
|
return pulumi.get(self, "series")
|
|
2090
2091
|
|
|
2091
2092
|
@series.setter
|
|
2092
|
-
def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2093
|
+
def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2093
2094
|
pulumi.set(self, "series", value)
|
|
2094
2095
|
|
|
2095
2096
|
@property
|
|
2096
2097
|
@pulumi.getter(name="vmTypes")
|
|
2097
|
-
def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2098
|
+
def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2098
2099
|
"""
|
|
2099
2100
|
The filtered vm types will belong to one of the vm types from this list.
|
|
2100
2101
|
"""
|
|
2101
2102
|
return pulumi.get(self, "vm_types")
|
|
2102
2103
|
|
|
2103
2104
|
@vm_types.setter
|
|
2104
|
-
def vm_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2105
|
+
def vm_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2105
2106
|
pulumi.set(self, "vm_types", value)
|
|
2106
2107
|
|
|
2107
2108
|
|
|
2108
2109
|
if not MYPY:
|
|
2109
2110
|
class OceanNpVirtualNodeGroupHeadroomArgsDict(TypedDict):
|
|
2110
|
-
cpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
2111
|
+
cpu_per_unit: NotRequired[pulumi.Input[builtins.int]]
|
|
2111
2112
|
"""
|
|
2112
2113
|
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2113
2114
|
"""
|
|
2114
|
-
gpu_per_unit: NotRequired[pulumi.Input[int]]
|
|
2115
|
+
gpu_per_unit: NotRequired[pulumi.Input[builtins.int]]
|
|
2115
2116
|
"""
|
|
2116
2117
|
Amount of GPU to allocate for headroom unit.
|
|
2117
2118
|
"""
|
|
2118
|
-
memory_per_unit: NotRequired[pulumi.Input[int]]
|
|
2119
|
+
memory_per_unit: NotRequired[pulumi.Input[builtins.int]]
|
|
2119
2120
|
"""
|
|
2120
2121
|
Configure the amount of memory (MiB) to allocate the headroom.
|
|
2121
2122
|
"""
|
|
2122
|
-
num_of_units: NotRequired[pulumi.Input[int]]
|
|
2123
|
+
num_of_units: NotRequired[pulumi.Input[builtins.int]]
|
|
2123
2124
|
"""
|
|
2124
2125
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
2125
2126
|
"""
|
|
@@ -2129,15 +2130,15 @@ elif False:
|
|
|
2129
2130
|
@pulumi.input_type
|
|
2130
2131
|
class OceanNpVirtualNodeGroupHeadroomArgs:
|
|
2131
2132
|
def __init__(__self__, *,
|
|
2132
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
2133
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
2134
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None,
|
|
2135
|
-
num_of_units: Optional[pulumi.Input[int]] = None):
|
|
2133
|
+
cpu_per_unit: Optional[pulumi.Input[builtins.int]] = None,
|
|
2134
|
+
gpu_per_unit: Optional[pulumi.Input[builtins.int]] = None,
|
|
2135
|
+
memory_per_unit: Optional[pulumi.Input[builtins.int]] = None,
|
|
2136
|
+
num_of_units: Optional[pulumi.Input[builtins.int]] = None):
|
|
2136
2137
|
"""
|
|
2137
|
-
:param pulumi.Input[int] cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2138
|
-
:param pulumi.Input[int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
|
|
2139
|
-
:param pulumi.Input[int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
|
|
2140
|
-
: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.
|
|
2138
|
+
:param pulumi.Input[builtins.int] cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2139
|
+
:param pulumi.Input[builtins.int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
|
|
2140
|
+
:param pulumi.Input[builtins.int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
|
|
2141
|
+
: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.
|
|
2141
2142
|
"""
|
|
2142
2143
|
if cpu_per_unit is not None:
|
|
2143
2144
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -2150,50 +2151,50 @@ class OceanNpVirtualNodeGroupHeadroomArgs:
|
|
|
2150
2151
|
|
|
2151
2152
|
@property
|
|
2152
2153
|
@pulumi.getter(name="cpuPerUnit")
|
|
2153
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2154
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2154
2155
|
"""
|
|
2155
2156
|
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2156
2157
|
"""
|
|
2157
2158
|
return pulumi.get(self, "cpu_per_unit")
|
|
2158
2159
|
|
|
2159
2160
|
@cpu_per_unit.setter
|
|
2160
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2161
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2161
2162
|
pulumi.set(self, "cpu_per_unit", value)
|
|
2162
2163
|
|
|
2163
2164
|
@property
|
|
2164
2165
|
@pulumi.getter(name="gpuPerUnit")
|
|
2165
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2166
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2166
2167
|
"""
|
|
2167
2168
|
Amount of GPU to allocate for headroom unit.
|
|
2168
2169
|
"""
|
|
2169
2170
|
return pulumi.get(self, "gpu_per_unit")
|
|
2170
2171
|
|
|
2171
2172
|
@gpu_per_unit.setter
|
|
2172
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2173
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2173
2174
|
pulumi.set(self, "gpu_per_unit", value)
|
|
2174
2175
|
|
|
2175
2176
|
@property
|
|
2176
2177
|
@pulumi.getter(name="memoryPerUnit")
|
|
2177
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2178
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2178
2179
|
"""
|
|
2179
2180
|
Configure the amount of memory (MiB) to allocate the headroom.
|
|
2180
2181
|
"""
|
|
2181
2182
|
return pulumi.get(self, "memory_per_unit")
|
|
2182
2183
|
|
|
2183
2184
|
@memory_per_unit.setter
|
|
2184
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2185
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2185
2186
|
pulumi.set(self, "memory_per_unit", value)
|
|
2186
2187
|
|
|
2187
2188
|
@property
|
|
2188
2189
|
@pulumi.getter(name="numOfUnits")
|
|
2189
|
-
def num_of_units(self) -> Optional[pulumi.Input[int]]:
|
|
2190
|
+
def num_of_units(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2190
2191
|
"""
|
|
2191
2192
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
2192
2193
|
"""
|
|
2193
2194
|
return pulumi.get(self, "num_of_units")
|
|
2194
2195
|
|
|
2195
2196
|
@num_of_units.setter
|
|
2196
|
-
def num_of_units(self, value: Optional[pulumi.Input[int]]):
|
|
2197
|
+
def num_of_units(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2197
2198
|
pulumi.set(self, "num_of_units", value)
|
|
2198
2199
|
|
|
2199
2200
|
|
|
@@ -2231,7 +2232,7 @@ class OceanNpVirtualNodeGroupLinuxOsConfigArgs:
|
|
|
2231
2232
|
|
|
2232
2233
|
if not MYPY:
|
|
2233
2234
|
class OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgsDict(TypedDict):
|
|
2234
|
-
vm_max_map_count: NotRequired[pulumi.Input[int]]
|
|
2235
|
+
vm_max_map_count: NotRequired[pulumi.Input[builtins.int]]
|
|
2235
2236
|
"""
|
|
2236
2237
|
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
2237
2238
|
"""
|
|
@@ -2241,23 +2242,23 @@ elif False:
|
|
|
2241
2242
|
@pulumi.input_type
|
|
2242
2243
|
class OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgs:
|
|
2243
2244
|
def __init__(__self__, *,
|
|
2244
|
-
vm_max_map_count: Optional[pulumi.Input[int]] = None):
|
|
2245
|
+
vm_max_map_count: Optional[pulumi.Input[builtins.int]] = None):
|
|
2245
2246
|
"""
|
|
2246
|
-
:param pulumi.Input[int] vm_max_map_count: Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
2247
|
+
:param pulumi.Input[builtins.int] vm_max_map_count: Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
2247
2248
|
"""
|
|
2248
2249
|
if vm_max_map_count is not None:
|
|
2249
2250
|
pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
|
|
2250
2251
|
|
|
2251
2252
|
@property
|
|
2252
2253
|
@pulumi.getter(name="vmMaxMapCount")
|
|
2253
|
-
def vm_max_map_count(self) -> Optional[pulumi.Input[int]]:
|
|
2254
|
+
def vm_max_map_count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2254
2255
|
"""
|
|
2255
2256
|
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
2256
2257
|
"""
|
|
2257
2258
|
return pulumi.get(self, "vm_max_map_count")
|
|
2258
2259
|
|
|
2259
2260
|
@vm_max_map_count.setter
|
|
2260
|
-
def vm_max_map_count(self, value: Optional[pulumi.Input[int]]):
|
|
2261
|
+
def vm_max_map_count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2261
2262
|
pulumi.set(self, "vm_max_map_count", value)
|
|
2262
2263
|
|
|
2263
2264
|
|
|
@@ -2295,11 +2296,11 @@ class OceanNpVirtualNodeGroupSchedulingArgs:
|
|
|
2295
2296
|
|
|
2296
2297
|
if not MYPY:
|
|
2297
2298
|
class OceanNpVirtualNodeGroupSchedulingShutdownHoursArgsDict(TypedDict):
|
|
2298
|
-
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
2299
|
+
is_enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
2299
2300
|
"""
|
|
2300
2301
|
Flag to enable or disable the shutdown hours mechanism. When `false`, the mechanism is deactivated, and the virtual node gorup remains in its current state.
|
|
2301
2302
|
"""
|
|
2302
|
-
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2303
|
+
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2303
2304
|
"""
|
|
2304
2305
|
The times that the shutdown hours will apply. Required if isEnabled is true.
|
|
2305
2306
|
"""
|
|
@@ -2309,11 +2310,11 @@ elif False:
|
|
|
2309
2310
|
@pulumi.input_type
|
|
2310
2311
|
class OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs:
|
|
2311
2312
|
def __init__(__self__, *,
|
|
2312
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
2313
|
-
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
2313
|
+
is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2314
|
+
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
2314
2315
|
"""
|
|
2315
|
-
:param pulumi.Input[bool] is_enabled: Flag to enable or disable the shutdown hours mechanism. When `false`, the mechanism is deactivated, and the virtual node gorup remains in its current state.
|
|
2316
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: The times that the shutdown hours will apply. Required if isEnabled is true.
|
|
2316
|
+
:param pulumi.Input[builtins.bool] is_enabled: Flag to enable or disable the shutdown hours mechanism. When `false`, the mechanism is deactivated, and the virtual node gorup remains in its current state.
|
|
2317
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] time_windows: The times that the shutdown hours will apply. Required if isEnabled is true.
|
|
2317
2318
|
"""
|
|
2318
2319
|
if is_enabled is not None:
|
|
2319
2320
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
@@ -2322,40 +2323,40 @@ class OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs:
|
|
|
2322
2323
|
|
|
2323
2324
|
@property
|
|
2324
2325
|
@pulumi.getter(name="isEnabled")
|
|
2325
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
2326
|
+
def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
2326
2327
|
"""
|
|
2327
2328
|
Flag to enable or disable the shutdown hours mechanism. When `false`, the mechanism is deactivated, and the virtual node gorup remains in its current state.
|
|
2328
2329
|
"""
|
|
2329
2330
|
return pulumi.get(self, "is_enabled")
|
|
2330
2331
|
|
|
2331
2332
|
@is_enabled.setter
|
|
2332
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
2333
|
+
def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
2333
2334
|
pulumi.set(self, "is_enabled", value)
|
|
2334
2335
|
|
|
2335
2336
|
@property
|
|
2336
2337
|
@pulumi.getter(name="timeWindows")
|
|
2337
|
-
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2338
|
+
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2338
2339
|
"""
|
|
2339
2340
|
The times that the shutdown hours will apply. Required if isEnabled is true.
|
|
2340
2341
|
"""
|
|
2341
2342
|
return pulumi.get(self, "time_windows")
|
|
2342
2343
|
|
|
2343
2344
|
@time_windows.setter
|
|
2344
|
-
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2345
|
+
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2345
2346
|
pulumi.set(self, "time_windows", value)
|
|
2346
2347
|
|
|
2347
2348
|
|
|
2348
2349
|
if not MYPY:
|
|
2349
2350
|
class OceanNpVirtualNodeGroupTaintArgsDict(TypedDict):
|
|
2350
|
-
effect: pulumi.Input[str]
|
|
2351
|
+
effect: pulumi.Input[builtins.str]
|
|
2351
2352
|
"""
|
|
2352
2353
|
Set taint effect.
|
|
2353
2354
|
"""
|
|
2354
|
-
key: pulumi.Input[str]
|
|
2355
|
+
key: pulumi.Input[builtins.str]
|
|
2355
2356
|
"""
|
|
2356
2357
|
Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
|
|
2357
2358
|
"""
|
|
2358
|
-
value: pulumi.Input[str]
|
|
2359
|
+
value: pulumi.Input[builtins.str]
|
|
2359
2360
|
"""
|
|
2360
2361
|
Set taint value.
|
|
2361
2362
|
"""
|
|
@@ -2365,13 +2366,13 @@ elif False:
|
|
|
2365
2366
|
@pulumi.input_type
|
|
2366
2367
|
class OceanNpVirtualNodeGroupTaintArgs:
|
|
2367
2368
|
def __init__(__self__, *,
|
|
2368
|
-
effect: pulumi.Input[str],
|
|
2369
|
-
key: pulumi.Input[str],
|
|
2370
|
-
value: pulumi.Input[str]):
|
|
2369
|
+
effect: pulumi.Input[builtins.str],
|
|
2370
|
+
key: pulumi.Input[builtins.str],
|
|
2371
|
+
value: pulumi.Input[builtins.str]):
|
|
2371
2372
|
"""
|
|
2372
|
-
:param pulumi.Input[str] effect: Set taint effect.
|
|
2373
|
-
:param pulumi.Input[str] key: Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
|
|
2374
|
-
:param pulumi.Input[str] value: Set taint value.
|
|
2373
|
+
:param pulumi.Input[builtins.str] effect: Set taint effect.
|
|
2374
|
+
:param pulumi.Input[builtins.str] key: Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
|
|
2375
|
+
:param pulumi.Input[builtins.str] value: Set taint value.
|
|
2375
2376
|
"""
|
|
2376
2377
|
pulumi.set(__self__, "effect", effect)
|
|
2377
2378
|
pulumi.set(__self__, "key", key)
|
|
@@ -2379,48 +2380,48 @@ class OceanNpVirtualNodeGroupTaintArgs:
|
|
|
2379
2380
|
|
|
2380
2381
|
@property
|
|
2381
2382
|
@pulumi.getter
|
|
2382
|
-
def effect(self) -> pulumi.Input[str]:
|
|
2383
|
+
def effect(self) -> pulumi.Input[builtins.str]:
|
|
2383
2384
|
"""
|
|
2384
2385
|
Set taint effect.
|
|
2385
2386
|
"""
|
|
2386
2387
|
return pulumi.get(self, "effect")
|
|
2387
2388
|
|
|
2388
2389
|
@effect.setter
|
|
2389
|
-
def effect(self, value: pulumi.Input[str]):
|
|
2390
|
+
def effect(self, value: pulumi.Input[builtins.str]):
|
|
2390
2391
|
pulumi.set(self, "effect", value)
|
|
2391
2392
|
|
|
2392
2393
|
@property
|
|
2393
2394
|
@pulumi.getter
|
|
2394
|
-
def key(self) -> pulumi.Input[str]:
|
|
2395
|
+
def key(self) -> pulumi.Input[builtins.str]:
|
|
2395
2396
|
"""
|
|
2396
2397
|
Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
|
|
2397
2398
|
"""
|
|
2398
2399
|
return pulumi.get(self, "key")
|
|
2399
2400
|
|
|
2400
2401
|
@key.setter
|
|
2401
|
-
def key(self, value: pulumi.Input[str]):
|
|
2402
|
+
def key(self, value: pulumi.Input[builtins.str]):
|
|
2402
2403
|
pulumi.set(self, "key", value)
|
|
2403
2404
|
|
|
2404
2405
|
@property
|
|
2405
2406
|
@pulumi.getter
|
|
2406
|
-
def value(self) -> pulumi.Input[str]:
|
|
2407
|
+
def value(self) -> pulumi.Input[builtins.str]:
|
|
2407
2408
|
"""
|
|
2408
2409
|
Set taint value.
|
|
2409
2410
|
"""
|
|
2410
2411
|
return pulumi.get(self, "value")
|
|
2411
2412
|
|
|
2412
2413
|
@value.setter
|
|
2413
|
-
def value(self, value: pulumi.Input[str]):
|
|
2414
|
+
def value(self, value: pulumi.Input[builtins.str]):
|
|
2414
2415
|
pulumi.set(self, "value", value)
|
|
2415
2416
|
|
|
2416
2417
|
|
|
2417
2418
|
if not MYPY:
|
|
2418
2419
|
class OceanNpVirtualNodeGroupUpdatePolicyArgsDict(TypedDict):
|
|
2419
|
-
should_roll: pulumi.Input[bool]
|
|
2420
|
+
should_roll: pulumi.Input[builtins.bool]
|
|
2420
2421
|
"""
|
|
2421
2422
|
If set to true along with the vng update, roll will be triggered.
|
|
2422
2423
|
"""
|
|
2423
|
-
conditioned_roll: NotRequired[pulumi.Input[bool]]
|
|
2424
|
+
conditioned_roll: NotRequired[pulumi.Input[builtins.bool]]
|
|
2424
2425
|
"""
|
|
2425
2426
|
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 availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
|
|
2426
2427
|
"""
|
|
@@ -2434,12 +2435,12 @@ elif False:
|
|
|
2434
2435
|
@pulumi.input_type
|
|
2435
2436
|
class OceanNpVirtualNodeGroupUpdatePolicyArgs:
|
|
2436
2437
|
def __init__(__self__, *,
|
|
2437
|
-
should_roll: pulumi.Input[bool],
|
|
2438
|
-
conditioned_roll: Optional[pulumi.Input[bool]] = None,
|
|
2438
|
+
should_roll: pulumi.Input[builtins.bool],
|
|
2439
|
+
conditioned_roll: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2439
2440
|
roll_config: Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs']] = None):
|
|
2440
2441
|
"""
|
|
2441
|
-
:param pulumi.Input[bool] should_roll: If set to true along with the vng update, roll will be triggered.
|
|
2442
|
-
: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 availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
|
|
2442
|
+
:param pulumi.Input[builtins.bool] should_roll: If set to true along with the vng update, roll will be triggered.
|
|
2443
|
+
: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 availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
|
|
2443
2444
|
:param pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs'] roll_config: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
2444
2445
|
"""
|
|
2445
2446
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
@@ -2450,26 +2451,26 @@ class OceanNpVirtualNodeGroupUpdatePolicyArgs:
|
|
|
2450
2451
|
|
|
2451
2452
|
@property
|
|
2452
2453
|
@pulumi.getter(name="shouldRoll")
|
|
2453
|
-
def should_roll(self) -> pulumi.Input[bool]:
|
|
2454
|
+
def should_roll(self) -> pulumi.Input[builtins.bool]:
|
|
2454
2455
|
"""
|
|
2455
2456
|
If set to true along with the vng update, roll will be triggered.
|
|
2456
2457
|
"""
|
|
2457
2458
|
return pulumi.get(self, "should_roll")
|
|
2458
2459
|
|
|
2459
2460
|
@should_roll.setter
|
|
2460
|
-
def should_roll(self, value: pulumi.Input[bool]):
|
|
2461
|
+
def should_roll(self, value: pulumi.Input[builtins.bool]):
|
|
2461
2462
|
pulumi.set(self, "should_roll", value)
|
|
2462
2463
|
|
|
2463
2464
|
@property
|
|
2464
2465
|
@pulumi.getter(name="conditionedRoll")
|
|
2465
|
-
def conditioned_roll(self) -> Optional[pulumi.Input[bool]]:
|
|
2466
|
+
def conditioned_roll(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
2466
2467
|
"""
|
|
2467
2468
|
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 availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
|
|
2468
2469
|
"""
|
|
2469
2470
|
return pulumi.get(self, "conditioned_roll")
|
|
2470
2471
|
|
|
2471
2472
|
@conditioned_roll.setter
|
|
2472
|
-
def conditioned_roll(self, value: Optional[pulumi.Input[bool]]):
|
|
2473
|
+
def conditioned_roll(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
2473
2474
|
pulumi.set(self, "conditioned_roll", value)
|
|
2474
2475
|
|
|
2475
2476
|
@property
|
|
@@ -2487,35 +2488,35 @@ class OceanNpVirtualNodeGroupUpdatePolicyArgs:
|
|
|
2487
2488
|
|
|
2488
2489
|
if not MYPY:
|
|
2489
2490
|
class OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgsDict(TypedDict):
|
|
2490
|
-
batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
|
|
2491
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
2491
2492
|
"""
|
|
2492
2493
|
Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
2493
2494
|
"""
|
|
2494
|
-
batch_size_percentage: NotRequired[pulumi.Input[int]]
|
|
2495
|
+
batch_size_percentage: NotRequired[pulumi.Input[builtins.int]]
|
|
2495
2496
|
"""
|
|
2496
2497
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
|
|
2497
2498
|
"""
|
|
2498
|
-
comment: NotRequired[pulumi.Input[str]]
|
|
2499
|
+
comment: NotRequired[pulumi.Input[builtins.str]]
|
|
2499
2500
|
"""
|
|
2500
2501
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
2501
2502
|
"""
|
|
2502
|
-
node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2503
|
+
node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2503
2504
|
"""
|
|
2504
2505
|
List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
|
|
2505
2506
|
"""
|
|
2506
|
-
node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2507
|
+
node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2507
2508
|
"""
|
|
2508
2509
|
List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
|
|
2509
2510
|
"""
|
|
2510
|
-
respect_pdb: NotRequired[pulumi.Input[bool]]
|
|
2511
|
+
respect_pdb: NotRequired[pulumi.Input[builtins.bool]]
|
|
2511
2512
|
"""
|
|
2512
2513
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
2513
2514
|
"""
|
|
2514
|
-
respect_restrict_scale_down: NotRequired[pulumi.Input[bool]]
|
|
2515
|
+
respect_restrict_scale_down: NotRequired[pulumi.Input[builtins.bool]]
|
|
2515
2516
|
"""
|
|
2516
2517
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
2517
2518
|
"""
|
|
2518
|
-
vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2519
|
+
vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2519
2520
|
"""
|
|
2520
2521
|
List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
2521
2522
|
"""
|
|
@@ -2525,23 +2526,23 @@ elif False:
|
|
|
2525
2526
|
@pulumi.input_type
|
|
2526
2527
|
class OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs:
|
|
2527
2528
|
def __init__(__self__, *,
|
|
2528
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
2529
|
-
batch_size_percentage: Optional[pulumi.Input[int]] = None,
|
|
2530
|
-
comment: Optional[pulumi.Input[str]] = None,
|
|
2531
|
-
node_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2532
|
-
node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2533
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None,
|
|
2534
|
-
respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None,
|
|
2535
|
-
vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
2536
|
-
"""
|
|
2537
|
-
:param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
2538
|
-
: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. In case of null as value, the default value in the backend will be 20%.
|
|
2539
|
-
:param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
2540
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] node_names: List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
|
|
2541
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] node_pool_names: List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
|
|
2542
|
-
:param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
2543
|
-
:param pulumi.Input[bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
2544
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
2529
|
+
batch_min_healthy_percentage: Optional[pulumi.Input[builtins.int]] = None,
|
|
2530
|
+
batch_size_percentage: Optional[pulumi.Input[builtins.int]] = None,
|
|
2531
|
+
comment: Optional[pulumi.Input[builtins.str]] = None,
|
|
2532
|
+
node_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2533
|
+
node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2534
|
+
respect_pdb: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2535
|
+
respect_restrict_scale_down: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2536
|
+
vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
2537
|
+
"""
|
|
2538
|
+
:param pulumi.Input[builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
2539
|
+
: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. In case of null as value, the default value in the backend will be 20%.
|
|
2540
|
+
:param pulumi.Input[builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
2541
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_names: List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
|
|
2542
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_pool_names: List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
|
|
2543
|
+
:param pulumi.Input[builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
2544
|
+
:param pulumi.Input[builtins.bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
2545
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
2545
2546
|
"""
|
|
2546
2547
|
if batch_min_healthy_percentage is not None:
|
|
2547
2548
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -2562,98 +2563,98 @@ class OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs:
|
|
|
2562
2563
|
|
|
2563
2564
|
@property
|
|
2564
2565
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
2565
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2566
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2566
2567
|
"""
|
|
2567
2568
|
Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the 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.
|
|
2568
2569
|
"""
|
|
2569
2570
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
2570
2571
|
|
|
2571
2572
|
@batch_min_healthy_percentage.setter
|
|
2572
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2573
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2573
2574
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
2574
2575
|
|
|
2575
2576
|
@property
|
|
2576
2577
|
@pulumi.getter(name="batchSizePercentage")
|
|
2577
|
-
def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2578
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2578
2579
|
"""
|
|
2579
2580
|
Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
|
|
2580
2581
|
"""
|
|
2581
2582
|
return pulumi.get(self, "batch_size_percentage")
|
|
2582
2583
|
|
|
2583
2584
|
@batch_size_percentage.setter
|
|
2584
|
-
def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2585
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2585
2586
|
pulumi.set(self, "batch_size_percentage", value)
|
|
2586
2587
|
|
|
2587
2588
|
@property
|
|
2588
2589
|
@pulumi.getter
|
|
2589
|
-
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
2590
|
+
def comment(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2590
2591
|
"""
|
|
2591
2592
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
2592
2593
|
"""
|
|
2593
2594
|
return pulumi.get(self, "comment")
|
|
2594
2595
|
|
|
2595
2596
|
@comment.setter
|
|
2596
|
-
def comment(self, value: Optional[pulumi.Input[str]]):
|
|
2597
|
+
def comment(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2597
2598
|
pulumi.set(self, "comment", value)
|
|
2598
2599
|
|
|
2599
2600
|
@property
|
|
2600
2601
|
@pulumi.getter(name="nodeNames")
|
|
2601
|
-
def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2602
|
+
def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2602
2603
|
"""
|
|
2603
2604
|
List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
|
|
2604
2605
|
"""
|
|
2605
2606
|
return pulumi.get(self, "node_names")
|
|
2606
2607
|
|
|
2607
2608
|
@node_names.setter
|
|
2608
|
-
def node_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2609
|
+
def node_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2609
2610
|
pulumi.set(self, "node_names", value)
|
|
2610
2611
|
|
|
2611
2612
|
@property
|
|
2612
2613
|
@pulumi.getter(name="nodePoolNames")
|
|
2613
|
-
def node_pool_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2614
|
+
def node_pool_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2614
2615
|
"""
|
|
2615
2616
|
List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
|
|
2616
2617
|
"""
|
|
2617
2618
|
return pulumi.get(self, "node_pool_names")
|
|
2618
2619
|
|
|
2619
2620
|
@node_pool_names.setter
|
|
2620
|
-
def node_pool_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2621
|
+
def node_pool_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2621
2622
|
pulumi.set(self, "node_pool_names", value)
|
|
2622
2623
|
|
|
2623
2624
|
@property
|
|
2624
2625
|
@pulumi.getter(name="respectPdb")
|
|
2625
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
2626
|
+
def respect_pdb(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
2626
2627
|
"""
|
|
2627
2628
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
2628
2629
|
"""
|
|
2629
2630
|
return pulumi.get(self, "respect_pdb")
|
|
2630
2631
|
|
|
2631
2632
|
@respect_pdb.setter
|
|
2632
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
2633
|
+
def respect_pdb(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
2633
2634
|
pulumi.set(self, "respect_pdb", value)
|
|
2634
2635
|
|
|
2635
2636
|
@property
|
|
2636
2637
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
2637
|
-
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
|
|
2638
|
+
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
2638
2639
|
"""
|
|
2639
2640
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
2640
2641
|
"""
|
|
2641
2642
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
2642
2643
|
|
|
2643
2644
|
@respect_restrict_scale_down.setter
|
|
2644
|
-
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
|
|
2645
|
+
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
2645
2646
|
pulumi.set(self, "respect_restrict_scale_down", value)
|
|
2646
2647
|
|
|
2647
2648
|
@property
|
|
2648
2649
|
@pulumi.getter(name="vngIds")
|
|
2649
|
-
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2650
|
+
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2650
2651
|
"""
|
|
2651
2652
|
List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
|
|
2652
2653
|
"""
|
|
2653
2654
|
return pulumi.get(self, "vng_ids")
|
|
2654
2655
|
|
|
2655
2656
|
@vng_ids.setter
|
|
2656
|
-
def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2657
|
+
def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2657
2658
|
pulumi.set(self, "vng_ids", value)
|
|
2658
2659
|
|
|
2659
2660
|
|
|
@@ -2682,8 +2683,8 @@ class OceanNpVngTemplateSchedulingArgs:
|
|
|
2682
2683
|
|
|
2683
2684
|
if not MYPY:
|
|
2684
2685
|
class OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgsDict(TypedDict):
|
|
2685
|
-
is_enabled: NotRequired[pulumi.Input[bool]]
|
|
2686
|
-
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2686
|
+
is_enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
2687
|
+
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2687
2688
|
"""
|
|
2688
2689
|
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
2689
2690
|
"""
|
|
@@ -2693,10 +2694,10 @@ elif False:
|
|
|
2693
2694
|
@pulumi.input_type
|
|
2694
2695
|
class OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgs:
|
|
2695
2696
|
def __init__(__self__, *,
|
|
2696
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
2697
|
-
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
2697
|
+
is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2698
|
+
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
2698
2699
|
"""
|
|
2699
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
2700
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
2700
2701
|
"""
|
|
2701
2702
|
if is_enabled is not None:
|
|
2702
2703
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
@@ -2705,23 +2706,23 @@ class OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgs:
|
|
|
2705
2706
|
|
|
2706
2707
|
@property
|
|
2707
2708
|
@pulumi.getter(name="isEnabled")
|
|
2708
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
2709
|
+
def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
2709
2710
|
return pulumi.get(self, "is_enabled")
|
|
2710
2711
|
|
|
2711
2712
|
@is_enabled.setter
|
|
2712
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
2713
|
+
def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
2713
2714
|
pulumi.set(self, "is_enabled", value)
|
|
2714
2715
|
|
|
2715
2716
|
@property
|
|
2716
2717
|
@pulumi.getter(name="timeWindows")
|
|
2717
|
-
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2718
|
+
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
2718
2719
|
"""
|
|
2719
2720
|
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
2720
2721
|
"""
|
|
2721
2722
|
return pulumi.get(self, "time_windows")
|
|
2722
2723
|
|
|
2723
2724
|
@time_windows.setter
|
|
2724
|
-
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2725
|
+
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
2725
2726
|
pulumi.set(self, "time_windows", value)
|
|
2726
2727
|
|
|
2727
2728
|
|