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