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