pulumi-spotinst 3.124.0a1753339288__py3-none-any.whl → 3.124.0a1753511976__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 -1
- pulumi_spotinst/_inputs.py +1616 -1617
- pulumi_spotinst/account.py +18 -19
- pulumi_spotinst/aws/__init__.py +1 -1
- pulumi_spotinst/aws/_inputs.py +3654 -3655
- pulumi_spotinst/aws/account.py +18 -19
- pulumi_spotinst/aws/beanstalk.py +176 -177
- pulumi_spotinst/aws/credentials.py +35 -36
- pulumi_spotinst/aws/elastigroup.py +936 -937
- pulumi_spotinst/aws/managed_instance.py +505 -506
- pulumi_spotinst/aws/mr_scalar.py +652 -653
- pulumi_spotinst/aws/ocean.py +531 -532
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +35 -36
- pulumi_spotinst/aws/ocean_launch_spec.py +302 -303
- pulumi_spotinst/aws/outputs.py +2392 -2393
- pulumi_spotinst/aws/suspension.py +21 -22
- pulumi_spotinst/azure/__init__.py +1 -1
- pulumi_spotinst/azure/_inputs.py +606 -607
- pulumi_spotinst/azure/ocean_np.py +385 -386
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +321 -322
- pulumi_spotinst/azure/outputs.py +410 -411
- pulumi_spotinst/config/__init__.py +1 -1
- pulumi_spotinst/config/__init__.pyi +1 -2
- pulumi_spotinst/config/vars.py +5 -6
- pulumi_spotinst/credentials_azure.py +103 -104
- pulumi_spotinst/credentials_gcp.py +188 -189
- pulumi_spotinst/data_integration.py +38 -39
- pulumi_spotinst/ecs/__init__.py +1 -1
- pulumi_spotinst/ecs/_inputs.py +583 -584
- pulumi_spotinst/ecs/ocean.py +414 -415
- pulumi_spotinst/ecs/ocean_launch_spec.py +195 -196
- pulumi_spotinst/ecs/outputs.py +393 -394
- pulumi_spotinst/elastigroup_azure_v3.py +324 -325
- pulumi_spotinst/gcp/__init__.py +1 -1
- pulumi_spotinst/gcp/_inputs.py +505 -506
- pulumi_spotinst/gcp/elastigroup.py +481 -482
- pulumi_spotinst/gcp/outputs.py +335 -336
- pulumi_spotinst/gke/__init__.py +1 -1
- pulumi_spotinst/gke/_inputs.py +917 -918
- pulumi_spotinst/gke/elastigroup.py +339 -340
- pulumi_spotinst/gke/ocean_import.py +202 -203
- pulumi_spotinst/gke/ocean_launch_spec.py +210 -211
- pulumi_spotinst/gke/ocean_launch_spec_import.py +35 -36
- pulumi_spotinst/gke/outputs.py +597 -598
- pulumi_spotinst/health_check.py +64 -65
- pulumi_spotinst/notification_center.py +62 -63
- pulumi_spotinst/ocean_right_sizing_rule.py +74 -75
- pulumi_spotinst/oceancd/__init__.py +1 -1
- pulumi_spotinst/oceancd/_inputs.py +763 -764
- pulumi_spotinst/oceancd/outputs.py +525 -526
- pulumi_spotinst/oceancd/rollout_spec.py +33 -34
- pulumi_spotinst/oceancd/strategy.py +20 -21
- pulumi_spotinst/oceancd/verification_provider.py +50 -51
- pulumi_spotinst/oceancd/verification_template.py +24 -25
- pulumi_spotinst/organization/__init__.py +1 -1
- pulumi_spotinst/organization/_inputs.py +67 -68
- pulumi_spotinst/organization/outputs.py +45 -46
- pulumi_spotinst/organization/policy.py +38 -39
- pulumi_spotinst/organization/programmatic_user.py +58 -59
- pulumi_spotinst/organization/user.py +106 -107
- pulumi_spotinst/organization/user_group.py +55 -56
- pulumi_spotinst/outputs.py +990 -991
- pulumi_spotinst/provider.py +40 -41
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +1 -1
- pulumi_spotinst/spark/_inputs.py +103 -104
- pulumi_spotinst/spark/ocean.py +36 -37
- pulumi_spotinst/spark/ocean_virtual_node_group.py +27 -28
- pulumi_spotinst/spark/outputs.py +71 -72
- pulumi_spotinst/stateful_node_azure.py +304 -305
- pulumi_spotinst/subscription.py +86 -87
- {pulumi_spotinst-3.124.0a1753339288.dist-info → pulumi_spotinst-3.124.0a1753511976.dist-info}/METADATA +1 -1
- pulumi_spotinst-3.124.0a1753511976.dist-info/RECORD +77 -0
- pulumi_spotinst-3.124.0a1753339288.dist-info/RECORD +0 -77
- {pulumi_spotinst-3.124.0a1753339288.dist-info → pulumi_spotinst-3.124.0a1753511976.dist-info}/WHEEL +0 -0
- {pulumi_spotinst-3.124.0a1753339288.dist-info → pulumi_spotinst-3.124.0a1753511976.dist-info}/top_level.txt +0 -0
pulumi_spotinst/azure/outputs.py
CHANGED
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -82,12 +81,12 @@ class OceanNpAutoscaler(dict):
|
|
|
82
81
|
def __init__(__self__, *,
|
|
83
82
|
autoscale_down: Optional['outputs.OceanNpAutoscalerAutoscaleDown'] = None,
|
|
84
83
|
autoscale_headroom: Optional['outputs.OceanNpAutoscalerAutoscaleHeadroom'] = None,
|
|
85
|
-
autoscale_is_enabled: Optional[
|
|
84
|
+
autoscale_is_enabled: Optional[_builtins.bool] = None,
|
|
86
85
|
resource_limits: Optional['outputs.OceanNpAutoscalerResourceLimits'] = None):
|
|
87
86
|
"""
|
|
88
87
|
:param 'OceanNpAutoscalerAutoscaleDownArgs' autoscale_down: Auto Scaling scale down operations.
|
|
89
88
|
:param 'OceanNpAutoscalerAutoscaleHeadroomArgs' autoscale_headroom: Spare resource capacity management enabling fast assignment of pods without waiting for new resources to launch.
|
|
90
|
-
:param
|
|
89
|
+
:param _builtins.bool autoscale_is_enabled: Enable the Ocean Kubernetes Autoscaler.
|
|
91
90
|
:param 'OceanNpAutoscalerResourceLimitsArgs' resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
|
|
92
91
|
"""
|
|
93
92
|
if autoscale_down is not None:
|
|
@@ -99,7 +98,7 @@ class OceanNpAutoscaler(dict):
|
|
|
99
98
|
if resource_limits is not None:
|
|
100
99
|
pulumi.set(__self__, "resource_limits", resource_limits)
|
|
101
100
|
|
|
102
|
-
@property
|
|
101
|
+
@_builtins.property
|
|
103
102
|
@pulumi.getter(name="autoscaleDown")
|
|
104
103
|
def autoscale_down(self) -> Optional['outputs.OceanNpAutoscalerAutoscaleDown']:
|
|
105
104
|
"""
|
|
@@ -107,7 +106,7 @@ class OceanNpAutoscaler(dict):
|
|
|
107
106
|
"""
|
|
108
107
|
return pulumi.get(self, "autoscale_down")
|
|
109
108
|
|
|
110
|
-
@property
|
|
109
|
+
@_builtins.property
|
|
111
110
|
@pulumi.getter(name="autoscaleHeadroom")
|
|
112
111
|
def autoscale_headroom(self) -> Optional['outputs.OceanNpAutoscalerAutoscaleHeadroom']:
|
|
113
112
|
"""
|
|
@@ -115,15 +114,15 @@ class OceanNpAutoscaler(dict):
|
|
|
115
114
|
"""
|
|
116
115
|
return pulumi.get(self, "autoscale_headroom")
|
|
117
116
|
|
|
118
|
-
@property
|
|
117
|
+
@_builtins.property
|
|
119
118
|
@pulumi.getter(name="autoscaleIsEnabled")
|
|
120
|
-
def autoscale_is_enabled(self) -> Optional[
|
|
119
|
+
def autoscale_is_enabled(self) -> Optional[_builtins.bool]:
|
|
121
120
|
"""
|
|
122
121
|
Enable the Ocean Kubernetes Autoscaler.
|
|
123
122
|
"""
|
|
124
123
|
return pulumi.get(self, "autoscale_is_enabled")
|
|
125
124
|
|
|
126
|
-
@property
|
|
125
|
+
@_builtins.property
|
|
127
126
|
@pulumi.getter(name="resourceLimits")
|
|
128
127
|
def resource_limits(self) -> Optional['outputs.OceanNpAutoscalerResourceLimits']:
|
|
129
128
|
"""
|
|
@@ -152,16 +151,16 @@ class OceanNpAutoscalerAutoscaleDown(dict):
|
|
|
152
151
|
return super().get(key, default)
|
|
153
152
|
|
|
154
153
|
def __init__(__self__, *,
|
|
155
|
-
max_scale_down_percentage: Optional[
|
|
154
|
+
max_scale_down_percentage: Optional[_builtins.int] = None):
|
|
156
155
|
"""
|
|
157
|
-
:param
|
|
156
|
+
:param _builtins.int max_scale_down_percentage: The maximum percentage allowed to scale down in a single scaling action.
|
|
158
157
|
"""
|
|
159
158
|
if max_scale_down_percentage is not None:
|
|
160
159
|
pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
|
|
161
160
|
|
|
162
|
-
@property
|
|
161
|
+
@_builtins.property
|
|
163
162
|
@pulumi.getter(name="maxScaleDownPercentage")
|
|
164
|
-
def max_scale_down_percentage(self) -> Optional[
|
|
163
|
+
def max_scale_down_percentage(self) -> Optional[_builtins.int]:
|
|
165
164
|
"""
|
|
166
165
|
The maximum percentage allowed to scale down in a single scaling action.
|
|
167
166
|
"""
|
|
@@ -178,7 +177,7 @@ class OceanNpAutoscalerAutoscaleHeadroom(dict):
|
|
|
178
177
|
if automatic is not None:
|
|
179
178
|
pulumi.set(__self__, "automatic", automatic)
|
|
180
179
|
|
|
181
|
-
@property
|
|
180
|
+
@_builtins.property
|
|
182
181
|
@pulumi.getter
|
|
183
182
|
def automatic(self) -> Optional['outputs.OceanNpAutoscalerAutoscaleHeadroomAutomatic']:
|
|
184
183
|
"""
|
|
@@ -207,28 +206,28 @@ class OceanNpAutoscalerAutoscaleHeadroomAutomatic(dict):
|
|
|
207
206
|
return super().get(key, default)
|
|
208
207
|
|
|
209
208
|
def __init__(__self__, *,
|
|
210
|
-
is_enabled: Optional[
|
|
211
|
-
percentage: Optional[
|
|
209
|
+
is_enabled: Optional[_builtins.bool] = None,
|
|
210
|
+
percentage: Optional[_builtins.int] = None):
|
|
212
211
|
"""
|
|
213
|
-
:param
|
|
214
|
-
:param
|
|
212
|
+
:param _builtins.bool is_enabled: Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
|
|
213
|
+
:param _builtins.int percentage: Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
|
|
215
214
|
"""
|
|
216
215
|
if is_enabled is not None:
|
|
217
216
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
218
217
|
if percentage is not None:
|
|
219
218
|
pulumi.set(__self__, "percentage", percentage)
|
|
220
219
|
|
|
221
|
-
@property
|
|
220
|
+
@_builtins.property
|
|
222
221
|
@pulumi.getter(name="isEnabled")
|
|
223
|
-
def is_enabled(self) -> Optional[
|
|
222
|
+
def is_enabled(self) -> Optional[_builtins.bool]:
|
|
224
223
|
"""
|
|
225
224
|
Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
|
|
226
225
|
"""
|
|
227
226
|
return pulumi.get(self, "is_enabled")
|
|
228
227
|
|
|
229
|
-
@property
|
|
228
|
+
@_builtins.property
|
|
230
229
|
@pulumi.getter
|
|
231
|
-
def percentage(self) -> Optional[
|
|
230
|
+
def percentage(self) -> Optional[_builtins.int]:
|
|
232
231
|
"""
|
|
233
232
|
Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
|
|
234
233
|
"""
|
|
@@ -257,28 +256,28 @@ class OceanNpAutoscalerResourceLimits(dict):
|
|
|
257
256
|
return super().get(key, default)
|
|
258
257
|
|
|
259
258
|
def __init__(__self__, *,
|
|
260
|
-
max_memory_gib: Optional[
|
|
261
|
-
max_vcpu: Optional[
|
|
259
|
+
max_memory_gib: Optional[_builtins.int] = None,
|
|
260
|
+
max_vcpu: Optional[_builtins.int] = None):
|
|
262
261
|
"""
|
|
263
|
-
:param
|
|
264
|
-
:param
|
|
262
|
+
:param _builtins.int max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
|
|
263
|
+
:param _builtins.int max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
265
264
|
"""
|
|
266
265
|
if max_memory_gib is not None:
|
|
267
266
|
pulumi.set(__self__, "max_memory_gib", max_memory_gib)
|
|
268
267
|
if max_vcpu is not None:
|
|
269
268
|
pulumi.set(__self__, "max_vcpu", max_vcpu)
|
|
270
269
|
|
|
271
|
-
@property
|
|
270
|
+
@_builtins.property
|
|
272
271
|
@pulumi.getter(name="maxMemoryGib")
|
|
273
|
-
def max_memory_gib(self) -> Optional[
|
|
272
|
+
def max_memory_gib(self) -> Optional[_builtins.int]:
|
|
274
273
|
"""
|
|
275
274
|
The maximum memory in GiB units that can be allocated to the cluster.
|
|
276
275
|
"""
|
|
277
276
|
return pulumi.get(self, "max_memory_gib")
|
|
278
277
|
|
|
279
|
-
@property
|
|
278
|
+
@_builtins.property
|
|
280
279
|
@pulumi.getter(name="maxVcpu")
|
|
281
|
-
def max_vcpu(self) -> Optional[
|
|
280
|
+
def max_vcpu(self) -> Optional[_builtins.int]:
|
|
282
281
|
"""
|
|
283
282
|
The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
284
283
|
"""
|
|
@@ -329,37 +328,37 @@ class OceanNpFilters(dict):
|
|
|
329
328
|
return super().get(key, default)
|
|
330
329
|
|
|
331
330
|
def __init__(__self__, *,
|
|
332
|
-
accelerated_networking: Optional[
|
|
333
|
-
architectures: Optional[Sequence[
|
|
334
|
-
disk_performance: Optional[
|
|
335
|
-
exclude_series: Optional[Sequence[
|
|
336
|
-
gpu_types: Optional[Sequence[
|
|
337
|
-
max_gpu: Optional[
|
|
338
|
-
max_memory_gib: Optional[
|
|
339
|
-
max_vcpu: Optional[
|
|
340
|
-
min_disk: Optional[
|
|
341
|
-
min_gpu: Optional[
|
|
342
|
-
min_memory_gib: Optional[
|
|
343
|
-
min_nics: Optional[
|
|
344
|
-
min_vcpu: Optional[
|
|
345
|
-
series: Optional[Sequence[
|
|
346
|
-
vm_types: Optional[Sequence[
|
|
347
|
-
"""
|
|
348
|
-
:param
|
|
349
|
-
:param Sequence[
|
|
350
|
-
:param
|
|
351
|
-
:param Sequence[
|
|
352
|
-
:param Sequence[
|
|
353
|
-
:param
|
|
354
|
-
:param
|
|
355
|
-
:param
|
|
356
|
-
:param
|
|
357
|
-
:param
|
|
358
|
-
:param
|
|
359
|
-
:param
|
|
360
|
-
:param
|
|
361
|
-
:param Sequence[
|
|
362
|
-
:param Sequence[
|
|
331
|
+
accelerated_networking: Optional[_builtins.str] = None,
|
|
332
|
+
architectures: Optional[Sequence[_builtins.str]] = None,
|
|
333
|
+
disk_performance: Optional[_builtins.str] = None,
|
|
334
|
+
exclude_series: Optional[Sequence[_builtins.str]] = None,
|
|
335
|
+
gpu_types: Optional[Sequence[_builtins.str]] = None,
|
|
336
|
+
max_gpu: Optional[_builtins.float] = None,
|
|
337
|
+
max_memory_gib: Optional[_builtins.float] = None,
|
|
338
|
+
max_vcpu: Optional[_builtins.int] = None,
|
|
339
|
+
min_disk: Optional[_builtins.int] = None,
|
|
340
|
+
min_gpu: Optional[_builtins.float] = None,
|
|
341
|
+
min_memory_gib: Optional[_builtins.float] = None,
|
|
342
|
+
min_nics: Optional[_builtins.int] = None,
|
|
343
|
+
min_vcpu: Optional[_builtins.int] = None,
|
|
344
|
+
series: Optional[Sequence[_builtins.str]] = None,
|
|
345
|
+
vm_types: Optional[Sequence[_builtins.str]] = None):
|
|
346
|
+
"""
|
|
347
|
+
:param _builtins.str accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
348
|
+
:param Sequence[_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.
|
|
349
|
+
:param _builtins.str disk_performance: The filtered vm sizes will support at least one of the classes from this list.
|
|
350
|
+
:param Sequence[_builtins.str] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling
|
|
351
|
+
:param Sequence[_builtins.str] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
|
|
352
|
+
:param _builtins.float max_gpu: Maximum number of GPUs available.
|
|
353
|
+
:param _builtins.float max_memory_gib: Maximum amount of Memory (GiB).
|
|
354
|
+
:param _builtins.int max_vcpu: Maximum number of vcpus available.
|
|
355
|
+
:param _builtins.int min_disk: Minimum number of data disks available.
|
|
356
|
+
:param _builtins.float min_gpu: Minimum number of GPUs available.
|
|
357
|
+
:param _builtins.float min_memory_gib: Minimum amount of Memory (GiB).
|
|
358
|
+
:param _builtins.int min_nics: Minimum number of network interfaces.
|
|
359
|
+
:param _builtins.int min_vcpu: Minimum number of vcpus available.
|
|
360
|
+
:param Sequence[_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.
|
|
361
|
+
:param Sequence[_builtins.str] vm_types: The filtered vm types will belong to one of the vm types from this list.
|
|
363
362
|
"""
|
|
364
363
|
if accelerated_networking is not None:
|
|
365
364
|
pulumi.set(__self__, "accelerated_networking", accelerated_networking)
|
|
@@ -392,121 +391,121 @@ class OceanNpFilters(dict):
|
|
|
392
391
|
if vm_types is not None:
|
|
393
392
|
pulumi.set(__self__, "vm_types", vm_types)
|
|
394
393
|
|
|
395
|
-
@property
|
|
394
|
+
@_builtins.property
|
|
396
395
|
@pulumi.getter(name="acceleratedNetworking")
|
|
397
|
-
def accelerated_networking(self) -> Optional[
|
|
396
|
+
def accelerated_networking(self) -> Optional[_builtins.str]:
|
|
398
397
|
"""
|
|
399
398
|
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
400
399
|
"""
|
|
401
400
|
return pulumi.get(self, "accelerated_networking")
|
|
402
401
|
|
|
403
|
-
@property
|
|
402
|
+
@_builtins.property
|
|
404
403
|
@pulumi.getter
|
|
405
|
-
def architectures(self) -> Optional[Sequence[
|
|
404
|
+
def architectures(self) -> Optional[Sequence[_builtins.str]]:
|
|
406
405
|
"""
|
|
407
406
|
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
408
407
|
"""
|
|
409
408
|
return pulumi.get(self, "architectures")
|
|
410
409
|
|
|
411
|
-
@property
|
|
410
|
+
@_builtins.property
|
|
412
411
|
@pulumi.getter(name="diskPerformance")
|
|
413
|
-
def disk_performance(self) -> Optional[
|
|
412
|
+
def disk_performance(self) -> Optional[_builtins.str]:
|
|
414
413
|
"""
|
|
415
414
|
The filtered vm sizes will support at least one of the classes from this list.
|
|
416
415
|
"""
|
|
417
416
|
return pulumi.get(self, "disk_performance")
|
|
418
417
|
|
|
419
|
-
@property
|
|
418
|
+
@_builtins.property
|
|
420
419
|
@pulumi.getter(name="excludeSeries")
|
|
421
|
-
def exclude_series(self) -> Optional[Sequence[
|
|
420
|
+
def exclude_series(self) -> Optional[Sequence[_builtins.str]]:
|
|
422
421
|
"""
|
|
423
422
|
Vm sizes belonging to a series from the list will not be available for scaling
|
|
424
423
|
"""
|
|
425
424
|
return pulumi.get(self, "exclude_series")
|
|
426
425
|
|
|
427
|
-
@property
|
|
426
|
+
@_builtins.property
|
|
428
427
|
@pulumi.getter(name="gpuTypes")
|
|
429
|
-
def gpu_types(self) -> Optional[Sequence[
|
|
428
|
+
def gpu_types(self) -> Optional[Sequence[_builtins.str]]:
|
|
430
429
|
"""
|
|
431
430
|
The filtered gpu types will belong to one of the gpu types from this list.
|
|
432
431
|
"""
|
|
433
432
|
return pulumi.get(self, "gpu_types")
|
|
434
433
|
|
|
435
|
-
@property
|
|
434
|
+
@_builtins.property
|
|
436
435
|
@pulumi.getter(name="maxGpu")
|
|
437
|
-
def max_gpu(self) -> Optional[
|
|
436
|
+
def max_gpu(self) -> Optional[_builtins.float]:
|
|
438
437
|
"""
|
|
439
438
|
Maximum number of GPUs available.
|
|
440
439
|
"""
|
|
441
440
|
return pulumi.get(self, "max_gpu")
|
|
442
441
|
|
|
443
|
-
@property
|
|
442
|
+
@_builtins.property
|
|
444
443
|
@pulumi.getter(name="maxMemoryGib")
|
|
445
|
-
def max_memory_gib(self) -> Optional[
|
|
444
|
+
def max_memory_gib(self) -> Optional[_builtins.float]:
|
|
446
445
|
"""
|
|
447
446
|
Maximum amount of Memory (GiB).
|
|
448
447
|
"""
|
|
449
448
|
return pulumi.get(self, "max_memory_gib")
|
|
450
449
|
|
|
451
|
-
@property
|
|
450
|
+
@_builtins.property
|
|
452
451
|
@pulumi.getter(name="maxVcpu")
|
|
453
|
-
def max_vcpu(self) -> Optional[
|
|
452
|
+
def max_vcpu(self) -> Optional[_builtins.int]:
|
|
454
453
|
"""
|
|
455
454
|
Maximum number of vcpus available.
|
|
456
455
|
"""
|
|
457
456
|
return pulumi.get(self, "max_vcpu")
|
|
458
457
|
|
|
459
|
-
@property
|
|
458
|
+
@_builtins.property
|
|
460
459
|
@pulumi.getter(name="minDisk")
|
|
461
|
-
def min_disk(self) -> Optional[
|
|
460
|
+
def min_disk(self) -> Optional[_builtins.int]:
|
|
462
461
|
"""
|
|
463
462
|
Minimum number of data disks available.
|
|
464
463
|
"""
|
|
465
464
|
return pulumi.get(self, "min_disk")
|
|
466
465
|
|
|
467
|
-
@property
|
|
466
|
+
@_builtins.property
|
|
468
467
|
@pulumi.getter(name="minGpu")
|
|
469
|
-
def min_gpu(self) -> Optional[
|
|
468
|
+
def min_gpu(self) -> Optional[_builtins.float]:
|
|
470
469
|
"""
|
|
471
470
|
Minimum number of GPUs available.
|
|
472
471
|
"""
|
|
473
472
|
return pulumi.get(self, "min_gpu")
|
|
474
473
|
|
|
475
|
-
@property
|
|
474
|
+
@_builtins.property
|
|
476
475
|
@pulumi.getter(name="minMemoryGib")
|
|
477
|
-
def min_memory_gib(self) -> Optional[
|
|
476
|
+
def min_memory_gib(self) -> Optional[_builtins.float]:
|
|
478
477
|
"""
|
|
479
478
|
Minimum amount of Memory (GiB).
|
|
480
479
|
"""
|
|
481
480
|
return pulumi.get(self, "min_memory_gib")
|
|
482
481
|
|
|
483
|
-
@property
|
|
482
|
+
@_builtins.property
|
|
484
483
|
@pulumi.getter(name="minNics")
|
|
485
|
-
def min_nics(self) -> Optional[
|
|
484
|
+
def min_nics(self) -> Optional[_builtins.int]:
|
|
486
485
|
"""
|
|
487
486
|
Minimum number of network interfaces.
|
|
488
487
|
"""
|
|
489
488
|
return pulumi.get(self, "min_nics")
|
|
490
489
|
|
|
491
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
492
491
|
@pulumi.getter(name="minVcpu")
|
|
493
|
-
def min_vcpu(self) -> Optional[
|
|
492
|
+
def min_vcpu(self) -> Optional[_builtins.int]:
|
|
494
493
|
"""
|
|
495
494
|
Minimum number of vcpus available.
|
|
496
495
|
"""
|
|
497
496
|
return pulumi.get(self, "min_vcpu")
|
|
498
497
|
|
|
499
|
-
@property
|
|
498
|
+
@_builtins.property
|
|
500
499
|
@pulumi.getter
|
|
501
|
-
def series(self) -> Optional[Sequence[
|
|
500
|
+
def series(self) -> Optional[Sequence[_builtins.str]]:
|
|
502
501
|
"""
|
|
503
502
|
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.
|
|
504
503
|
"""
|
|
505
504
|
return pulumi.get(self, "series")
|
|
506
505
|
|
|
507
|
-
@property
|
|
506
|
+
@_builtins.property
|
|
508
507
|
@pulumi.getter(name="vmTypes")
|
|
509
|
-
def vm_types(self) -> Optional[Sequence[
|
|
508
|
+
def vm_types(self) -> Optional[Sequence[_builtins.str]]:
|
|
510
509
|
"""
|
|
511
510
|
The filtered vm types will belong to one of the vm types from this list.
|
|
512
511
|
"""
|
|
@@ -539,15 +538,15 @@ class OceanNpHeadroom(dict):
|
|
|
539
538
|
return super().get(key, default)
|
|
540
539
|
|
|
541
540
|
def __init__(__self__, *,
|
|
542
|
-
cpu_per_unit: Optional[
|
|
543
|
-
gpu_per_unit: Optional[
|
|
544
|
-
memory_per_unit: Optional[
|
|
545
|
-
num_of_units: Optional[
|
|
541
|
+
cpu_per_unit: Optional[_builtins.int] = None,
|
|
542
|
+
gpu_per_unit: Optional[_builtins.int] = None,
|
|
543
|
+
memory_per_unit: Optional[_builtins.int] = None,
|
|
544
|
+
num_of_units: Optional[_builtins.int] = None):
|
|
546
545
|
"""
|
|
547
|
-
:param
|
|
548
|
-
:param
|
|
549
|
-
:param
|
|
550
|
-
:param
|
|
546
|
+
:param _builtins.int cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
547
|
+
:param _builtins.int gpu_per_unit: Amount of GPU to allocate for headroom unit.
|
|
548
|
+
:param _builtins.int memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
|
|
549
|
+
:param _builtins.int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
551
550
|
"""
|
|
552
551
|
if cpu_per_unit is not None:
|
|
553
552
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -558,33 +557,33 @@ class OceanNpHeadroom(dict):
|
|
|
558
557
|
if num_of_units is not None:
|
|
559
558
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
560
559
|
|
|
561
|
-
@property
|
|
560
|
+
@_builtins.property
|
|
562
561
|
@pulumi.getter(name="cpuPerUnit")
|
|
563
|
-
def cpu_per_unit(self) -> Optional[
|
|
562
|
+
def cpu_per_unit(self) -> Optional[_builtins.int]:
|
|
564
563
|
"""
|
|
565
564
|
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
566
565
|
"""
|
|
567
566
|
return pulumi.get(self, "cpu_per_unit")
|
|
568
567
|
|
|
569
|
-
@property
|
|
568
|
+
@_builtins.property
|
|
570
569
|
@pulumi.getter(name="gpuPerUnit")
|
|
571
|
-
def gpu_per_unit(self) -> Optional[
|
|
570
|
+
def gpu_per_unit(self) -> Optional[_builtins.int]:
|
|
572
571
|
"""
|
|
573
572
|
Amount of GPU to allocate for headroom unit.
|
|
574
573
|
"""
|
|
575
574
|
return pulumi.get(self, "gpu_per_unit")
|
|
576
575
|
|
|
577
|
-
@property
|
|
576
|
+
@_builtins.property
|
|
578
577
|
@pulumi.getter(name="memoryPerUnit")
|
|
579
|
-
def memory_per_unit(self) -> Optional[
|
|
578
|
+
def memory_per_unit(self) -> Optional[_builtins.int]:
|
|
580
579
|
"""
|
|
581
580
|
Configure the amount of memory (MiB) to allocate the headroom.
|
|
582
581
|
"""
|
|
583
582
|
return pulumi.get(self, "memory_per_unit")
|
|
584
583
|
|
|
585
|
-
@property
|
|
584
|
+
@_builtins.property
|
|
586
585
|
@pulumi.getter(name="numOfUnits")
|
|
587
|
-
def num_of_units(self) -> Optional[
|
|
586
|
+
def num_of_units(self) -> Optional[_builtins.int]:
|
|
588
587
|
"""
|
|
589
588
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
590
589
|
"""
|
|
@@ -611,16 +610,16 @@ class OceanNpHealth(dict):
|
|
|
611
610
|
return super().get(key, default)
|
|
612
611
|
|
|
613
612
|
def __init__(__self__, *,
|
|
614
|
-
grace_period: Optional[
|
|
613
|
+
grace_period: Optional[_builtins.int] = None):
|
|
615
614
|
"""
|
|
616
|
-
:param
|
|
615
|
+
:param _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.
|
|
617
616
|
"""
|
|
618
617
|
if grace_period is not None:
|
|
619
618
|
pulumi.set(__self__, "grace_period", grace_period)
|
|
620
619
|
|
|
621
|
-
@property
|
|
620
|
+
@_builtins.property
|
|
622
621
|
@pulumi.getter(name="gracePeriod")
|
|
623
|
-
def grace_period(self) -> Optional[
|
|
622
|
+
def grace_period(self) -> Optional[_builtins.int]:
|
|
624
623
|
"""
|
|
625
624
|
The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
|
|
626
625
|
"""
|
|
@@ -637,7 +636,7 @@ class OceanNpLinuxOsConfig(dict):
|
|
|
637
636
|
if sysctls is not None:
|
|
638
637
|
pulumi.set(__self__, "sysctls", sysctls)
|
|
639
638
|
|
|
640
|
-
@property
|
|
639
|
+
@_builtins.property
|
|
641
640
|
@pulumi.getter
|
|
642
641
|
def sysctls(self) -> Optional[Sequence['outputs.OceanNpLinuxOsConfigSysctl']]:
|
|
643
642
|
"""
|
|
@@ -666,16 +665,16 @@ class OceanNpLinuxOsConfigSysctl(dict):
|
|
|
666
665
|
return super().get(key, default)
|
|
667
666
|
|
|
668
667
|
def __init__(__self__, *,
|
|
669
|
-
vm_max_map_count: Optional[
|
|
668
|
+
vm_max_map_count: Optional[_builtins.int] = None):
|
|
670
669
|
"""
|
|
671
|
-
:param
|
|
670
|
+
:param _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.
|
|
672
671
|
"""
|
|
673
672
|
if vm_max_map_count is not None:
|
|
674
673
|
pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
|
|
675
674
|
|
|
676
|
-
@property
|
|
675
|
+
@_builtins.property
|
|
677
676
|
@pulumi.getter(name="vmMaxMapCount")
|
|
678
|
-
def vm_max_map_count(self) -> Optional[
|
|
677
|
+
def vm_max_map_count(self) -> Optional[_builtins.int]:
|
|
679
678
|
"""
|
|
680
679
|
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
681
680
|
"""
|
|
@@ -692,7 +691,7 @@ class OceanNpLogging(dict):
|
|
|
692
691
|
if export is not None:
|
|
693
692
|
pulumi.set(__self__, "export", export)
|
|
694
693
|
|
|
695
|
-
@property
|
|
694
|
+
@_builtins.property
|
|
696
695
|
@pulumi.getter
|
|
697
696
|
def export(self) -> Optional['outputs.OceanNpLoggingExport']:
|
|
698
697
|
"""
|
|
@@ -728,7 +727,7 @@ class OceanNpLoggingExport(dict):
|
|
|
728
727
|
if azure_blobs is not None:
|
|
729
728
|
pulumi.set(__self__, "azure_blobs", azure_blobs)
|
|
730
729
|
|
|
731
|
-
@property
|
|
730
|
+
@_builtins.property
|
|
732
731
|
@pulumi.getter(name="azureBlobs")
|
|
733
732
|
def azure_blobs(self) -> Optional[Sequence['outputs.OceanNpLoggingExportAzureBlob']]:
|
|
734
733
|
"""
|
|
@@ -740,16 +739,16 @@ class OceanNpLoggingExport(dict):
|
|
|
740
739
|
@pulumi.output_type
|
|
741
740
|
class OceanNpLoggingExportAzureBlob(dict):
|
|
742
741
|
def __init__(__self__, *,
|
|
743
|
-
id: Optional[
|
|
742
|
+
id: Optional[_builtins.str] = None):
|
|
744
743
|
"""
|
|
745
|
-
:param
|
|
744
|
+
:param _builtins.str id: The identifier of The Azure Blob data integration to export the logs to.
|
|
746
745
|
"""
|
|
747
746
|
if id is not None:
|
|
748
747
|
pulumi.set(__self__, "id", id)
|
|
749
748
|
|
|
750
|
-
@property
|
|
749
|
+
@_builtins.property
|
|
751
750
|
@pulumi.getter
|
|
752
|
-
def id(self) -> Optional[
|
|
751
|
+
def id(self) -> Optional[_builtins.str]:
|
|
753
752
|
"""
|
|
754
753
|
The identifier of The Azure Blob data integration to export the logs to.
|
|
755
754
|
"""
|
|
@@ -791,7 +790,7 @@ class OceanNpScheduling(dict):
|
|
|
791
790
|
if tasks is not None:
|
|
792
791
|
pulumi.set(__self__, "tasks", tasks)
|
|
793
792
|
|
|
794
|
-
@property
|
|
793
|
+
@_builtins.property
|
|
795
794
|
@pulumi.getter(name="shutdownHours")
|
|
796
795
|
def shutdown_hours(self) -> Optional['outputs.OceanNpSchedulingShutdownHours']:
|
|
797
796
|
"""
|
|
@@ -799,12 +798,12 @@ class OceanNpScheduling(dict):
|
|
|
799
798
|
"""
|
|
800
799
|
return pulumi.get(self, "shutdown_hours")
|
|
801
800
|
|
|
802
|
-
@property
|
|
801
|
+
@_builtins.property
|
|
803
802
|
@pulumi.getter(name="suspensionHours")
|
|
804
803
|
def suspension_hours(self) -> Optional['outputs.OceanNpSchedulingSuspensionHours']:
|
|
805
804
|
return pulumi.get(self, "suspension_hours")
|
|
806
805
|
|
|
807
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
808
807
|
@pulumi.getter
|
|
809
808
|
def tasks(self) -> Optional[Sequence['outputs.OceanNpSchedulingTask']]:
|
|
810
809
|
return pulumi.get(self, "tasks")
|
|
@@ -832,24 +831,24 @@ class OceanNpSchedulingShutdownHours(dict):
|
|
|
832
831
|
return super().get(key, default)
|
|
833
832
|
|
|
834
833
|
def __init__(__self__, *,
|
|
835
|
-
is_enabled: Optional[
|
|
836
|
-
time_windows: Optional[Sequence[
|
|
834
|
+
is_enabled: Optional[_builtins.bool] = None,
|
|
835
|
+
time_windows: Optional[Sequence[_builtins.str]] = None):
|
|
837
836
|
"""
|
|
838
|
-
:param Sequence[
|
|
837
|
+
:param Sequence[_builtins.str] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
839
838
|
"""
|
|
840
839
|
if is_enabled is not None:
|
|
841
840
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
842
841
|
if time_windows is not None:
|
|
843
842
|
pulumi.set(__self__, "time_windows", time_windows)
|
|
844
843
|
|
|
845
|
-
@property
|
|
844
|
+
@_builtins.property
|
|
846
845
|
@pulumi.getter(name="isEnabled")
|
|
847
|
-
def is_enabled(self) -> Optional[
|
|
846
|
+
def is_enabled(self) -> Optional[_builtins.bool]:
|
|
848
847
|
return pulumi.get(self, "is_enabled")
|
|
849
848
|
|
|
850
|
-
@property
|
|
849
|
+
@_builtins.property
|
|
851
850
|
@pulumi.getter(name="timeWindows")
|
|
852
|
-
def time_windows(self) -> Optional[Sequence[
|
|
851
|
+
def time_windows(self) -> Optional[Sequence[_builtins.str]]:
|
|
853
852
|
"""
|
|
854
853
|
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
855
854
|
"""
|
|
@@ -878,24 +877,24 @@ class OceanNpSchedulingSuspensionHours(dict):
|
|
|
878
877
|
return super().get(key, default)
|
|
879
878
|
|
|
880
879
|
def __init__(__self__, *,
|
|
881
|
-
is_enabled: Optional[
|
|
882
|
-
time_windows: Optional[Sequence[
|
|
880
|
+
is_enabled: Optional[_builtins.bool] = None,
|
|
881
|
+
time_windows: Optional[Sequence[_builtins.str]] = None):
|
|
883
882
|
"""
|
|
884
|
-
:param Sequence[
|
|
883
|
+
:param Sequence[_builtins.str] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
885
884
|
"""
|
|
886
885
|
if is_enabled is not None:
|
|
887
886
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
888
887
|
if time_windows is not None:
|
|
889
888
|
pulumi.set(__self__, "time_windows", time_windows)
|
|
890
889
|
|
|
891
|
-
@property
|
|
890
|
+
@_builtins.property
|
|
892
891
|
@pulumi.getter(name="isEnabled")
|
|
893
|
-
def is_enabled(self) -> Optional[
|
|
892
|
+
def is_enabled(self) -> Optional[_builtins.bool]:
|
|
894
893
|
return pulumi.get(self, "is_enabled")
|
|
895
894
|
|
|
896
|
-
@property
|
|
895
|
+
@_builtins.property
|
|
897
896
|
@pulumi.getter(name="timeWindows")
|
|
898
|
-
def time_windows(self) -> Optional[Sequence[
|
|
897
|
+
def time_windows(self) -> Optional[Sequence[_builtins.str]]:
|
|
899
898
|
"""
|
|
900
899
|
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
901
900
|
"""
|
|
@@ -926,9 +925,9 @@ class OceanNpSchedulingTask(dict):
|
|
|
926
925
|
return super().get(key, default)
|
|
927
926
|
|
|
928
927
|
def __init__(__self__, *,
|
|
929
|
-
cron_expression:
|
|
930
|
-
is_enabled:
|
|
931
|
-
task_type:
|
|
928
|
+
cron_expression: _builtins.str,
|
|
929
|
+
is_enabled: _builtins.bool,
|
|
930
|
+
task_type: _builtins.str,
|
|
932
931
|
parameters: Optional['outputs.OceanNpSchedulingTaskParameters'] = None):
|
|
933
932
|
pulumi.set(__self__, "cron_expression", cron_expression)
|
|
934
933
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
@@ -936,22 +935,22 @@ class OceanNpSchedulingTask(dict):
|
|
|
936
935
|
if parameters is not None:
|
|
937
936
|
pulumi.set(__self__, "parameters", parameters)
|
|
938
937
|
|
|
939
|
-
@property
|
|
938
|
+
@_builtins.property
|
|
940
939
|
@pulumi.getter(name="cronExpression")
|
|
941
|
-
def cron_expression(self) ->
|
|
940
|
+
def cron_expression(self) -> _builtins.str:
|
|
942
941
|
return pulumi.get(self, "cron_expression")
|
|
943
942
|
|
|
944
|
-
@property
|
|
943
|
+
@_builtins.property
|
|
945
944
|
@pulumi.getter(name="isEnabled")
|
|
946
|
-
def is_enabled(self) ->
|
|
945
|
+
def is_enabled(self) -> _builtins.bool:
|
|
947
946
|
return pulumi.get(self, "is_enabled")
|
|
948
947
|
|
|
949
|
-
@property
|
|
948
|
+
@_builtins.property
|
|
950
949
|
@pulumi.getter(name="taskType")
|
|
951
|
-
def task_type(self) ->
|
|
950
|
+
def task_type(self) -> _builtins.str:
|
|
952
951
|
return pulumi.get(self, "task_type")
|
|
953
952
|
|
|
954
|
-
@property
|
|
953
|
+
@_builtins.property
|
|
955
954
|
@pulumi.getter
|
|
956
955
|
def parameters(self) -> Optional['outputs.OceanNpSchedulingTaskParameters']:
|
|
957
956
|
return pulumi.get(self, "parameters")
|
|
@@ -986,12 +985,12 @@ class OceanNpSchedulingTaskParameters(dict):
|
|
|
986
985
|
if parameters_upgrade_config is not None:
|
|
987
986
|
pulumi.set(__self__, "parameters_upgrade_config", parameters_upgrade_config)
|
|
988
987
|
|
|
989
|
-
@property
|
|
988
|
+
@_builtins.property
|
|
990
989
|
@pulumi.getter(name="parametersClusterRoll")
|
|
991
990
|
def parameters_cluster_roll(self) -> Optional['outputs.OceanNpSchedulingTaskParametersParametersClusterRoll']:
|
|
992
991
|
return pulumi.get(self, "parameters_cluster_roll")
|
|
993
992
|
|
|
994
|
-
@property
|
|
993
|
+
@_builtins.property
|
|
995
994
|
@pulumi.getter(name="parametersUpgradeConfig")
|
|
996
995
|
def parameters_upgrade_config(self) -> Optional['outputs.OceanNpSchedulingTaskParametersParametersUpgradeConfig']:
|
|
997
996
|
return pulumi.get(self, "parameters_upgrade_config")
|
|
@@ -1025,19 +1024,19 @@ class OceanNpSchedulingTaskParametersParametersClusterRoll(dict):
|
|
|
1025
1024
|
return super().get(key, default)
|
|
1026
1025
|
|
|
1027
1026
|
def __init__(__self__, *,
|
|
1028
|
-
batch_min_healthy_percentage: Optional[
|
|
1029
|
-
batch_size_percentage: Optional[
|
|
1030
|
-
comment: Optional[
|
|
1031
|
-
respect_pdb: Optional[
|
|
1032
|
-
respect_restrict_scale_down: Optional[
|
|
1033
|
-
vng_ids: Optional[Sequence[
|
|
1034
|
-
"""
|
|
1035
|
-
:param
|
|
1036
|
-
:param
|
|
1037
|
-
:param
|
|
1038
|
-
:param
|
|
1039
|
-
:param
|
|
1040
|
-
:param Sequence[
|
|
1027
|
+
batch_min_healthy_percentage: Optional[_builtins.int] = None,
|
|
1028
|
+
batch_size_percentage: Optional[_builtins.int] = None,
|
|
1029
|
+
comment: Optional[_builtins.str] = None,
|
|
1030
|
+
respect_pdb: Optional[_builtins.bool] = None,
|
|
1031
|
+
respect_restrict_scale_down: Optional[_builtins.bool] = None,
|
|
1032
|
+
vng_ids: Optional[Sequence[_builtins.str]] = None):
|
|
1033
|
+
"""
|
|
1034
|
+
:param _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.
|
|
1035
|
+
:param _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%.
|
|
1036
|
+
:param _builtins.str comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1037
|
+
:param _builtins.bool respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1038
|
+
:param _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.
|
|
1039
|
+
:param Sequence[_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.
|
|
1041
1040
|
"""
|
|
1042
1041
|
if batch_min_healthy_percentage is not None:
|
|
1043
1042
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -1052,49 +1051,49 @@ class OceanNpSchedulingTaskParametersParametersClusterRoll(dict):
|
|
|
1052
1051
|
if vng_ids is not None:
|
|
1053
1052
|
pulumi.set(__self__, "vng_ids", vng_ids)
|
|
1054
1053
|
|
|
1055
|
-
@property
|
|
1054
|
+
@_builtins.property
|
|
1056
1055
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1057
|
-
def batch_min_healthy_percentage(self) -> Optional[
|
|
1056
|
+
def batch_min_healthy_percentage(self) -> Optional[_builtins.int]:
|
|
1058
1057
|
"""
|
|
1059
1058
|
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.
|
|
1060
1059
|
"""
|
|
1061
1060
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1062
1061
|
|
|
1063
|
-
@property
|
|
1062
|
+
@_builtins.property
|
|
1064
1063
|
@pulumi.getter(name="batchSizePercentage")
|
|
1065
|
-
def batch_size_percentage(self) -> Optional[
|
|
1064
|
+
def batch_size_percentage(self) -> Optional[_builtins.int]:
|
|
1066
1065
|
"""
|
|
1067
1066
|
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%.
|
|
1068
1067
|
"""
|
|
1069
1068
|
return pulumi.get(self, "batch_size_percentage")
|
|
1070
1069
|
|
|
1071
|
-
@property
|
|
1070
|
+
@_builtins.property
|
|
1072
1071
|
@pulumi.getter
|
|
1073
|
-
def comment(self) -> Optional[
|
|
1072
|
+
def comment(self) -> Optional[_builtins.str]:
|
|
1074
1073
|
"""
|
|
1075
1074
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1076
1075
|
"""
|
|
1077
1076
|
return pulumi.get(self, "comment")
|
|
1078
1077
|
|
|
1079
|
-
@property
|
|
1078
|
+
@_builtins.property
|
|
1080
1079
|
@pulumi.getter(name="respectPdb")
|
|
1081
|
-
def respect_pdb(self) -> Optional[
|
|
1080
|
+
def respect_pdb(self) -> Optional[_builtins.bool]:
|
|
1082
1081
|
"""
|
|
1083
1082
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1084
1083
|
"""
|
|
1085
1084
|
return pulumi.get(self, "respect_pdb")
|
|
1086
1085
|
|
|
1087
|
-
@property
|
|
1086
|
+
@_builtins.property
|
|
1088
1087
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
1089
|
-
def respect_restrict_scale_down(self) -> Optional[
|
|
1088
|
+
def respect_restrict_scale_down(self) -> Optional[_builtins.bool]:
|
|
1090
1089
|
"""
|
|
1091
1090
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1092
1091
|
"""
|
|
1093
1092
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
1094
1093
|
|
|
1095
|
-
@property
|
|
1094
|
+
@_builtins.property
|
|
1096
1095
|
@pulumi.getter(name="vngIds")
|
|
1097
|
-
def vng_ids(self) -> Optional[Sequence[
|
|
1096
|
+
def vng_ids(self) -> Optional[Sequence[_builtins.str]]:
|
|
1098
1097
|
"""
|
|
1099
1098
|
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.
|
|
1100
1099
|
"""
|
|
@@ -1125,9 +1124,9 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfig(dict):
|
|
|
1125
1124
|
return super().get(key, default)
|
|
1126
1125
|
|
|
1127
1126
|
def __init__(__self__, *,
|
|
1128
|
-
apply_roll: Optional[
|
|
1127
|
+
apply_roll: Optional[_builtins.bool] = None,
|
|
1129
1128
|
roll_parameters: Optional['outputs.OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParameters'] = None,
|
|
1130
|
-
scope_version: Optional[
|
|
1129
|
+
scope_version: Optional[_builtins.str] = None):
|
|
1131
1130
|
if apply_roll is not None:
|
|
1132
1131
|
pulumi.set(__self__, "apply_roll", apply_roll)
|
|
1133
1132
|
if roll_parameters is not None:
|
|
@@ -1135,19 +1134,19 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfig(dict):
|
|
|
1135
1134
|
if scope_version is not None:
|
|
1136
1135
|
pulumi.set(__self__, "scope_version", scope_version)
|
|
1137
1136
|
|
|
1138
|
-
@property
|
|
1137
|
+
@_builtins.property
|
|
1139
1138
|
@pulumi.getter(name="applyRoll")
|
|
1140
|
-
def apply_roll(self) -> Optional[
|
|
1139
|
+
def apply_roll(self) -> Optional[_builtins.bool]:
|
|
1141
1140
|
return pulumi.get(self, "apply_roll")
|
|
1142
1141
|
|
|
1143
|
-
@property
|
|
1142
|
+
@_builtins.property
|
|
1144
1143
|
@pulumi.getter(name="rollParameters")
|
|
1145
1144
|
def roll_parameters(self) -> Optional['outputs.OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParameters']:
|
|
1146
1145
|
return pulumi.get(self, "roll_parameters")
|
|
1147
1146
|
|
|
1148
|
-
@property
|
|
1147
|
+
@_builtins.property
|
|
1149
1148
|
@pulumi.getter(name="scopeVersion")
|
|
1150
|
-
def scope_version(self) -> Optional[
|
|
1149
|
+
def scope_version(self) -> Optional[_builtins.str]:
|
|
1151
1150
|
return pulumi.get(self, "scope_version")
|
|
1152
1151
|
|
|
1153
1152
|
|
|
@@ -1177,17 +1176,17 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParameters(dict)
|
|
|
1177
1176
|
return super().get(key, default)
|
|
1178
1177
|
|
|
1179
1178
|
def __init__(__self__, *,
|
|
1180
|
-
batch_min_healthy_percentage: Optional[
|
|
1181
|
-
batch_size_percentage: Optional[
|
|
1182
|
-
comment: Optional[
|
|
1183
|
-
respect_pdb: Optional[
|
|
1184
|
-
respect_restrict_scale_down: Optional[
|
|
1185
|
-
"""
|
|
1186
|
-
:param
|
|
1187
|
-
:param
|
|
1188
|
-
:param
|
|
1189
|
-
:param
|
|
1190
|
-
:param
|
|
1179
|
+
batch_min_healthy_percentage: Optional[_builtins.int] = None,
|
|
1180
|
+
batch_size_percentage: Optional[_builtins.int] = None,
|
|
1181
|
+
comment: Optional[_builtins.str] = None,
|
|
1182
|
+
respect_pdb: Optional[_builtins.bool] = None,
|
|
1183
|
+
respect_restrict_scale_down: Optional[_builtins.bool] = None):
|
|
1184
|
+
"""
|
|
1185
|
+
:param _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.
|
|
1186
|
+
:param _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%.
|
|
1187
|
+
:param _builtins.str comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1188
|
+
:param _builtins.bool respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1189
|
+
:param _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.
|
|
1191
1190
|
"""
|
|
1192
1191
|
if batch_min_healthy_percentage is not None:
|
|
1193
1192
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -1200,41 +1199,41 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParameters(dict)
|
|
|
1200
1199
|
if respect_restrict_scale_down is not None:
|
|
1201
1200
|
pulumi.set(__self__, "respect_restrict_scale_down", respect_restrict_scale_down)
|
|
1202
1201
|
|
|
1203
|
-
@property
|
|
1202
|
+
@_builtins.property
|
|
1204
1203
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1205
|
-
def batch_min_healthy_percentage(self) -> Optional[
|
|
1204
|
+
def batch_min_healthy_percentage(self) -> Optional[_builtins.int]:
|
|
1206
1205
|
"""
|
|
1207
1206
|
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.
|
|
1208
1207
|
"""
|
|
1209
1208
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1210
1209
|
|
|
1211
|
-
@property
|
|
1210
|
+
@_builtins.property
|
|
1212
1211
|
@pulumi.getter(name="batchSizePercentage")
|
|
1213
|
-
def batch_size_percentage(self) -> Optional[
|
|
1212
|
+
def batch_size_percentage(self) -> Optional[_builtins.int]:
|
|
1214
1213
|
"""
|
|
1215
1214
|
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%.
|
|
1216
1215
|
"""
|
|
1217
1216
|
return pulumi.get(self, "batch_size_percentage")
|
|
1218
1217
|
|
|
1219
|
-
@property
|
|
1218
|
+
@_builtins.property
|
|
1220
1219
|
@pulumi.getter
|
|
1221
|
-
def comment(self) -> Optional[
|
|
1220
|
+
def comment(self) -> Optional[_builtins.str]:
|
|
1222
1221
|
"""
|
|
1223
1222
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1224
1223
|
"""
|
|
1225
1224
|
return pulumi.get(self, "comment")
|
|
1226
1225
|
|
|
1227
|
-
@property
|
|
1226
|
+
@_builtins.property
|
|
1228
1227
|
@pulumi.getter(name="respectPdb")
|
|
1229
|
-
def respect_pdb(self) -> Optional[
|
|
1228
|
+
def respect_pdb(self) -> Optional[_builtins.bool]:
|
|
1230
1229
|
"""
|
|
1231
1230
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1232
1231
|
"""
|
|
1233
1232
|
return pulumi.get(self, "respect_pdb")
|
|
1234
1233
|
|
|
1235
|
-
@property
|
|
1234
|
+
@_builtins.property
|
|
1236
1235
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
1237
|
-
def respect_restrict_scale_down(self) -> Optional[
|
|
1236
|
+
def respect_restrict_scale_down(self) -> Optional[_builtins.bool]:
|
|
1238
1237
|
"""
|
|
1239
1238
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1240
1239
|
"""
|
|
@@ -1244,37 +1243,37 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParameters(dict)
|
|
|
1244
1243
|
@pulumi.output_type
|
|
1245
1244
|
class OceanNpTaint(dict):
|
|
1246
1245
|
def __init__(__self__, *,
|
|
1247
|
-
effect:
|
|
1248
|
-
key:
|
|
1249
|
-
value:
|
|
1246
|
+
effect: _builtins.str,
|
|
1247
|
+
key: _builtins.str,
|
|
1248
|
+
value: _builtins.str):
|
|
1250
1249
|
"""
|
|
1251
|
-
:param
|
|
1252
|
-
:param
|
|
1253
|
-
:param
|
|
1250
|
+
:param _builtins.str effect: Set taint effect.
|
|
1251
|
+
:param _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"]
|
|
1252
|
+
:param _builtins.str value: Set taint value.
|
|
1254
1253
|
"""
|
|
1255
1254
|
pulumi.set(__self__, "effect", effect)
|
|
1256
1255
|
pulumi.set(__self__, "key", key)
|
|
1257
1256
|
pulumi.set(__self__, "value", value)
|
|
1258
1257
|
|
|
1259
|
-
@property
|
|
1258
|
+
@_builtins.property
|
|
1260
1259
|
@pulumi.getter
|
|
1261
|
-
def effect(self) ->
|
|
1260
|
+
def effect(self) -> _builtins.str:
|
|
1262
1261
|
"""
|
|
1263
1262
|
Set taint effect.
|
|
1264
1263
|
"""
|
|
1265
1264
|
return pulumi.get(self, "effect")
|
|
1266
1265
|
|
|
1267
|
-
@property
|
|
1266
|
+
@_builtins.property
|
|
1268
1267
|
@pulumi.getter
|
|
1269
|
-
def key(self) ->
|
|
1268
|
+
def key(self) -> _builtins.str:
|
|
1270
1269
|
"""
|
|
1271
1270
|
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"]
|
|
1272
1271
|
"""
|
|
1273
1272
|
return pulumi.get(self, "key")
|
|
1274
1273
|
|
|
1275
|
-
@property
|
|
1274
|
+
@_builtins.property
|
|
1276
1275
|
@pulumi.getter
|
|
1277
|
-
def value(self) ->
|
|
1276
|
+
def value(self) -> _builtins.str:
|
|
1278
1277
|
"""
|
|
1279
1278
|
Set taint value.
|
|
1280
1279
|
"""
|
|
@@ -1305,12 +1304,12 @@ class OceanNpUpdatePolicy(dict):
|
|
|
1305
1304
|
return super().get(key, default)
|
|
1306
1305
|
|
|
1307
1306
|
def __init__(__self__, *,
|
|
1308
|
-
should_roll:
|
|
1309
|
-
conditioned_roll: Optional[
|
|
1307
|
+
should_roll: _builtins.bool,
|
|
1308
|
+
conditioned_roll: Optional[_builtins.bool] = None,
|
|
1310
1309
|
roll_config: Optional['outputs.OceanNpUpdatePolicyRollConfig'] = None):
|
|
1311
1310
|
"""
|
|
1312
|
-
:param
|
|
1313
|
-
:param
|
|
1311
|
+
:param _builtins.bool should_roll: If set to true along with the cluster update, roll will be triggered.
|
|
1312
|
+
:param _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).
|
|
1314
1313
|
:param 'OceanNpUpdatePolicyRollConfigArgs' roll_config: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
1315
1314
|
"""
|
|
1316
1315
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
@@ -1319,23 +1318,23 @@ class OceanNpUpdatePolicy(dict):
|
|
|
1319
1318
|
if roll_config is not None:
|
|
1320
1319
|
pulumi.set(__self__, "roll_config", roll_config)
|
|
1321
1320
|
|
|
1322
|
-
@property
|
|
1321
|
+
@_builtins.property
|
|
1323
1322
|
@pulumi.getter(name="shouldRoll")
|
|
1324
|
-
def should_roll(self) ->
|
|
1323
|
+
def should_roll(self) -> _builtins.bool:
|
|
1325
1324
|
"""
|
|
1326
1325
|
If set to true along with the cluster update, roll will be triggered.
|
|
1327
1326
|
"""
|
|
1328
1327
|
return pulumi.get(self, "should_roll")
|
|
1329
1328
|
|
|
1330
|
-
@property
|
|
1329
|
+
@_builtins.property
|
|
1331
1330
|
@pulumi.getter(name="conditionedRoll")
|
|
1332
|
-
def conditioned_roll(self) -> Optional[
|
|
1331
|
+
def conditioned_roll(self) -> Optional[_builtins.bool]:
|
|
1333
1332
|
"""
|
|
1334
1333
|
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).
|
|
1335
1334
|
"""
|
|
1336
1335
|
return pulumi.get(self, "conditioned_roll")
|
|
1337
1336
|
|
|
1338
|
-
@property
|
|
1337
|
+
@_builtins.property
|
|
1339
1338
|
@pulumi.getter(name="rollConfig")
|
|
1340
1339
|
def roll_config(self) -> Optional['outputs.OceanNpUpdatePolicyRollConfig']:
|
|
1341
1340
|
"""
|
|
@@ -1376,23 +1375,23 @@ class OceanNpUpdatePolicyRollConfig(dict):
|
|
|
1376
1375
|
return super().get(key, default)
|
|
1377
1376
|
|
|
1378
1377
|
def __init__(__self__, *,
|
|
1379
|
-
batch_min_healthy_percentage: Optional[
|
|
1380
|
-
batch_size_percentage: Optional[
|
|
1381
|
-
comment: Optional[
|
|
1382
|
-
node_names: Optional[Sequence[
|
|
1383
|
-
node_pool_names: Optional[Sequence[
|
|
1384
|
-
respect_pdb: Optional[
|
|
1385
|
-
respect_restrict_scale_down: Optional[
|
|
1386
|
-
vng_ids: Optional[Sequence[
|
|
1387
|
-
"""
|
|
1388
|
-
:param
|
|
1389
|
-
:param
|
|
1390
|
-
:param
|
|
1391
|
-
:param Sequence[
|
|
1392
|
-
:param Sequence[
|
|
1393
|
-
:param
|
|
1394
|
-
:param
|
|
1395
|
-
:param Sequence[
|
|
1378
|
+
batch_min_healthy_percentage: Optional[_builtins.int] = None,
|
|
1379
|
+
batch_size_percentage: Optional[_builtins.int] = None,
|
|
1380
|
+
comment: Optional[_builtins.str] = None,
|
|
1381
|
+
node_names: Optional[Sequence[_builtins.str]] = None,
|
|
1382
|
+
node_pool_names: Optional[Sequence[_builtins.str]] = None,
|
|
1383
|
+
respect_pdb: Optional[_builtins.bool] = None,
|
|
1384
|
+
respect_restrict_scale_down: Optional[_builtins.bool] = None,
|
|
1385
|
+
vng_ids: Optional[Sequence[_builtins.str]] = None):
|
|
1386
|
+
"""
|
|
1387
|
+
:param _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.
|
|
1388
|
+
:param _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%.
|
|
1389
|
+
:param _builtins.str comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1390
|
+
:param Sequence[_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.
|
|
1391
|
+
:param Sequence[_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.
|
|
1392
|
+
:param _builtins.bool respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1393
|
+
:param _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.
|
|
1394
|
+
:param Sequence[_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.
|
|
1396
1395
|
"""
|
|
1397
1396
|
if batch_min_healthy_percentage is not None:
|
|
1398
1397
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -1411,65 +1410,65 @@ class OceanNpUpdatePolicyRollConfig(dict):
|
|
|
1411
1410
|
if vng_ids is not None:
|
|
1412
1411
|
pulumi.set(__self__, "vng_ids", vng_ids)
|
|
1413
1412
|
|
|
1414
|
-
@property
|
|
1413
|
+
@_builtins.property
|
|
1415
1414
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1416
|
-
def batch_min_healthy_percentage(self) -> Optional[
|
|
1415
|
+
def batch_min_healthy_percentage(self) -> Optional[_builtins.int]:
|
|
1417
1416
|
"""
|
|
1418
1417
|
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.
|
|
1419
1418
|
"""
|
|
1420
1419
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1421
1420
|
|
|
1422
|
-
@property
|
|
1421
|
+
@_builtins.property
|
|
1423
1422
|
@pulumi.getter(name="batchSizePercentage")
|
|
1424
|
-
def batch_size_percentage(self) -> Optional[
|
|
1423
|
+
def batch_size_percentage(self) -> Optional[_builtins.int]:
|
|
1425
1424
|
"""
|
|
1426
1425
|
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%.
|
|
1427
1426
|
"""
|
|
1428
1427
|
return pulumi.get(self, "batch_size_percentage")
|
|
1429
1428
|
|
|
1430
|
-
@property
|
|
1429
|
+
@_builtins.property
|
|
1431
1430
|
@pulumi.getter
|
|
1432
|
-
def comment(self) -> Optional[
|
|
1431
|
+
def comment(self) -> Optional[_builtins.str]:
|
|
1433
1432
|
"""
|
|
1434
1433
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1435
1434
|
"""
|
|
1436
1435
|
return pulumi.get(self, "comment")
|
|
1437
1436
|
|
|
1438
|
-
@property
|
|
1437
|
+
@_builtins.property
|
|
1439
1438
|
@pulumi.getter(name="nodeNames")
|
|
1440
|
-
def node_names(self) -> Optional[Sequence[
|
|
1439
|
+
def node_names(self) -> Optional[Sequence[_builtins.str]]:
|
|
1441
1440
|
"""
|
|
1442
1441
|
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.
|
|
1443
1442
|
"""
|
|
1444
1443
|
return pulumi.get(self, "node_names")
|
|
1445
1444
|
|
|
1446
|
-
@property
|
|
1445
|
+
@_builtins.property
|
|
1447
1446
|
@pulumi.getter(name="nodePoolNames")
|
|
1448
|
-
def node_pool_names(self) -> Optional[Sequence[
|
|
1447
|
+
def node_pool_names(self) -> Optional[Sequence[_builtins.str]]:
|
|
1449
1448
|
"""
|
|
1450
1449
|
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.
|
|
1451
1450
|
"""
|
|
1452
1451
|
return pulumi.get(self, "node_pool_names")
|
|
1453
1452
|
|
|
1454
|
-
@property
|
|
1453
|
+
@_builtins.property
|
|
1455
1454
|
@pulumi.getter(name="respectPdb")
|
|
1456
|
-
def respect_pdb(self) -> Optional[
|
|
1455
|
+
def respect_pdb(self) -> Optional[_builtins.bool]:
|
|
1457
1456
|
"""
|
|
1458
1457
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1459
1458
|
"""
|
|
1460
1459
|
return pulumi.get(self, "respect_pdb")
|
|
1461
1460
|
|
|
1462
|
-
@property
|
|
1461
|
+
@_builtins.property
|
|
1463
1462
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
1464
|
-
def respect_restrict_scale_down(self) -> Optional[
|
|
1463
|
+
def respect_restrict_scale_down(self) -> Optional[_builtins.bool]:
|
|
1465
1464
|
"""
|
|
1466
1465
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1467
1466
|
"""
|
|
1468
1467
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
1469
1468
|
|
|
1470
|
-
@property
|
|
1469
|
+
@_builtins.property
|
|
1471
1470
|
@pulumi.getter(name="vngIds")
|
|
1472
|
-
def vng_ids(self) -> Optional[Sequence[
|
|
1471
|
+
def vng_ids(self) -> Optional[Sequence[_builtins.str]]:
|
|
1473
1472
|
"""
|
|
1474
1473
|
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.
|
|
1475
1474
|
"""
|
|
@@ -1520,37 +1519,37 @@ class OceanNpVirtualNodeGroupFilters(dict):
|
|
|
1520
1519
|
return super().get(key, default)
|
|
1521
1520
|
|
|
1522
1521
|
def __init__(__self__, *,
|
|
1523
|
-
accelerated_networking: Optional[
|
|
1524
|
-
architectures: Optional[Sequence[
|
|
1525
|
-
disk_performance: Optional[
|
|
1526
|
-
exclude_series: Optional[Sequence[
|
|
1527
|
-
gpu_types: Optional[Sequence[
|
|
1528
|
-
max_gpu: Optional[
|
|
1529
|
-
max_memory_gib: Optional[
|
|
1530
|
-
max_vcpu: Optional[
|
|
1531
|
-
min_disk: Optional[
|
|
1532
|
-
min_gpu: Optional[
|
|
1533
|
-
min_memory_gib: Optional[
|
|
1534
|
-
min_nics: Optional[
|
|
1535
|
-
min_vcpu: Optional[
|
|
1536
|
-
series: Optional[Sequence[
|
|
1537
|
-
vm_types: Optional[Sequence[
|
|
1538
|
-
"""
|
|
1539
|
-
:param
|
|
1540
|
-
:param Sequence[
|
|
1541
|
-
:param
|
|
1542
|
-
:param Sequence[
|
|
1543
|
-
:param Sequence[
|
|
1544
|
-
:param
|
|
1545
|
-
:param
|
|
1546
|
-
:param
|
|
1547
|
-
:param
|
|
1548
|
-
:param
|
|
1549
|
-
:param
|
|
1550
|
-
:param
|
|
1551
|
-
:param
|
|
1552
|
-
:param Sequence[
|
|
1553
|
-
:param Sequence[
|
|
1522
|
+
accelerated_networking: Optional[_builtins.str] = None,
|
|
1523
|
+
architectures: Optional[Sequence[_builtins.str]] = None,
|
|
1524
|
+
disk_performance: Optional[_builtins.str] = None,
|
|
1525
|
+
exclude_series: Optional[Sequence[_builtins.str]] = None,
|
|
1526
|
+
gpu_types: Optional[Sequence[_builtins.str]] = None,
|
|
1527
|
+
max_gpu: Optional[_builtins.float] = None,
|
|
1528
|
+
max_memory_gib: Optional[_builtins.float] = None,
|
|
1529
|
+
max_vcpu: Optional[_builtins.int] = None,
|
|
1530
|
+
min_disk: Optional[_builtins.int] = None,
|
|
1531
|
+
min_gpu: Optional[_builtins.float] = None,
|
|
1532
|
+
min_memory_gib: Optional[_builtins.float] = None,
|
|
1533
|
+
min_nics: Optional[_builtins.int] = None,
|
|
1534
|
+
min_vcpu: Optional[_builtins.int] = None,
|
|
1535
|
+
series: Optional[Sequence[_builtins.str]] = None,
|
|
1536
|
+
vm_types: Optional[Sequence[_builtins.str]] = None):
|
|
1537
|
+
"""
|
|
1538
|
+
:param _builtins.str accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
1539
|
+
:param Sequence[_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.
|
|
1540
|
+
:param _builtins.str disk_performance: The filtered vm sizes will support at least one of the classes from this list.
|
|
1541
|
+
:param Sequence[_builtins.str] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling.
|
|
1542
|
+
:param Sequence[_builtins.str] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
|
|
1543
|
+
:param _builtins.float max_gpu: Maximum number of GPUs available.
|
|
1544
|
+
:param _builtins.float max_memory_gib: Maximum amount of Memory (GiB).
|
|
1545
|
+
:param _builtins.int max_vcpu: Maximum number of vcpus available.
|
|
1546
|
+
:param _builtins.int min_disk: Minimum number of data disks available.
|
|
1547
|
+
:param _builtins.float min_gpu: Minimum number of GPUs available.
|
|
1548
|
+
:param _builtins.float min_memory_gib: Minimum amount of Memory (GiB).
|
|
1549
|
+
:param _builtins.int min_nics: Minimum number of network interfaces.
|
|
1550
|
+
:param _builtins.int min_vcpu: Minimum number of vcpus available.
|
|
1551
|
+
:param Sequence[_builtins.str] series: Vm sizes belonging to a series from the list will be available for scaling.
|
|
1552
|
+
:param Sequence[_builtins.str] vm_types: The filtered vm types will belong to one of the vm types from this list.
|
|
1554
1553
|
"""
|
|
1555
1554
|
if accelerated_networking is not None:
|
|
1556
1555
|
pulumi.set(__self__, "accelerated_networking", accelerated_networking)
|
|
@@ -1583,121 +1582,121 @@ class OceanNpVirtualNodeGroupFilters(dict):
|
|
|
1583
1582
|
if vm_types is not None:
|
|
1584
1583
|
pulumi.set(__self__, "vm_types", vm_types)
|
|
1585
1584
|
|
|
1586
|
-
@property
|
|
1585
|
+
@_builtins.property
|
|
1587
1586
|
@pulumi.getter(name="acceleratedNetworking")
|
|
1588
|
-
def accelerated_networking(self) -> Optional[
|
|
1587
|
+
def accelerated_networking(self) -> Optional[_builtins.str]:
|
|
1589
1588
|
"""
|
|
1590
1589
|
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
1591
1590
|
"""
|
|
1592
1591
|
return pulumi.get(self, "accelerated_networking")
|
|
1593
1592
|
|
|
1594
|
-
@property
|
|
1593
|
+
@_builtins.property
|
|
1595
1594
|
@pulumi.getter
|
|
1596
|
-
def architectures(self) -> Optional[Sequence[
|
|
1595
|
+
def architectures(self) -> Optional[Sequence[_builtins.str]]:
|
|
1597
1596
|
"""
|
|
1598
1597
|
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
1599
1598
|
"""
|
|
1600
1599
|
return pulumi.get(self, "architectures")
|
|
1601
1600
|
|
|
1602
|
-
@property
|
|
1601
|
+
@_builtins.property
|
|
1603
1602
|
@pulumi.getter(name="diskPerformance")
|
|
1604
|
-
def disk_performance(self) -> Optional[
|
|
1603
|
+
def disk_performance(self) -> Optional[_builtins.str]:
|
|
1605
1604
|
"""
|
|
1606
1605
|
The filtered vm sizes will support at least one of the classes from this list.
|
|
1607
1606
|
"""
|
|
1608
1607
|
return pulumi.get(self, "disk_performance")
|
|
1609
1608
|
|
|
1610
|
-
@property
|
|
1609
|
+
@_builtins.property
|
|
1611
1610
|
@pulumi.getter(name="excludeSeries")
|
|
1612
|
-
def exclude_series(self) -> Optional[Sequence[
|
|
1611
|
+
def exclude_series(self) -> Optional[Sequence[_builtins.str]]:
|
|
1613
1612
|
"""
|
|
1614
1613
|
Vm sizes belonging to a series from the list will not be available for scaling.
|
|
1615
1614
|
"""
|
|
1616
1615
|
return pulumi.get(self, "exclude_series")
|
|
1617
1616
|
|
|
1618
|
-
@property
|
|
1617
|
+
@_builtins.property
|
|
1619
1618
|
@pulumi.getter(name="gpuTypes")
|
|
1620
|
-
def gpu_types(self) -> Optional[Sequence[
|
|
1619
|
+
def gpu_types(self) -> Optional[Sequence[_builtins.str]]:
|
|
1621
1620
|
"""
|
|
1622
1621
|
The filtered gpu types will belong to one of the gpu types from this list.
|
|
1623
1622
|
"""
|
|
1624
1623
|
return pulumi.get(self, "gpu_types")
|
|
1625
1624
|
|
|
1626
|
-
@property
|
|
1625
|
+
@_builtins.property
|
|
1627
1626
|
@pulumi.getter(name="maxGpu")
|
|
1628
|
-
def max_gpu(self) -> Optional[
|
|
1627
|
+
def max_gpu(self) -> Optional[_builtins.float]:
|
|
1629
1628
|
"""
|
|
1630
1629
|
Maximum number of GPUs available.
|
|
1631
1630
|
"""
|
|
1632
1631
|
return pulumi.get(self, "max_gpu")
|
|
1633
1632
|
|
|
1634
|
-
@property
|
|
1633
|
+
@_builtins.property
|
|
1635
1634
|
@pulumi.getter(name="maxMemoryGib")
|
|
1636
|
-
def max_memory_gib(self) -> Optional[
|
|
1635
|
+
def max_memory_gib(self) -> Optional[_builtins.float]:
|
|
1637
1636
|
"""
|
|
1638
1637
|
Maximum amount of Memory (GiB).
|
|
1639
1638
|
"""
|
|
1640
1639
|
return pulumi.get(self, "max_memory_gib")
|
|
1641
1640
|
|
|
1642
|
-
@property
|
|
1641
|
+
@_builtins.property
|
|
1643
1642
|
@pulumi.getter(name="maxVcpu")
|
|
1644
|
-
def max_vcpu(self) -> Optional[
|
|
1643
|
+
def max_vcpu(self) -> Optional[_builtins.int]:
|
|
1645
1644
|
"""
|
|
1646
1645
|
Maximum number of vcpus available.
|
|
1647
1646
|
"""
|
|
1648
1647
|
return pulumi.get(self, "max_vcpu")
|
|
1649
1648
|
|
|
1650
|
-
@property
|
|
1649
|
+
@_builtins.property
|
|
1651
1650
|
@pulumi.getter(name="minDisk")
|
|
1652
|
-
def min_disk(self) -> Optional[
|
|
1651
|
+
def min_disk(self) -> Optional[_builtins.int]:
|
|
1653
1652
|
"""
|
|
1654
1653
|
Minimum number of data disks available.
|
|
1655
1654
|
"""
|
|
1656
1655
|
return pulumi.get(self, "min_disk")
|
|
1657
1656
|
|
|
1658
|
-
@property
|
|
1657
|
+
@_builtins.property
|
|
1659
1658
|
@pulumi.getter(name="minGpu")
|
|
1660
|
-
def min_gpu(self) -> Optional[
|
|
1659
|
+
def min_gpu(self) -> Optional[_builtins.float]:
|
|
1661
1660
|
"""
|
|
1662
1661
|
Minimum number of GPUs available.
|
|
1663
1662
|
"""
|
|
1664
1663
|
return pulumi.get(self, "min_gpu")
|
|
1665
1664
|
|
|
1666
|
-
@property
|
|
1665
|
+
@_builtins.property
|
|
1667
1666
|
@pulumi.getter(name="minMemoryGib")
|
|
1668
|
-
def min_memory_gib(self) -> Optional[
|
|
1667
|
+
def min_memory_gib(self) -> Optional[_builtins.float]:
|
|
1669
1668
|
"""
|
|
1670
1669
|
Minimum amount of Memory (GiB).
|
|
1671
1670
|
"""
|
|
1672
1671
|
return pulumi.get(self, "min_memory_gib")
|
|
1673
1672
|
|
|
1674
|
-
@property
|
|
1673
|
+
@_builtins.property
|
|
1675
1674
|
@pulumi.getter(name="minNics")
|
|
1676
|
-
def min_nics(self) -> Optional[
|
|
1675
|
+
def min_nics(self) -> Optional[_builtins.int]:
|
|
1677
1676
|
"""
|
|
1678
1677
|
Minimum number of network interfaces.
|
|
1679
1678
|
"""
|
|
1680
1679
|
return pulumi.get(self, "min_nics")
|
|
1681
1680
|
|
|
1682
|
-
@property
|
|
1681
|
+
@_builtins.property
|
|
1683
1682
|
@pulumi.getter(name="minVcpu")
|
|
1684
|
-
def min_vcpu(self) -> Optional[
|
|
1683
|
+
def min_vcpu(self) -> Optional[_builtins.int]:
|
|
1685
1684
|
"""
|
|
1686
1685
|
Minimum number of vcpus available.
|
|
1687
1686
|
"""
|
|
1688
1687
|
return pulumi.get(self, "min_vcpu")
|
|
1689
1688
|
|
|
1690
|
-
@property
|
|
1689
|
+
@_builtins.property
|
|
1691
1690
|
@pulumi.getter
|
|
1692
|
-
def series(self) -> Optional[Sequence[
|
|
1691
|
+
def series(self) -> Optional[Sequence[_builtins.str]]:
|
|
1693
1692
|
"""
|
|
1694
1693
|
Vm sizes belonging to a series from the list will be available for scaling.
|
|
1695
1694
|
"""
|
|
1696
1695
|
return pulumi.get(self, "series")
|
|
1697
1696
|
|
|
1698
|
-
@property
|
|
1697
|
+
@_builtins.property
|
|
1699
1698
|
@pulumi.getter(name="vmTypes")
|
|
1700
|
-
def vm_types(self) -> Optional[Sequence[
|
|
1699
|
+
def vm_types(self) -> Optional[Sequence[_builtins.str]]:
|
|
1701
1700
|
"""
|
|
1702
1701
|
The filtered vm types will belong to one of the vm types from this list.
|
|
1703
1702
|
"""
|
|
@@ -1730,15 +1729,15 @@ class OceanNpVirtualNodeGroupHeadroom(dict):
|
|
|
1730
1729
|
return super().get(key, default)
|
|
1731
1730
|
|
|
1732
1731
|
def __init__(__self__, *,
|
|
1733
|
-
cpu_per_unit: Optional[
|
|
1734
|
-
gpu_per_unit: Optional[
|
|
1735
|
-
memory_per_unit: Optional[
|
|
1736
|
-
num_of_units: Optional[
|
|
1732
|
+
cpu_per_unit: Optional[_builtins.int] = None,
|
|
1733
|
+
gpu_per_unit: Optional[_builtins.int] = None,
|
|
1734
|
+
memory_per_unit: Optional[_builtins.int] = None,
|
|
1735
|
+
num_of_units: Optional[_builtins.int] = None):
|
|
1737
1736
|
"""
|
|
1738
|
-
:param
|
|
1739
|
-
:param
|
|
1740
|
-
:param
|
|
1741
|
-
:param
|
|
1737
|
+
:param _builtins.int cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1738
|
+
:param _builtins.int gpu_per_unit: Amount of GPU to allocate for headroom unit.
|
|
1739
|
+
:param _builtins.int memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
|
|
1740
|
+
:param _builtins.int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1742
1741
|
"""
|
|
1743
1742
|
if cpu_per_unit is not None:
|
|
1744
1743
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -1749,33 +1748,33 @@ class OceanNpVirtualNodeGroupHeadroom(dict):
|
|
|
1749
1748
|
if num_of_units is not None:
|
|
1750
1749
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
1751
1750
|
|
|
1752
|
-
@property
|
|
1751
|
+
@_builtins.property
|
|
1753
1752
|
@pulumi.getter(name="cpuPerUnit")
|
|
1754
|
-
def cpu_per_unit(self) -> Optional[
|
|
1753
|
+
def cpu_per_unit(self) -> Optional[_builtins.int]:
|
|
1755
1754
|
"""
|
|
1756
1755
|
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1757
1756
|
"""
|
|
1758
1757
|
return pulumi.get(self, "cpu_per_unit")
|
|
1759
1758
|
|
|
1760
|
-
@property
|
|
1759
|
+
@_builtins.property
|
|
1761
1760
|
@pulumi.getter(name="gpuPerUnit")
|
|
1762
|
-
def gpu_per_unit(self) -> Optional[
|
|
1761
|
+
def gpu_per_unit(self) -> Optional[_builtins.int]:
|
|
1763
1762
|
"""
|
|
1764
1763
|
Amount of GPU to allocate for headroom unit.
|
|
1765
1764
|
"""
|
|
1766
1765
|
return pulumi.get(self, "gpu_per_unit")
|
|
1767
1766
|
|
|
1768
|
-
@property
|
|
1767
|
+
@_builtins.property
|
|
1769
1768
|
@pulumi.getter(name="memoryPerUnit")
|
|
1770
|
-
def memory_per_unit(self) -> Optional[
|
|
1769
|
+
def memory_per_unit(self) -> Optional[_builtins.int]:
|
|
1771
1770
|
"""
|
|
1772
1771
|
Configure the amount of memory (MiB) to allocate the headroom.
|
|
1773
1772
|
"""
|
|
1774
1773
|
return pulumi.get(self, "memory_per_unit")
|
|
1775
1774
|
|
|
1776
|
-
@property
|
|
1775
|
+
@_builtins.property
|
|
1777
1776
|
@pulumi.getter(name="numOfUnits")
|
|
1778
|
-
def num_of_units(self) -> Optional[
|
|
1777
|
+
def num_of_units(self) -> Optional[_builtins.int]:
|
|
1779
1778
|
"""
|
|
1780
1779
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1781
1780
|
"""
|
|
@@ -1792,7 +1791,7 @@ class OceanNpVirtualNodeGroupLinuxOsConfig(dict):
|
|
|
1792
1791
|
if sysctls is not None:
|
|
1793
1792
|
pulumi.set(__self__, "sysctls", sysctls)
|
|
1794
1793
|
|
|
1795
|
-
@property
|
|
1794
|
+
@_builtins.property
|
|
1796
1795
|
@pulumi.getter
|
|
1797
1796
|
def sysctls(self) -> Optional[Sequence['outputs.OceanNpVirtualNodeGroupLinuxOsConfigSysctl']]:
|
|
1798
1797
|
"""
|
|
@@ -1821,16 +1820,16 @@ class OceanNpVirtualNodeGroupLinuxOsConfigSysctl(dict):
|
|
|
1821
1820
|
return super().get(key, default)
|
|
1822
1821
|
|
|
1823
1822
|
def __init__(__self__, *,
|
|
1824
|
-
vm_max_map_count: Optional[
|
|
1823
|
+
vm_max_map_count: Optional[_builtins.int] = None):
|
|
1825
1824
|
"""
|
|
1826
|
-
:param
|
|
1825
|
+
:param _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.
|
|
1827
1826
|
"""
|
|
1828
1827
|
if vm_max_map_count is not None:
|
|
1829
1828
|
pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
|
|
1830
1829
|
|
|
1831
|
-
@property
|
|
1830
|
+
@_builtins.property
|
|
1832
1831
|
@pulumi.getter(name="vmMaxMapCount")
|
|
1833
|
-
def vm_max_map_count(self) -> Optional[
|
|
1832
|
+
def vm_max_map_count(self) -> Optional[_builtins.int]:
|
|
1834
1833
|
"""
|
|
1835
1834
|
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
1836
1835
|
"""
|
|
@@ -1864,7 +1863,7 @@ class OceanNpVirtualNodeGroupScheduling(dict):
|
|
|
1864
1863
|
if shutdown_hours is not None:
|
|
1865
1864
|
pulumi.set(__self__, "shutdown_hours", shutdown_hours)
|
|
1866
1865
|
|
|
1867
|
-
@property
|
|
1866
|
+
@_builtins.property
|
|
1868
1867
|
@pulumi.getter(name="shutdownHours")
|
|
1869
1868
|
def shutdown_hours(self) -> Optional['outputs.OceanNpVirtualNodeGroupSchedulingShutdownHours']:
|
|
1870
1869
|
"""
|
|
@@ -1895,28 +1894,28 @@ class OceanNpVirtualNodeGroupSchedulingShutdownHours(dict):
|
|
|
1895
1894
|
return super().get(key, default)
|
|
1896
1895
|
|
|
1897
1896
|
def __init__(__self__, *,
|
|
1898
|
-
is_enabled: Optional[
|
|
1899
|
-
time_windows: Optional[Sequence[
|
|
1897
|
+
is_enabled: Optional[_builtins.bool] = None,
|
|
1898
|
+
time_windows: Optional[Sequence[_builtins.str]] = None):
|
|
1900
1899
|
"""
|
|
1901
|
-
:param
|
|
1902
|
-
:param Sequence[
|
|
1900
|
+
:param _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.
|
|
1901
|
+
:param Sequence[_builtins.str] time_windows: The times that the shutdown hours will apply. Required if isEnabled is true.
|
|
1903
1902
|
"""
|
|
1904
1903
|
if is_enabled is not None:
|
|
1905
1904
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
1906
1905
|
if time_windows is not None:
|
|
1907
1906
|
pulumi.set(__self__, "time_windows", time_windows)
|
|
1908
1907
|
|
|
1909
|
-
@property
|
|
1908
|
+
@_builtins.property
|
|
1910
1909
|
@pulumi.getter(name="isEnabled")
|
|
1911
|
-
def is_enabled(self) -> Optional[
|
|
1910
|
+
def is_enabled(self) -> Optional[_builtins.bool]:
|
|
1912
1911
|
"""
|
|
1913
1912
|
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.
|
|
1914
1913
|
"""
|
|
1915
1914
|
return pulumi.get(self, "is_enabled")
|
|
1916
1915
|
|
|
1917
|
-
@property
|
|
1916
|
+
@_builtins.property
|
|
1918
1917
|
@pulumi.getter(name="timeWindows")
|
|
1919
|
-
def time_windows(self) -> Optional[Sequence[
|
|
1918
|
+
def time_windows(self) -> Optional[Sequence[_builtins.str]]:
|
|
1920
1919
|
"""
|
|
1921
1920
|
The times that the shutdown hours will apply. Required if isEnabled is true.
|
|
1922
1921
|
"""
|
|
@@ -1926,37 +1925,37 @@ class OceanNpVirtualNodeGroupSchedulingShutdownHours(dict):
|
|
|
1926
1925
|
@pulumi.output_type
|
|
1927
1926
|
class OceanNpVirtualNodeGroupTaint(dict):
|
|
1928
1927
|
def __init__(__self__, *,
|
|
1929
|
-
effect:
|
|
1930
|
-
key:
|
|
1931
|
-
value:
|
|
1928
|
+
effect: _builtins.str,
|
|
1929
|
+
key: _builtins.str,
|
|
1930
|
+
value: _builtins.str):
|
|
1932
1931
|
"""
|
|
1933
|
-
:param
|
|
1934
|
-
:param
|
|
1935
|
-
:param
|
|
1932
|
+
:param _builtins.str effect: Set taint effect.
|
|
1933
|
+
:param _builtins.str key: Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
|
|
1934
|
+
:param _builtins.str value: Set taint value.
|
|
1936
1935
|
"""
|
|
1937
1936
|
pulumi.set(__self__, "effect", effect)
|
|
1938
1937
|
pulumi.set(__self__, "key", key)
|
|
1939
1938
|
pulumi.set(__self__, "value", value)
|
|
1940
1939
|
|
|
1941
|
-
@property
|
|
1940
|
+
@_builtins.property
|
|
1942
1941
|
@pulumi.getter
|
|
1943
|
-
def effect(self) ->
|
|
1942
|
+
def effect(self) -> _builtins.str:
|
|
1944
1943
|
"""
|
|
1945
1944
|
Set taint effect.
|
|
1946
1945
|
"""
|
|
1947
1946
|
return pulumi.get(self, "effect")
|
|
1948
1947
|
|
|
1949
|
-
@property
|
|
1948
|
+
@_builtins.property
|
|
1950
1949
|
@pulumi.getter
|
|
1951
|
-
def key(self) ->
|
|
1950
|
+
def key(self) -> _builtins.str:
|
|
1952
1951
|
"""
|
|
1953
1952
|
Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
|
|
1954
1953
|
"""
|
|
1955
1954
|
return pulumi.get(self, "key")
|
|
1956
1955
|
|
|
1957
|
-
@property
|
|
1956
|
+
@_builtins.property
|
|
1958
1957
|
@pulumi.getter
|
|
1959
|
-
def value(self) ->
|
|
1958
|
+
def value(self) -> _builtins.str:
|
|
1960
1959
|
"""
|
|
1961
1960
|
Set taint value.
|
|
1962
1961
|
"""
|
|
@@ -1987,12 +1986,12 @@ class OceanNpVirtualNodeGroupUpdatePolicy(dict):
|
|
|
1987
1986
|
return super().get(key, default)
|
|
1988
1987
|
|
|
1989
1988
|
def __init__(__self__, *,
|
|
1990
|
-
should_roll:
|
|
1991
|
-
conditioned_roll: Optional[
|
|
1989
|
+
should_roll: _builtins.bool,
|
|
1990
|
+
conditioned_roll: Optional[_builtins.bool] = None,
|
|
1992
1991
|
roll_config: Optional['outputs.OceanNpVirtualNodeGroupUpdatePolicyRollConfig'] = None):
|
|
1993
1992
|
"""
|
|
1994
|
-
:param
|
|
1995
|
-
:param
|
|
1993
|
+
:param _builtins.bool should_roll: If set to true along with the vng update, roll will be triggered.
|
|
1994
|
+
:param _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).
|
|
1996
1995
|
:param 'OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs' roll_config: While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
1997
1996
|
"""
|
|
1998
1997
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
@@ -2001,23 +2000,23 @@ class OceanNpVirtualNodeGroupUpdatePolicy(dict):
|
|
|
2001
2000
|
if roll_config is not None:
|
|
2002
2001
|
pulumi.set(__self__, "roll_config", roll_config)
|
|
2003
2002
|
|
|
2004
|
-
@property
|
|
2003
|
+
@_builtins.property
|
|
2005
2004
|
@pulumi.getter(name="shouldRoll")
|
|
2006
|
-
def should_roll(self) ->
|
|
2005
|
+
def should_roll(self) -> _builtins.bool:
|
|
2007
2006
|
"""
|
|
2008
2007
|
If set to true along with the vng update, roll will be triggered.
|
|
2009
2008
|
"""
|
|
2010
2009
|
return pulumi.get(self, "should_roll")
|
|
2011
2010
|
|
|
2012
|
-
@property
|
|
2011
|
+
@_builtins.property
|
|
2013
2012
|
@pulumi.getter(name="conditionedRoll")
|
|
2014
|
-
def conditioned_roll(self) -> Optional[
|
|
2013
|
+
def conditioned_roll(self) -> Optional[_builtins.bool]:
|
|
2015
2014
|
"""
|
|
2016
2015
|
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).
|
|
2017
2016
|
"""
|
|
2018
2017
|
return pulumi.get(self, "conditioned_roll")
|
|
2019
2018
|
|
|
2020
|
-
@property
|
|
2019
|
+
@_builtins.property
|
|
2021
2020
|
@pulumi.getter(name="rollConfig")
|
|
2022
2021
|
def roll_config(self) -> Optional['outputs.OceanNpVirtualNodeGroupUpdatePolicyRollConfig']:
|
|
2023
2022
|
"""
|
|
@@ -2058,23 +2057,23 @@ class OceanNpVirtualNodeGroupUpdatePolicyRollConfig(dict):
|
|
|
2058
2057
|
return super().get(key, default)
|
|
2059
2058
|
|
|
2060
2059
|
def __init__(__self__, *,
|
|
2061
|
-
batch_min_healthy_percentage: Optional[
|
|
2062
|
-
batch_size_percentage: Optional[
|
|
2063
|
-
comment: Optional[
|
|
2064
|
-
node_names: Optional[Sequence[
|
|
2065
|
-
node_pool_names: Optional[Sequence[
|
|
2066
|
-
respect_pdb: Optional[
|
|
2067
|
-
respect_restrict_scale_down: Optional[
|
|
2068
|
-
vng_ids: Optional[Sequence[
|
|
2069
|
-
"""
|
|
2070
|
-
:param
|
|
2071
|
-
:param
|
|
2072
|
-
:param
|
|
2073
|
-
:param Sequence[
|
|
2074
|
-
:param Sequence[
|
|
2075
|
-
:param
|
|
2076
|
-
:param
|
|
2077
|
-
:param Sequence[
|
|
2060
|
+
batch_min_healthy_percentage: Optional[_builtins.int] = None,
|
|
2061
|
+
batch_size_percentage: Optional[_builtins.int] = None,
|
|
2062
|
+
comment: Optional[_builtins.str] = None,
|
|
2063
|
+
node_names: Optional[Sequence[_builtins.str]] = None,
|
|
2064
|
+
node_pool_names: Optional[Sequence[_builtins.str]] = None,
|
|
2065
|
+
respect_pdb: Optional[_builtins.bool] = None,
|
|
2066
|
+
respect_restrict_scale_down: Optional[_builtins.bool] = None,
|
|
2067
|
+
vng_ids: Optional[Sequence[_builtins.str]] = None):
|
|
2068
|
+
"""
|
|
2069
|
+
:param _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.
|
|
2070
|
+
:param _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%.
|
|
2071
|
+
:param _builtins.str comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
2072
|
+
:param Sequence[_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.
|
|
2073
|
+
:param Sequence[_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.
|
|
2074
|
+
:param _builtins.bool respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
2075
|
+
:param _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.
|
|
2076
|
+
:param Sequence[_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.
|
|
2078
2077
|
"""
|
|
2079
2078
|
if batch_min_healthy_percentage is not None:
|
|
2080
2079
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -2093,65 +2092,65 @@ class OceanNpVirtualNodeGroupUpdatePolicyRollConfig(dict):
|
|
|
2093
2092
|
if vng_ids is not None:
|
|
2094
2093
|
pulumi.set(__self__, "vng_ids", vng_ids)
|
|
2095
2094
|
|
|
2096
|
-
@property
|
|
2095
|
+
@_builtins.property
|
|
2097
2096
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
2098
|
-
def batch_min_healthy_percentage(self) -> Optional[
|
|
2097
|
+
def batch_min_healthy_percentage(self) -> Optional[_builtins.int]:
|
|
2099
2098
|
"""
|
|
2100
2099
|
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.
|
|
2101
2100
|
"""
|
|
2102
2101
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
2103
2102
|
|
|
2104
|
-
@property
|
|
2103
|
+
@_builtins.property
|
|
2105
2104
|
@pulumi.getter(name="batchSizePercentage")
|
|
2106
|
-
def batch_size_percentage(self) -> Optional[
|
|
2105
|
+
def batch_size_percentage(self) -> Optional[_builtins.int]:
|
|
2107
2106
|
"""
|
|
2108
2107
|
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%.
|
|
2109
2108
|
"""
|
|
2110
2109
|
return pulumi.get(self, "batch_size_percentage")
|
|
2111
2110
|
|
|
2112
|
-
@property
|
|
2111
|
+
@_builtins.property
|
|
2113
2112
|
@pulumi.getter
|
|
2114
|
-
def comment(self) -> Optional[
|
|
2113
|
+
def comment(self) -> Optional[_builtins.str]:
|
|
2115
2114
|
"""
|
|
2116
2115
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
2117
2116
|
"""
|
|
2118
2117
|
return pulumi.get(self, "comment")
|
|
2119
2118
|
|
|
2120
|
-
@property
|
|
2119
|
+
@_builtins.property
|
|
2121
2120
|
@pulumi.getter(name="nodeNames")
|
|
2122
|
-
def node_names(self) -> Optional[Sequence[
|
|
2121
|
+
def node_names(self) -> Optional[Sequence[_builtins.str]]:
|
|
2123
2122
|
"""
|
|
2124
2123
|
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.
|
|
2125
2124
|
"""
|
|
2126
2125
|
return pulumi.get(self, "node_names")
|
|
2127
2126
|
|
|
2128
|
-
@property
|
|
2127
|
+
@_builtins.property
|
|
2129
2128
|
@pulumi.getter(name="nodePoolNames")
|
|
2130
|
-
def node_pool_names(self) -> Optional[Sequence[
|
|
2129
|
+
def node_pool_names(self) -> Optional[Sequence[_builtins.str]]:
|
|
2131
2130
|
"""
|
|
2132
2131
|
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.
|
|
2133
2132
|
"""
|
|
2134
2133
|
return pulumi.get(self, "node_pool_names")
|
|
2135
2134
|
|
|
2136
|
-
@property
|
|
2135
|
+
@_builtins.property
|
|
2137
2136
|
@pulumi.getter(name="respectPdb")
|
|
2138
|
-
def respect_pdb(self) -> Optional[
|
|
2137
|
+
def respect_pdb(self) -> Optional[_builtins.bool]:
|
|
2139
2138
|
"""
|
|
2140
2139
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
2141
2140
|
"""
|
|
2142
2141
|
return pulumi.get(self, "respect_pdb")
|
|
2143
2142
|
|
|
2144
|
-
@property
|
|
2143
|
+
@_builtins.property
|
|
2145
2144
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
2146
|
-
def respect_restrict_scale_down(self) -> Optional[
|
|
2145
|
+
def respect_restrict_scale_down(self) -> Optional[_builtins.bool]:
|
|
2147
2146
|
"""
|
|
2148
2147
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
2149
2148
|
"""
|
|
2150
2149
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
2151
2150
|
|
|
2152
|
-
@property
|
|
2151
|
+
@_builtins.property
|
|
2153
2152
|
@pulumi.getter(name="vngIds")
|
|
2154
|
-
def vng_ids(self) -> Optional[Sequence[
|
|
2153
|
+
def vng_ids(self) -> Optional[Sequence[_builtins.str]]:
|
|
2155
2154
|
"""
|
|
2156
2155
|
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.
|
|
2157
2156
|
"""
|
|
@@ -2182,7 +2181,7 @@ class OceanNpVngTemplateScheduling(dict):
|
|
|
2182
2181
|
if vng_template_shutdown_hours is not None:
|
|
2183
2182
|
pulumi.set(__self__, "vng_template_shutdown_hours", vng_template_shutdown_hours)
|
|
2184
2183
|
|
|
2185
|
-
@property
|
|
2184
|
+
@_builtins.property
|
|
2186
2185
|
@pulumi.getter(name="vngTemplateShutdownHours")
|
|
2187
2186
|
def vng_template_shutdown_hours(self) -> Optional['outputs.OceanNpVngTemplateSchedulingVngTemplateShutdownHours']:
|
|
2188
2187
|
return pulumi.get(self, "vng_template_shutdown_hours")
|
|
@@ -2210,24 +2209,24 @@ class OceanNpVngTemplateSchedulingVngTemplateShutdownHours(dict):
|
|
|
2210
2209
|
return super().get(key, default)
|
|
2211
2210
|
|
|
2212
2211
|
def __init__(__self__, *,
|
|
2213
|
-
is_enabled: Optional[
|
|
2214
|
-
time_windows: Optional[Sequence[
|
|
2212
|
+
is_enabled: Optional[_builtins.bool] = None,
|
|
2213
|
+
time_windows: Optional[Sequence[_builtins.str]] = None):
|
|
2215
2214
|
"""
|
|
2216
|
-
:param Sequence[
|
|
2215
|
+
:param Sequence[_builtins.str] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
2217
2216
|
"""
|
|
2218
2217
|
if is_enabled is not None:
|
|
2219
2218
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
2220
2219
|
if time_windows is not None:
|
|
2221
2220
|
pulumi.set(__self__, "time_windows", time_windows)
|
|
2222
2221
|
|
|
2223
|
-
@property
|
|
2222
|
+
@_builtins.property
|
|
2224
2223
|
@pulumi.getter(name="isEnabled")
|
|
2225
|
-
def is_enabled(self) -> Optional[
|
|
2224
|
+
def is_enabled(self) -> Optional[_builtins.bool]:
|
|
2226
2225
|
return pulumi.get(self, "is_enabled")
|
|
2227
2226
|
|
|
2228
|
-
@property
|
|
2227
|
+
@_builtins.property
|
|
2229
2228
|
@pulumi.getter(name="timeWindows")
|
|
2230
|
-
def time_windows(self) -> Optional[Sequence[
|
|
2229
|
+
def time_windows(self) -> Optional[Sequence[_builtins.str]]:
|
|
2231
2230
|
"""
|
|
2232
2231
|
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
2233
2232
|
"""
|