pulumi-spotinst 3.83.0a1720524486__py3-none-any.whl → 3.128.0a1767140134__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.
- pulumi_spotinst/__init__.py +38 -1
- pulumi_spotinst/_inputs.py +4082 -846
- pulumi_spotinst/_utilities.py +15 -10
- pulumi_spotinst/account.py +171 -0
- pulumi_spotinst/aws/__init__.py +2 -1
- pulumi_spotinst/aws/_inputs.py +7292 -2871
- pulumi_spotinst/aws/account.py +25 -19
- pulumi_spotinst/aws/beanstalk.py +272 -190
- pulumi_spotinst/aws/credentials.py +42 -36
- pulumi_spotinst/aws/elastigroup.py +1321 -1176
- pulumi_spotinst/aws/managed_instance.py +633 -526
- pulumi_spotinst/aws/mr_scalar.py +827 -983
- pulumi_spotinst/aws/ocean.py +764 -570
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +42 -36
- pulumi_spotinst/aws/ocean_launch_spec.py +580 -366
- pulumi_spotinst/aws/outputs.py +3421 -2205
- pulumi_spotinst/aws/suspension.py +51 -45
- pulumi_spotinst/azure/__init__.py +2 -1
- pulumi_spotinst/azure/_inputs.py +1492 -434
- pulumi_spotinst/azure/ocean_np.py +518 -464
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +479 -408
- pulumi_spotinst/azure/outputs.py +840 -345
- pulumi_spotinst/config/__init__.py +2 -1
- pulumi_spotinst/config/__init__.pyi +7 -2
- pulumi_spotinst/config/vars.py +11 -6
- pulumi_spotinst/credentials_azure.py +423 -0
- pulumi_spotinst/credentials_gcp.py +632 -0
- pulumi_spotinst/data_integration.py +58 -52
- pulumi_spotinst/ecs/__init__.py +2 -1
- pulumi_spotinst/ecs/_inputs.py +1164 -469
- pulumi_spotinst/ecs/ocean.py +711 -446
- pulumi_spotinst/ecs/ocean_launch_spec.py +367 -341
- pulumi_spotinst/ecs/outputs.py +463 -374
- pulumi_spotinst/elastigroup_azure_v3.py +985 -197
- pulumi_spotinst/gcp/__init__.py +2 -1
- pulumi_spotinst/gcp/_inputs.py +1061 -381
- pulumi_spotinst/gcp/elastigroup.py +885 -567
- pulumi_spotinst/gcp/outputs.py +542 -301
- pulumi_spotinst/gke/__init__.py +2 -1
- pulumi_spotinst/gke/_inputs.py +2071 -715
- pulumi_spotinst/gke/elastigroup.py +558 -382
- pulumi_spotinst/gke/ocean_import.py +379 -255
- pulumi_spotinst/gke/ocean_launch_spec.py +501 -384
- pulumi_spotinst/gke/ocean_launch_spec_import.py +42 -36
- pulumi_spotinst/gke/outputs.py +1063 -528
- pulumi_spotinst/health_check.py +116 -70
- pulumi_spotinst/notification_center.py +344 -0
- pulumi_spotinst/ocean_right_sizing_rule.py +515 -95
- pulumi_spotinst/oceancd/__init__.py +2 -1
- pulumi_spotinst/oceancd/_inputs.py +1709 -651
- pulumi_spotinst/oceancd/outputs.py +537 -526
- pulumi_spotinst/oceancd/rollout_spec.py +65 -59
- pulumi_spotinst/oceancd/strategy.py +37 -31
- pulumi_spotinst/oceancd/verification_provider.py +128 -122
- pulumi_spotinst/oceancd/verification_template.py +265 -259
- pulumi_spotinst/organization/__init__.py +2 -1
- pulumi_spotinst/organization/_inputs.py +151 -57
- pulumi_spotinst/organization/outputs.py +51 -46
- pulumi_spotinst/organization/policy.py +76 -70
- pulumi_spotinst/organization/programmatic_user.py +83 -77
- pulumi_spotinst/organization/user.py +126 -120
- pulumi_spotinst/organization/user_group.py +75 -69
- pulumi_spotinst/outputs.py +3005 -832
- pulumi_spotinst/provider.py +66 -40
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +2 -1
- pulumi_spotinst/spark/_inputs.py +290 -81
- pulumi_spotinst/spark/ocean.py +169 -115
- pulumi_spotinst/spark/ocean_virtual_node_group.py +34 -28
- pulumi_spotinst/spark/outputs.py +136 -66
- pulumi_spotinst/stateful_node_azure.py +820 -784
- pulumi_spotinst/subscription.py +93 -87
- {pulumi_spotinst-3.83.0a1720524486.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/METADATA +7 -6
- pulumi_spotinst-3.128.0a1767140134.dist-info/RECORD +77 -0
- {pulumi_spotinst-3.83.0a1720524486.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/WHEEL +1 -1
- pulumi_spotinst-3.83.0a1720524486.dist-info/RECORD +0 -73
- {pulumi_spotinst-3.83.0a1720524486.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/top_level.txt +0 -0
pulumi_spotinst/azure/_inputs.py
CHANGED
|
@@ -1,53 +1,126 @@
|
|
|
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
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from .. import _utilities
|
|
11
16
|
|
|
12
17
|
__all__ = [
|
|
13
18
|
'OceanNpAutoscalerArgs',
|
|
19
|
+
'OceanNpAutoscalerArgsDict',
|
|
14
20
|
'OceanNpAutoscalerAutoscaleDownArgs',
|
|
21
|
+
'OceanNpAutoscalerAutoscaleDownArgsDict',
|
|
15
22
|
'OceanNpAutoscalerAutoscaleHeadroomArgs',
|
|
23
|
+
'OceanNpAutoscalerAutoscaleHeadroomArgsDict',
|
|
16
24
|
'OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs',
|
|
25
|
+
'OceanNpAutoscalerAutoscaleHeadroomAutomaticArgsDict',
|
|
17
26
|
'OceanNpAutoscalerResourceLimitsArgs',
|
|
27
|
+
'OceanNpAutoscalerResourceLimitsArgsDict',
|
|
18
28
|
'OceanNpFiltersArgs',
|
|
29
|
+
'OceanNpFiltersArgsDict',
|
|
19
30
|
'OceanNpHeadroomArgs',
|
|
31
|
+
'OceanNpHeadroomArgsDict',
|
|
20
32
|
'OceanNpHealthArgs',
|
|
33
|
+
'OceanNpHealthArgsDict',
|
|
21
34
|
'OceanNpLinuxOsConfigArgs',
|
|
35
|
+
'OceanNpLinuxOsConfigArgsDict',
|
|
22
36
|
'OceanNpLinuxOsConfigSysctlArgs',
|
|
37
|
+
'OceanNpLinuxOsConfigSysctlArgsDict',
|
|
38
|
+
'OceanNpLoggingArgs',
|
|
39
|
+
'OceanNpLoggingArgsDict',
|
|
40
|
+
'OceanNpLoggingExportArgs',
|
|
41
|
+
'OceanNpLoggingExportArgsDict',
|
|
42
|
+
'OceanNpLoggingExportAzureBlobArgs',
|
|
43
|
+
'OceanNpLoggingExportAzureBlobArgsDict',
|
|
23
44
|
'OceanNpSchedulingArgs',
|
|
45
|
+
'OceanNpSchedulingArgsDict',
|
|
24
46
|
'OceanNpSchedulingShutdownHoursArgs',
|
|
47
|
+
'OceanNpSchedulingShutdownHoursArgsDict',
|
|
48
|
+
'OceanNpSchedulingSuspensionHoursArgs',
|
|
49
|
+
'OceanNpSchedulingSuspensionHoursArgsDict',
|
|
25
50
|
'OceanNpSchedulingTaskArgs',
|
|
51
|
+
'OceanNpSchedulingTaskArgsDict',
|
|
26
52
|
'OceanNpSchedulingTaskParametersArgs',
|
|
53
|
+
'OceanNpSchedulingTaskParametersArgsDict',
|
|
27
54
|
'OceanNpSchedulingTaskParametersParametersClusterRollArgs',
|
|
55
|
+
'OceanNpSchedulingTaskParametersParametersClusterRollArgsDict',
|
|
56
|
+
'OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs',
|
|
57
|
+
'OceanNpSchedulingTaskParametersParametersUpgradeConfigArgsDict',
|
|
58
|
+
'OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs',
|
|
59
|
+
'OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgsDict',
|
|
28
60
|
'OceanNpTaintArgs',
|
|
61
|
+
'OceanNpTaintArgsDict',
|
|
29
62
|
'OceanNpUpdatePolicyArgs',
|
|
63
|
+
'OceanNpUpdatePolicyArgsDict',
|
|
30
64
|
'OceanNpUpdatePolicyRollConfigArgs',
|
|
65
|
+
'OceanNpUpdatePolicyRollConfigArgsDict',
|
|
31
66
|
'OceanNpVirtualNodeGroupFiltersArgs',
|
|
67
|
+
'OceanNpVirtualNodeGroupFiltersArgsDict',
|
|
32
68
|
'OceanNpVirtualNodeGroupHeadroomArgs',
|
|
69
|
+
'OceanNpVirtualNodeGroupHeadroomArgsDict',
|
|
33
70
|
'OceanNpVirtualNodeGroupLinuxOsConfigArgs',
|
|
71
|
+
'OceanNpVirtualNodeGroupLinuxOsConfigArgsDict',
|
|
34
72
|
'OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgs',
|
|
73
|
+
'OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgsDict',
|
|
74
|
+
'OceanNpVirtualNodeGroupSchedulingArgs',
|
|
75
|
+
'OceanNpVirtualNodeGroupSchedulingArgsDict',
|
|
76
|
+
'OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs',
|
|
77
|
+
'OceanNpVirtualNodeGroupSchedulingShutdownHoursArgsDict',
|
|
35
78
|
'OceanNpVirtualNodeGroupTaintArgs',
|
|
79
|
+
'OceanNpVirtualNodeGroupTaintArgsDict',
|
|
36
80
|
'OceanNpVirtualNodeGroupUpdatePolicyArgs',
|
|
81
|
+
'OceanNpVirtualNodeGroupUpdatePolicyArgsDict',
|
|
37
82
|
'OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs',
|
|
83
|
+
'OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgsDict',
|
|
84
|
+
'OceanNpVngTemplateSchedulingArgs',
|
|
85
|
+
'OceanNpVngTemplateSchedulingArgsDict',
|
|
86
|
+
'OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgs',
|
|
87
|
+
'OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgsDict',
|
|
38
88
|
]
|
|
39
89
|
|
|
90
|
+
MYPY = False
|
|
91
|
+
|
|
92
|
+
if not MYPY:
|
|
93
|
+
class OceanNpAutoscalerArgsDict(TypedDict):
|
|
94
|
+
autoscale_down: NotRequired[pulumi.Input['OceanNpAutoscalerAutoscaleDownArgsDict']]
|
|
95
|
+
"""
|
|
96
|
+
Auto Scaling scale down operations.
|
|
97
|
+
"""
|
|
98
|
+
autoscale_headroom: NotRequired[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgsDict']]
|
|
99
|
+
"""
|
|
100
|
+
Spare resource capacity management enabling fast assignment of pods without waiting for new resources to launch.
|
|
101
|
+
"""
|
|
102
|
+
autoscale_is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
103
|
+
"""
|
|
104
|
+
Enable the Ocean Kubernetes Autoscaler.
|
|
105
|
+
"""
|
|
106
|
+
resource_limits: NotRequired[pulumi.Input['OceanNpAutoscalerResourceLimitsArgsDict']]
|
|
107
|
+
"""
|
|
108
|
+
Optionally set upper and lower bounds on the resource usage of the cluster.
|
|
109
|
+
"""
|
|
110
|
+
elif False:
|
|
111
|
+
OceanNpAutoscalerArgsDict: TypeAlias = Mapping[str, Any]
|
|
112
|
+
|
|
40
113
|
@pulumi.input_type
|
|
41
114
|
class OceanNpAutoscalerArgs:
|
|
42
115
|
def __init__(__self__, *,
|
|
43
116
|
autoscale_down: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleDownArgs']] = None,
|
|
44
117
|
autoscale_headroom: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs']] = None,
|
|
45
|
-
autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
118
|
+
autoscale_is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
46
119
|
resource_limits: Optional[pulumi.Input['OceanNpAutoscalerResourceLimitsArgs']] = None):
|
|
47
120
|
"""
|
|
48
121
|
:param pulumi.Input['OceanNpAutoscalerAutoscaleDownArgs'] autoscale_down: Auto Scaling scale down operations.
|
|
49
122
|
:param pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs'] autoscale_headroom: Spare resource capacity management enabling fast assignment of pods without waiting for new resources to launch.
|
|
50
|
-
: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.
|
|
51
124
|
:param pulumi.Input['OceanNpAutoscalerResourceLimitsArgs'] resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
|
|
52
125
|
"""
|
|
53
126
|
if autoscale_down is not None:
|
|
@@ -59,7 +132,7 @@ class OceanNpAutoscalerArgs:
|
|
|
59
132
|
if resource_limits is not None:
|
|
60
133
|
pulumi.set(__self__, "resource_limits", resource_limits)
|
|
61
134
|
|
|
62
|
-
@property
|
|
135
|
+
@_builtins.property
|
|
63
136
|
@pulumi.getter(name="autoscaleDown")
|
|
64
137
|
def autoscale_down(self) -> Optional[pulumi.Input['OceanNpAutoscalerAutoscaleDownArgs']]:
|
|
65
138
|
"""
|
|
@@ -71,7 +144,7 @@ class OceanNpAutoscalerArgs:
|
|
|
71
144
|
def autoscale_down(self, value: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleDownArgs']]):
|
|
72
145
|
pulumi.set(self, "autoscale_down", value)
|
|
73
146
|
|
|
74
|
-
@property
|
|
147
|
+
@_builtins.property
|
|
75
148
|
@pulumi.getter(name="autoscaleHeadroom")
|
|
76
149
|
def autoscale_headroom(self) -> Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs']]:
|
|
77
150
|
"""
|
|
@@ -83,19 +156,19 @@ class OceanNpAutoscalerArgs:
|
|
|
83
156
|
def autoscale_headroom(self, value: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs']]):
|
|
84
157
|
pulumi.set(self, "autoscale_headroom", value)
|
|
85
158
|
|
|
86
|
-
@property
|
|
159
|
+
@_builtins.property
|
|
87
160
|
@pulumi.getter(name="autoscaleIsEnabled")
|
|
88
|
-
def autoscale_is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
161
|
+
def autoscale_is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
89
162
|
"""
|
|
90
163
|
Enable the Ocean Kubernetes Autoscaler.
|
|
91
164
|
"""
|
|
92
165
|
return pulumi.get(self, "autoscale_is_enabled")
|
|
93
166
|
|
|
94
167
|
@autoscale_is_enabled.setter
|
|
95
|
-
def autoscale_is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
168
|
+
def autoscale_is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
96
169
|
pulumi.set(self, "autoscale_is_enabled", value)
|
|
97
170
|
|
|
98
|
-
@property
|
|
171
|
+
@_builtins.property
|
|
99
172
|
@pulumi.getter(name="resourceLimits")
|
|
100
173
|
def resource_limits(self) -> Optional[pulumi.Input['OceanNpAutoscalerResourceLimitsArgs']]:
|
|
101
174
|
"""
|
|
@@ -108,29 +181,47 @@ class OceanNpAutoscalerArgs:
|
|
|
108
181
|
pulumi.set(self, "resource_limits", value)
|
|
109
182
|
|
|
110
183
|
|
|
184
|
+
if not MYPY:
|
|
185
|
+
class OceanNpAutoscalerAutoscaleDownArgsDict(TypedDict):
|
|
186
|
+
max_scale_down_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
187
|
+
"""
|
|
188
|
+
The maximum percentage allowed to scale down in a single scaling action.
|
|
189
|
+
"""
|
|
190
|
+
elif False:
|
|
191
|
+
OceanNpAutoscalerAutoscaleDownArgsDict: TypeAlias = Mapping[str, Any]
|
|
192
|
+
|
|
111
193
|
@pulumi.input_type
|
|
112
194
|
class OceanNpAutoscalerAutoscaleDownArgs:
|
|
113
195
|
def __init__(__self__, *,
|
|
114
|
-
max_scale_down_percentage: Optional[pulumi.Input[int]] = None):
|
|
196
|
+
max_scale_down_percentage: Optional[pulumi.Input[_builtins.int]] = None):
|
|
115
197
|
"""
|
|
116
|
-
: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.
|
|
117
199
|
"""
|
|
118
200
|
if max_scale_down_percentage is not None:
|
|
119
201
|
pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
|
|
120
202
|
|
|
121
|
-
@property
|
|
203
|
+
@_builtins.property
|
|
122
204
|
@pulumi.getter(name="maxScaleDownPercentage")
|
|
123
|
-
def max_scale_down_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
205
|
+
def max_scale_down_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
124
206
|
"""
|
|
125
207
|
The maximum percentage allowed to scale down in a single scaling action.
|
|
126
208
|
"""
|
|
127
209
|
return pulumi.get(self, "max_scale_down_percentage")
|
|
128
210
|
|
|
129
211
|
@max_scale_down_percentage.setter
|
|
130
|
-
def max_scale_down_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
212
|
+
def max_scale_down_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
131
213
|
pulumi.set(self, "max_scale_down_percentage", value)
|
|
132
214
|
|
|
133
215
|
|
|
216
|
+
if not MYPY:
|
|
217
|
+
class OceanNpAutoscalerAutoscaleHeadroomArgsDict(TypedDict):
|
|
218
|
+
automatic: NotRequired[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomAutomaticArgsDict']]
|
|
219
|
+
"""
|
|
220
|
+
[Automatic headroom](https://docs.spot.io/ocean/features/headroom?id=automatic-headroom) configuration.
|
|
221
|
+
"""
|
|
222
|
+
elif False:
|
|
223
|
+
OceanNpAutoscalerAutoscaleHeadroomArgsDict: TypeAlias = Mapping[str, Any]
|
|
224
|
+
|
|
134
225
|
@pulumi.input_type
|
|
135
226
|
class OceanNpAutoscalerAutoscaleHeadroomArgs:
|
|
136
227
|
def __init__(__self__, *,
|
|
@@ -141,7 +232,7 @@ class OceanNpAutoscalerAutoscaleHeadroomArgs:
|
|
|
141
232
|
if automatic is not None:
|
|
142
233
|
pulumi.set(__self__, "automatic", automatic)
|
|
143
234
|
|
|
144
|
-
@property
|
|
235
|
+
@_builtins.property
|
|
145
236
|
@pulumi.getter
|
|
146
237
|
def automatic(self) -> Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs']]:
|
|
147
238
|
"""
|
|
@@ -154,118 +245,209 @@ class OceanNpAutoscalerAutoscaleHeadroomArgs:
|
|
|
154
245
|
pulumi.set(self, "automatic", value)
|
|
155
246
|
|
|
156
247
|
|
|
248
|
+
if not MYPY:
|
|
249
|
+
class OceanNpAutoscalerAutoscaleHeadroomAutomaticArgsDict(TypedDict):
|
|
250
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
251
|
+
"""
|
|
252
|
+
Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
|
|
253
|
+
"""
|
|
254
|
+
percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
255
|
+
"""
|
|
256
|
+
Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
|
|
257
|
+
"""
|
|
258
|
+
elif False:
|
|
259
|
+
OceanNpAutoscalerAutoscaleHeadroomAutomaticArgsDict: TypeAlias = Mapping[str, Any]
|
|
260
|
+
|
|
157
261
|
@pulumi.input_type
|
|
158
262
|
class OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs:
|
|
159
263
|
def __init__(__self__, *,
|
|
160
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
161
|
-
percentage: Optional[pulumi.Input[int]] = None):
|
|
264
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
265
|
+
percentage: Optional[pulumi.Input[_builtins.int]] = None):
|
|
162
266
|
"""
|
|
163
|
-
:param pulumi.Input[bool] is_enabled: Enable automatic headroom. When set to
|
|
164
|
-
: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.
|
|
165
269
|
"""
|
|
166
270
|
if is_enabled is not None:
|
|
167
271
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
168
272
|
if percentage is not None:
|
|
169
273
|
pulumi.set(__self__, "percentage", percentage)
|
|
170
274
|
|
|
171
|
-
@property
|
|
275
|
+
@_builtins.property
|
|
172
276
|
@pulumi.getter(name="isEnabled")
|
|
173
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
277
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
174
278
|
"""
|
|
175
|
-
Enable automatic headroom. When set to
|
|
279
|
+
Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
|
|
176
280
|
"""
|
|
177
281
|
return pulumi.get(self, "is_enabled")
|
|
178
282
|
|
|
179
283
|
@is_enabled.setter
|
|
180
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
284
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
181
285
|
pulumi.set(self, "is_enabled", value)
|
|
182
286
|
|
|
183
|
-
@property
|
|
287
|
+
@_builtins.property
|
|
184
288
|
@pulumi.getter
|
|
185
|
-
def percentage(self) -> Optional[pulumi.Input[int]]:
|
|
289
|
+
def percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
186
290
|
"""
|
|
187
291
|
Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
|
|
188
292
|
"""
|
|
189
293
|
return pulumi.get(self, "percentage")
|
|
190
294
|
|
|
191
295
|
@percentage.setter
|
|
192
|
-
def percentage(self, value: Optional[pulumi.Input[int]]):
|
|
296
|
+
def percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
193
297
|
pulumi.set(self, "percentage", value)
|
|
194
298
|
|
|
195
299
|
|
|
300
|
+
if not MYPY:
|
|
301
|
+
class OceanNpAutoscalerResourceLimitsArgsDict(TypedDict):
|
|
302
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.int]]
|
|
303
|
+
"""
|
|
304
|
+
The maximum memory in GiB units that can be allocated to the cluster.
|
|
305
|
+
"""
|
|
306
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
307
|
+
"""
|
|
308
|
+
The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
309
|
+
"""
|
|
310
|
+
elif False:
|
|
311
|
+
OceanNpAutoscalerResourceLimitsArgsDict: TypeAlias = Mapping[str, Any]
|
|
312
|
+
|
|
196
313
|
@pulumi.input_type
|
|
197
314
|
class OceanNpAutoscalerResourceLimitsArgs:
|
|
198
315
|
def __init__(__self__, *,
|
|
199
|
-
max_memory_gib: Optional[pulumi.Input[int]] = None,
|
|
200
|
-
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):
|
|
201
318
|
"""
|
|
202
|
-
:param pulumi.Input[int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
|
|
203
|
-
: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.
|
|
204
321
|
"""
|
|
205
322
|
if max_memory_gib is not None:
|
|
206
323
|
pulumi.set(__self__, "max_memory_gib", max_memory_gib)
|
|
207
324
|
if max_vcpu is not None:
|
|
208
325
|
pulumi.set(__self__, "max_vcpu", max_vcpu)
|
|
209
326
|
|
|
210
|
-
@property
|
|
327
|
+
@_builtins.property
|
|
211
328
|
@pulumi.getter(name="maxMemoryGib")
|
|
212
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[int]]:
|
|
329
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
213
330
|
"""
|
|
214
331
|
The maximum memory in GiB units that can be allocated to the cluster.
|
|
215
332
|
"""
|
|
216
333
|
return pulumi.get(self, "max_memory_gib")
|
|
217
334
|
|
|
218
335
|
@max_memory_gib.setter
|
|
219
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[int]]):
|
|
336
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
220
337
|
pulumi.set(self, "max_memory_gib", value)
|
|
221
338
|
|
|
222
|
-
@property
|
|
339
|
+
@_builtins.property
|
|
223
340
|
@pulumi.getter(name="maxVcpu")
|
|
224
|
-
def max_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
341
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
225
342
|
"""
|
|
226
343
|
The maximum cpu in vCpu units that can be allocated to the cluster.
|
|
227
344
|
"""
|
|
228
345
|
return pulumi.get(self, "max_vcpu")
|
|
229
346
|
|
|
230
347
|
@max_vcpu.setter
|
|
231
|
-
def max_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
348
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
232
349
|
pulumi.set(self, "max_vcpu", value)
|
|
233
350
|
|
|
234
351
|
|
|
352
|
+
if not MYPY:
|
|
353
|
+
class OceanNpFiltersArgsDict(TypedDict):
|
|
354
|
+
accelerated_networking: NotRequired[pulumi.Input[_builtins.str]]
|
|
355
|
+
"""
|
|
356
|
+
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
357
|
+
"""
|
|
358
|
+
architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
359
|
+
"""
|
|
360
|
+
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
361
|
+
"""
|
|
362
|
+
disk_performance: NotRequired[pulumi.Input[_builtins.str]]
|
|
363
|
+
"""
|
|
364
|
+
The filtered vm sizes will support at least one of the classes from this list.
|
|
365
|
+
"""
|
|
366
|
+
exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
367
|
+
"""
|
|
368
|
+
Vm sizes belonging to a series from the list will not be available for scaling
|
|
369
|
+
"""
|
|
370
|
+
gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
371
|
+
"""
|
|
372
|
+
The filtered gpu types will belong to one of the gpu types from this list.
|
|
373
|
+
"""
|
|
374
|
+
max_gpu: NotRequired[pulumi.Input[_builtins.float]]
|
|
375
|
+
"""
|
|
376
|
+
Maximum number of GPUs available.
|
|
377
|
+
"""
|
|
378
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
379
|
+
"""
|
|
380
|
+
Maximum amount of Memory (GiB).
|
|
381
|
+
"""
|
|
382
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
383
|
+
"""
|
|
384
|
+
Maximum number of vcpus available.
|
|
385
|
+
"""
|
|
386
|
+
min_disk: NotRequired[pulumi.Input[_builtins.int]]
|
|
387
|
+
"""
|
|
388
|
+
Minimum number of data disks available.
|
|
389
|
+
"""
|
|
390
|
+
min_gpu: NotRequired[pulumi.Input[_builtins.float]]
|
|
391
|
+
"""
|
|
392
|
+
Minimum number of GPUs available.
|
|
393
|
+
"""
|
|
394
|
+
min_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
395
|
+
"""
|
|
396
|
+
Minimum amount of Memory (GiB).
|
|
397
|
+
"""
|
|
398
|
+
min_nics: NotRequired[pulumi.Input[_builtins.int]]
|
|
399
|
+
"""
|
|
400
|
+
Minimum number of network interfaces.
|
|
401
|
+
"""
|
|
402
|
+
min_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
403
|
+
"""
|
|
404
|
+
Minimum number of vcpus available.
|
|
405
|
+
"""
|
|
406
|
+
series: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
407
|
+
"""
|
|
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
|
+
"""
|
|
410
|
+
vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
411
|
+
"""
|
|
412
|
+
The filtered vm types will belong to one of the vm types from this list.
|
|
413
|
+
"""
|
|
414
|
+
elif False:
|
|
415
|
+
OceanNpFiltersArgsDict: TypeAlias = Mapping[str, Any]
|
|
416
|
+
|
|
235
417
|
@pulumi.input_type
|
|
236
418
|
class OceanNpFiltersArgs:
|
|
237
419
|
def __init__(__self__, *,
|
|
238
|
-
accelerated_networking: Optional[pulumi.Input[str]] = None,
|
|
239
|
-
architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
240
|
-
disk_performance: Optional[pulumi.Input[str]] = None,
|
|
241
|
-
exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
242
|
-
gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
243
|
-
max_gpu: Optional[pulumi.Input[float]] = None,
|
|
244
|
-
max_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
245
|
-
max_vcpu: Optional[pulumi.Input[int]] = None,
|
|
246
|
-
min_disk: Optional[pulumi.Input[int]] = None,
|
|
247
|
-
min_gpu: Optional[pulumi.Input[float]] = None,
|
|
248
|
-
min_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
249
|
-
min_nics: Optional[pulumi.Input[int]] = None,
|
|
250
|
-
min_vcpu: Optional[pulumi.Input[int]] = None,
|
|
251
|
-
series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
252
|
-
vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
253
|
-
"""
|
|
254
|
-
:param pulumi.Input[str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
255
|
-
: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.
|
|
256
|
-
:param pulumi.Input[str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
|
|
257
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling
|
|
258
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
|
|
259
|
-
:param pulumi.Input[float] max_gpu: Maximum number of GPUs available.
|
|
260
|
-
:param pulumi.Input[float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
261
|
-
:param pulumi.Input[int] max_vcpu: Maximum number of vcpus available.
|
|
262
|
-
:param pulumi.Input[int] min_disk: Minimum number of data disks available.
|
|
263
|
-
:param pulumi.Input[float] min_gpu: Minimum number of GPUs available.
|
|
264
|
-
:param pulumi.Input[float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
265
|
-
:param pulumi.Input[int] min_nics: Minimum number of network interfaces.
|
|
266
|
-
:param pulumi.Input[int] min_vcpu: Minimum number of vcpus available.
|
|
267
|
-
: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.
|
|
268
|
-
: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.
|
|
269
451
|
"""
|
|
270
452
|
if accelerated_networking is not None:
|
|
271
453
|
pulumi.set(__self__, "accelerated_networking", accelerated_networking)
|
|
@@ -298,199 +480,220 @@ class OceanNpFiltersArgs:
|
|
|
298
480
|
if vm_types is not None:
|
|
299
481
|
pulumi.set(__self__, "vm_types", vm_types)
|
|
300
482
|
|
|
301
|
-
@property
|
|
483
|
+
@_builtins.property
|
|
302
484
|
@pulumi.getter(name="acceleratedNetworking")
|
|
303
|
-
def accelerated_networking(self) -> Optional[pulumi.Input[str]]:
|
|
485
|
+
def accelerated_networking(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
304
486
|
"""
|
|
305
487
|
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
306
488
|
"""
|
|
307
489
|
return pulumi.get(self, "accelerated_networking")
|
|
308
490
|
|
|
309
491
|
@accelerated_networking.setter
|
|
310
|
-
def accelerated_networking(self, value: Optional[pulumi.Input[str]]):
|
|
492
|
+
def accelerated_networking(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
311
493
|
pulumi.set(self, "accelerated_networking", value)
|
|
312
494
|
|
|
313
|
-
@property
|
|
495
|
+
@_builtins.property
|
|
314
496
|
@pulumi.getter
|
|
315
|
-
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
497
|
+
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
316
498
|
"""
|
|
317
499
|
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
318
500
|
"""
|
|
319
501
|
return pulumi.get(self, "architectures")
|
|
320
502
|
|
|
321
503
|
@architectures.setter
|
|
322
|
-
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
504
|
+
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
323
505
|
pulumi.set(self, "architectures", value)
|
|
324
506
|
|
|
325
|
-
@property
|
|
507
|
+
@_builtins.property
|
|
326
508
|
@pulumi.getter(name="diskPerformance")
|
|
327
|
-
def disk_performance(self) -> Optional[pulumi.Input[str]]:
|
|
509
|
+
def disk_performance(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
328
510
|
"""
|
|
329
511
|
The filtered vm sizes will support at least one of the classes from this list.
|
|
330
512
|
"""
|
|
331
513
|
return pulumi.get(self, "disk_performance")
|
|
332
514
|
|
|
333
515
|
@disk_performance.setter
|
|
334
|
-
def disk_performance(self, value: Optional[pulumi.Input[str]]):
|
|
516
|
+
def disk_performance(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
335
517
|
pulumi.set(self, "disk_performance", value)
|
|
336
518
|
|
|
337
|
-
@property
|
|
519
|
+
@_builtins.property
|
|
338
520
|
@pulumi.getter(name="excludeSeries")
|
|
339
|
-
def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
521
|
+
def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
340
522
|
"""
|
|
341
523
|
Vm sizes belonging to a series from the list will not be available for scaling
|
|
342
524
|
"""
|
|
343
525
|
return pulumi.get(self, "exclude_series")
|
|
344
526
|
|
|
345
527
|
@exclude_series.setter
|
|
346
|
-
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]]]]):
|
|
347
529
|
pulumi.set(self, "exclude_series", value)
|
|
348
530
|
|
|
349
|
-
@property
|
|
531
|
+
@_builtins.property
|
|
350
532
|
@pulumi.getter(name="gpuTypes")
|
|
351
|
-
def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
533
|
+
def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
352
534
|
"""
|
|
353
535
|
The filtered gpu types will belong to one of the gpu types from this list.
|
|
354
536
|
"""
|
|
355
537
|
return pulumi.get(self, "gpu_types")
|
|
356
538
|
|
|
357
539
|
@gpu_types.setter
|
|
358
|
-
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]]]]):
|
|
359
541
|
pulumi.set(self, "gpu_types", value)
|
|
360
542
|
|
|
361
|
-
@property
|
|
543
|
+
@_builtins.property
|
|
362
544
|
@pulumi.getter(name="maxGpu")
|
|
363
|
-
def max_gpu(self) -> Optional[pulumi.Input[float]]:
|
|
545
|
+
def max_gpu(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
364
546
|
"""
|
|
365
547
|
Maximum number of GPUs available.
|
|
366
548
|
"""
|
|
367
549
|
return pulumi.get(self, "max_gpu")
|
|
368
550
|
|
|
369
551
|
@max_gpu.setter
|
|
370
|
-
def max_gpu(self, value: Optional[pulumi.Input[float]]):
|
|
552
|
+
def max_gpu(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
371
553
|
pulumi.set(self, "max_gpu", value)
|
|
372
554
|
|
|
373
|
-
@property
|
|
555
|
+
@_builtins.property
|
|
374
556
|
@pulumi.getter(name="maxMemoryGib")
|
|
375
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
557
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
376
558
|
"""
|
|
377
559
|
Maximum amount of Memory (GiB).
|
|
378
560
|
"""
|
|
379
561
|
return pulumi.get(self, "max_memory_gib")
|
|
380
562
|
|
|
381
563
|
@max_memory_gib.setter
|
|
382
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
564
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
383
565
|
pulumi.set(self, "max_memory_gib", value)
|
|
384
566
|
|
|
385
|
-
@property
|
|
567
|
+
@_builtins.property
|
|
386
568
|
@pulumi.getter(name="maxVcpu")
|
|
387
|
-
def max_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
569
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
388
570
|
"""
|
|
389
571
|
Maximum number of vcpus available.
|
|
390
572
|
"""
|
|
391
573
|
return pulumi.get(self, "max_vcpu")
|
|
392
574
|
|
|
393
575
|
@max_vcpu.setter
|
|
394
|
-
def max_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
576
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
395
577
|
pulumi.set(self, "max_vcpu", value)
|
|
396
578
|
|
|
397
|
-
@property
|
|
579
|
+
@_builtins.property
|
|
398
580
|
@pulumi.getter(name="minDisk")
|
|
399
|
-
def min_disk(self) -> Optional[pulumi.Input[int]]:
|
|
581
|
+
def min_disk(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
400
582
|
"""
|
|
401
583
|
Minimum number of data disks available.
|
|
402
584
|
"""
|
|
403
585
|
return pulumi.get(self, "min_disk")
|
|
404
586
|
|
|
405
587
|
@min_disk.setter
|
|
406
|
-
def min_disk(self, value: Optional[pulumi.Input[int]]):
|
|
588
|
+
def min_disk(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
407
589
|
pulumi.set(self, "min_disk", value)
|
|
408
590
|
|
|
409
|
-
@property
|
|
591
|
+
@_builtins.property
|
|
410
592
|
@pulumi.getter(name="minGpu")
|
|
411
|
-
def min_gpu(self) -> Optional[pulumi.Input[float]]:
|
|
593
|
+
def min_gpu(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
412
594
|
"""
|
|
413
595
|
Minimum number of GPUs available.
|
|
414
596
|
"""
|
|
415
597
|
return pulumi.get(self, "min_gpu")
|
|
416
598
|
|
|
417
599
|
@min_gpu.setter
|
|
418
|
-
def min_gpu(self, value: Optional[pulumi.Input[float]]):
|
|
600
|
+
def min_gpu(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
419
601
|
pulumi.set(self, "min_gpu", value)
|
|
420
602
|
|
|
421
|
-
@property
|
|
603
|
+
@_builtins.property
|
|
422
604
|
@pulumi.getter(name="minMemoryGib")
|
|
423
|
-
def min_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
605
|
+
def min_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
424
606
|
"""
|
|
425
607
|
Minimum amount of Memory (GiB).
|
|
426
608
|
"""
|
|
427
609
|
return pulumi.get(self, "min_memory_gib")
|
|
428
610
|
|
|
429
611
|
@min_memory_gib.setter
|
|
430
|
-
def min_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
612
|
+
def min_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
431
613
|
pulumi.set(self, "min_memory_gib", value)
|
|
432
614
|
|
|
433
|
-
@property
|
|
615
|
+
@_builtins.property
|
|
434
616
|
@pulumi.getter(name="minNics")
|
|
435
|
-
def min_nics(self) -> Optional[pulumi.Input[int]]:
|
|
617
|
+
def min_nics(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
436
618
|
"""
|
|
437
619
|
Minimum number of network interfaces.
|
|
438
620
|
"""
|
|
439
621
|
return pulumi.get(self, "min_nics")
|
|
440
622
|
|
|
441
623
|
@min_nics.setter
|
|
442
|
-
def min_nics(self, value: Optional[pulumi.Input[int]]):
|
|
624
|
+
def min_nics(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
443
625
|
pulumi.set(self, "min_nics", value)
|
|
444
626
|
|
|
445
|
-
@property
|
|
627
|
+
@_builtins.property
|
|
446
628
|
@pulumi.getter(name="minVcpu")
|
|
447
|
-
def min_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
629
|
+
def min_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
448
630
|
"""
|
|
449
631
|
Minimum number of vcpus available.
|
|
450
632
|
"""
|
|
451
633
|
return pulumi.get(self, "min_vcpu")
|
|
452
634
|
|
|
453
635
|
@min_vcpu.setter
|
|
454
|
-
def min_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
636
|
+
def min_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
455
637
|
pulumi.set(self, "min_vcpu", value)
|
|
456
638
|
|
|
457
|
-
@property
|
|
639
|
+
@_builtins.property
|
|
458
640
|
@pulumi.getter
|
|
459
|
-
def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
641
|
+
def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
460
642
|
"""
|
|
461
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.
|
|
462
644
|
"""
|
|
463
645
|
return pulumi.get(self, "series")
|
|
464
646
|
|
|
465
647
|
@series.setter
|
|
466
|
-
def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
648
|
+
def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
467
649
|
pulumi.set(self, "series", value)
|
|
468
650
|
|
|
469
|
-
@property
|
|
651
|
+
@_builtins.property
|
|
470
652
|
@pulumi.getter(name="vmTypes")
|
|
471
|
-
def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
653
|
+
def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
472
654
|
"""
|
|
473
655
|
The filtered vm types will belong to one of the vm types from this list.
|
|
474
656
|
"""
|
|
475
657
|
return pulumi.get(self, "vm_types")
|
|
476
658
|
|
|
477
659
|
@vm_types.setter
|
|
478
|
-
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]]]]):
|
|
479
661
|
pulumi.set(self, "vm_types", value)
|
|
480
662
|
|
|
481
663
|
|
|
664
|
+
if not MYPY:
|
|
665
|
+
class OceanNpHeadroomArgsDict(TypedDict):
|
|
666
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
667
|
+
"""
|
|
668
|
+
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
669
|
+
"""
|
|
670
|
+
gpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
671
|
+
"""
|
|
672
|
+
Amount of GPU to allocate for headroom unit.
|
|
673
|
+
"""
|
|
674
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
675
|
+
"""
|
|
676
|
+
Configure the amount of memory (MiB) to allocate the headroom.
|
|
677
|
+
"""
|
|
678
|
+
num_of_units: NotRequired[pulumi.Input[_builtins.int]]
|
|
679
|
+
"""
|
|
680
|
+
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
681
|
+
"""
|
|
682
|
+
elif False:
|
|
683
|
+
OceanNpHeadroomArgsDict: TypeAlias = Mapping[str, Any]
|
|
684
|
+
|
|
482
685
|
@pulumi.input_type
|
|
483
686
|
class OceanNpHeadroomArgs:
|
|
484
687
|
def __init__(__self__, *,
|
|
485
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
486
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
487
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None,
|
|
488
|
-
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):
|
|
489
692
|
"""
|
|
490
|
-
: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.
|
|
491
|
-
:param pulumi.Input[int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
|
|
492
|
-
:param pulumi.Input[int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
|
|
493
|
-
: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.
|
|
494
697
|
"""
|
|
495
698
|
if cpu_per_unit is not None:
|
|
496
699
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -501,78 +704,96 @@ class OceanNpHeadroomArgs:
|
|
|
501
704
|
if num_of_units is not None:
|
|
502
705
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
503
706
|
|
|
504
|
-
@property
|
|
707
|
+
@_builtins.property
|
|
505
708
|
@pulumi.getter(name="cpuPerUnit")
|
|
506
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
709
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
507
710
|
"""
|
|
508
711
|
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
509
712
|
"""
|
|
510
713
|
return pulumi.get(self, "cpu_per_unit")
|
|
511
714
|
|
|
512
715
|
@cpu_per_unit.setter
|
|
513
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
716
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
514
717
|
pulumi.set(self, "cpu_per_unit", value)
|
|
515
718
|
|
|
516
|
-
@property
|
|
719
|
+
@_builtins.property
|
|
517
720
|
@pulumi.getter(name="gpuPerUnit")
|
|
518
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
721
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
519
722
|
"""
|
|
520
723
|
Amount of GPU to allocate for headroom unit.
|
|
521
724
|
"""
|
|
522
725
|
return pulumi.get(self, "gpu_per_unit")
|
|
523
726
|
|
|
524
727
|
@gpu_per_unit.setter
|
|
525
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
728
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
526
729
|
pulumi.set(self, "gpu_per_unit", value)
|
|
527
730
|
|
|
528
|
-
@property
|
|
731
|
+
@_builtins.property
|
|
529
732
|
@pulumi.getter(name="memoryPerUnit")
|
|
530
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
733
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
531
734
|
"""
|
|
532
735
|
Configure the amount of memory (MiB) to allocate the headroom.
|
|
533
736
|
"""
|
|
534
737
|
return pulumi.get(self, "memory_per_unit")
|
|
535
738
|
|
|
536
739
|
@memory_per_unit.setter
|
|
537
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
740
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
538
741
|
pulumi.set(self, "memory_per_unit", value)
|
|
539
742
|
|
|
540
|
-
@property
|
|
743
|
+
@_builtins.property
|
|
541
744
|
@pulumi.getter(name="numOfUnits")
|
|
542
|
-
def num_of_units(self) -> Optional[pulumi.Input[int]]:
|
|
745
|
+
def num_of_units(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
543
746
|
"""
|
|
544
747
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
545
748
|
"""
|
|
546
749
|
return pulumi.get(self, "num_of_units")
|
|
547
750
|
|
|
548
751
|
@num_of_units.setter
|
|
549
|
-
def num_of_units(self, value: Optional[pulumi.Input[int]]):
|
|
752
|
+
def num_of_units(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
550
753
|
pulumi.set(self, "num_of_units", value)
|
|
551
754
|
|
|
552
755
|
|
|
756
|
+
if not MYPY:
|
|
757
|
+
class OceanNpHealthArgsDict(TypedDict):
|
|
758
|
+
grace_period: NotRequired[pulumi.Input[_builtins.int]]
|
|
759
|
+
"""
|
|
760
|
+
The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
|
|
761
|
+
"""
|
|
762
|
+
elif False:
|
|
763
|
+
OceanNpHealthArgsDict: TypeAlias = Mapping[str, Any]
|
|
764
|
+
|
|
553
765
|
@pulumi.input_type
|
|
554
766
|
class OceanNpHealthArgs:
|
|
555
767
|
def __init__(__self__, *,
|
|
556
|
-
grace_period: Optional[pulumi.Input[int]] = None):
|
|
768
|
+
grace_period: Optional[pulumi.Input[_builtins.int]] = None):
|
|
557
769
|
"""
|
|
558
|
-
: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.
|
|
559
771
|
"""
|
|
560
772
|
if grace_period is not None:
|
|
561
773
|
pulumi.set(__self__, "grace_period", grace_period)
|
|
562
774
|
|
|
563
|
-
@property
|
|
775
|
+
@_builtins.property
|
|
564
776
|
@pulumi.getter(name="gracePeriod")
|
|
565
|
-
def grace_period(self) -> Optional[pulumi.Input[int]]:
|
|
777
|
+
def grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
566
778
|
"""
|
|
567
779
|
The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
|
|
568
780
|
"""
|
|
569
781
|
return pulumi.get(self, "grace_period")
|
|
570
782
|
|
|
571
783
|
@grace_period.setter
|
|
572
|
-
def grace_period(self, value: Optional[pulumi.Input[int]]):
|
|
784
|
+
def grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
573
785
|
pulumi.set(self, "grace_period", value)
|
|
574
786
|
|
|
575
787
|
|
|
788
|
+
if not MYPY:
|
|
789
|
+
class OceanNpLinuxOsConfigArgsDict(TypedDict):
|
|
790
|
+
sysctls: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigSysctlArgsDict']]]]
|
|
791
|
+
"""
|
|
792
|
+
System Controls
|
|
793
|
+
"""
|
|
794
|
+
elif False:
|
|
795
|
+
OceanNpLinuxOsConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
796
|
+
|
|
576
797
|
@pulumi.input_type
|
|
577
798
|
class OceanNpLinuxOsConfigArgs:
|
|
578
799
|
def __init__(__self__, *,
|
|
@@ -583,7 +804,7 @@ class OceanNpLinuxOsConfigArgs:
|
|
|
583
804
|
if sysctls is not None:
|
|
584
805
|
pulumi.set(__self__, "sysctls", sysctls)
|
|
585
806
|
|
|
586
|
-
@property
|
|
807
|
+
@_builtins.property
|
|
587
808
|
@pulumi.getter
|
|
588
809
|
def sysctls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigSysctlArgs']]]]:
|
|
589
810
|
"""
|
|
@@ -596,49 +817,183 @@ class OceanNpLinuxOsConfigArgs:
|
|
|
596
817
|
pulumi.set(self, "sysctls", value)
|
|
597
818
|
|
|
598
819
|
|
|
820
|
+
if not MYPY:
|
|
821
|
+
class OceanNpLinuxOsConfigSysctlArgsDict(TypedDict):
|
|
822
|
+
vm_max_map_count: NotRequired[pulumi.Input[_builtins.int]]
|
|
823
|
+
"""
|
|
824
|
+
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
825
|
+
"""
|
|
826
|
+
elif False:
|
|
827
|
+
OceanNpLinuxOsConfigSysctlArgsDict: TypeAlias = Mapping[str, Any]
|
|
828
|
+
|
|
599
829
|
@pulumi.input_type
|
|
600
830
|
class OceanNpLinuxOsConfigSysctlArgs:
|
|
601
831
|
def __init__(__self__, *,
|
|
602
|
-
vm_max_map_count: Optional[pulumi.Input[int]] = None):
|
|
832
|
+
vm_max_map_count: Optional[pulumi.Input[_builtins.int]] = None):
|
|
603
833
|
"""
|
|
604
|
-
: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.
|
|
605
835
|
"""
|
|
606
836
|
if vm_max_map_count is not None:
|
|
607
837
|
pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
|
|
608
838
|
|
|
609
|
-
@property
|
|
839
|
+
@_builtins.property
|
|
610
840
|
@pulumi.getter(name="vmMaxMapCount")
|
|
611
|
-
def vm_max_map_count(self) -> Optional[pulumi.Input[int]]:
|
|
841
|
+
def vm_max_map_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
612
842
|
"""
|
|
613
843
|
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
614
844
|
"""
|
|
615
845
|
return pulumi.get(self, "vm_max_map_count")
|
|
616
846
|
|
|
617
847
|
@vm_max_map_count.setter
|
|
618
|
-
def vm_max_map_count(self, value: Optional[pulumi.Input[int]]):
|
|
848
|
+
def vm_max_map_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
619
849
|
pulumi.set(self, "vm_max_map_count", value)
|
|
620
850
|
|
|
621
851
|
|
|
852
|
+
if not MYPY:
|
|
853
|
+
class OceanNpLoggingArgsDict(TypedDict):
|
|
854
|
+
export: NotRequired[pulumi.Input['OceanNpLoggingExportArgsDict']]
|
|
855
|
+
"""
|
|
856
|
+
The Ocean AKS Logging Export object.
|
|
857
|
+
"""
|
|
858
|
+
elif False:
|
|
859
|
+
OceanNpLoggingArgsDict: TypeAlias = Mapping[str, Any]
|
|
860
|
+
|
|
861
|
+
@pulumi.input_type
|
|
862
|
+
class OceanNpLoggingArgs:
|
|
863
|
+
def __init__(__self__, *,
|
|
864
|
+
export: Optional[pulumi.Input['OceanNpLoggingExportArgs']] = None):
|
|
865
|
+
"""
|
|
866
|
+
:param pulumi.Input['OceanNpLoggingExportArgs'] export: The Ocean AKS Logging Export object.
|
|
867
|
+
"""
|
|
868
|
+
if export is not None:
|
|
869
|
+
pulumi.set(__self__, "export", export)
|
|
870
|
+
|
|
871
|
+
@_builtins.property
|
|
872
|
+
@pulumi.getter
|
|
873
|
+
def export(self) -> Optional[pulumi.Input['OceanNpLoggingExportArgs']]:
|
|
874
|
+
"""
|
|
875
|
+
The Ocean AKS Logging Export object.
|
|
876
|
+
"""
|
|
877
|
+
return pulumi.get(self, "export")
|
|
878
|
+
|
|
879
|
+
@export.setter
|
|
880
|
+
def export(self, value: Optional[pulumi.Input['OceanNpLoggingExportArgs']]):
|
|
881
|
+
pulumi.set(self, "export", value)
|
|
882
|
+
|
|
883
|
+
|
|
884
|
+
if not MYPY:
|
|
885
|
+
class OceanNpLoggingExportArgsDict(TypedDict):
|
|
886
|
+
azure_blobs: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanNpLoggingExportAzureBlobArgsDict']]]]
|
|
887
|
+
"""
|
|
888
|
+
Exports your cluster's logs to the storage account and container configured on the storage account [data integration](https://docs.spot.io/ocean/features/log-integration-with-azure-blob?id=log-integration-with-azure-blob) given. Each file contains logs of 3 minutes where each log is separated by a new line and saved as a JSON. The file formats are `container`/`accountId``oceanId``oceanName`_`startTime`.log
|
|
889
|
+
"""
|
|
890
|
+
elif False:
|
|
891
|
+
OceanNpLoggingExportArgsDict: TypeAlias = Mapping[str, Any]
|
|
892
|
+
|
|
893
|
+
@pulumi.input_type
|
|
894
|
+
class OceanNpLoggingExportArgs:
|
|
895
|
+
def __init__(__self__, *,
|
|
896
|
+
azure_blobs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLoggingExportAzureBlobArgs']]]] = None):
|
|
897
|
+
"""
|
|
898
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanNpLoggingExportAzureBlobArgs']]] azure_blobs: Exports your cluster's logs to the storage account and container configured on the storage account [data integration](https://docs.spot.io/ocean/features/log-integration-with-azure-blob?id=log-integration-with-azure-blob) given. Each file contains logs of 3 minutes where each log is separated by a new line and saved as a JSON. The file formats are `container`/`accountId``oceanId``oceanName`_`startTime`.log
|
|
899
|
+
"""
|
|
900
|
+
if azure_blobs is not None:
|
|
901
|
+
pulumi.set(__self__, "azure_blobs", azure_blobs)
|
|
902
|
+
|
|
903
|
+
@_builtins.property
|
|
904
|
+
@pulumi.getter(name="azureBlobs")
|
|
905
|
+
def azure_blobs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLoggingExportAzureBlobArgs']]]]:
|
|
906
|
+
"""
|
|
907
|
+
Exports your cluster's logs to the storage account and container configured on the storage account [data integration](https://docs.spot.io/ocean/features/log-integration-with-azure-blob?id=log-integration-with-azure-blob) given. Each file contains logs of 3 minutes where each log is separated by a new line and saved as a JSON. The file formats are `container`/`accountId``oceanId``oceanName`_`startTime`.log
|
|
908
|
+
"""
|
|
909
|
+
return pulumi.get(self, "azure_blobs")
|
|
910
|
+
|
|
911
|
+
@azure_blobs.setter
|
|
912
|
+
def azure_blobs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLoggingExportAzureBlobArgs']]]]):
|
|
913
|
+
pulumi.set(self, "azure_blobs", value)
|
|
914
|
+
|
|
915
|
+
|
|
916
|
+
if not MYPY:
|
|
917
|
+
class OceanNpLoggingExportAzureBlobArgsDict(TypedDict):
|
|
918
|
+
id: NotRequired[pulumi.Input[_builtins.str]]
|
|
919
|
+
"""
|
|
920
|
+
The identifier of The Azure Blob data integration to export the logs to.
|
|
921
|
+
"""
|
|
922
|
+
elif False:
|
|
923
|
+
OceanNpLoggingExportAzureBlobArgsDict: TypeAlias = Mapping[str, Any]
|
|
924
|
+
|
|
925
|
+
@pulumi.input_type
|
|
926
|
+
class OceanNpLoggingExportAzureBlobArgs:
|
|
927
|
+
def __init__(__self__, *,
|
|
928
|
+
id: Optional[pulumi.Input[_builtins.str]] = None):
|
|
929
|
+
"""
|
|
930
|
+
:param pulumi.Input[_builtins.str] id: The identifier of The Azure Blob data integration to export the logs to.
|
|
931
|
+
"""
|
|
932
|
+
if id is not None:
|
|
933
|
+
pulumi.set(__self__, "id", id)
|
|
934
|
+
|
|
935
|
+
@_builtins.property
|
|
936
|
+
@pulumi.getter
|
|
937
|
+
def id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
938
|
+
"""
|
|
939
|
+
The identifier of The Azure Blob data integration to export the logs to.
|
|
940
|
+
"""
|
|
941
|
+
return pulumi.get(self, "id")
|
|
942
|
+
|
|
943
|
+
@id.setter
|
|
944
|
+
def id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
945
|
+
pulumi.set(self, "id", value)
|
|
946
|
+
|
|
947
|
+
|
|
948
|
+
if not MYPY:
|
|
949
|
+
class OceanNpSchedulingArgsDict(TypedDict):
|
|
950
|
+
shutdown_hours: NotRequired[pulumi.Input['OceanNpSchedulingShutdownHoursArgsDict']]
|
|
951
|
+
"""
|
|
952
|
+
An object used to specify times that the nodes in the virtual node group will be stopped.
|
|
953
|
+
"""
|
|
954
|
+
suspension_hours: NotRequired[pulumi.Input['OceanNpSchedulingSuspensionHoursArgsDict']]
|
|
955
|
+
tasks: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanNpSchedulingTaskArgsDict']]]]
|
|
956
|
+
elif False:
|
|
957
|
+
OceanNpSchedulingArgsDict: TypeAlias = Mapping[str, Any]
|
|
958
|
+
|
|
622
959
|
@pulumi.input_type
|
|
623
960
|
class OceanNpSchedulingArgs:
|
|
624
961
|
def __init__(__self__, *,
|
|
625
962
|
shutdown_hours: Optional[pulumi.Input['OceanNpSchedulingShutdownHoursArgs']] = None,
|
|
963
|
+
suspension_hours: Optional[pulumi.Input['OceanNpSchedulingSuspensionHoursArgs']] = None,
|
|
626
964
|
tasks: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpSchedulingTaskArgs']]]] = None):
|
|
965
|
+
"""
|
|
966
|
+
:param pulumi.Input['OceanNpSchedulingShutdownHoursArgs'] shutdown_hours: An object used to specify times that the nodes in the virtual node group will be stopped.
|
|
967
|
+
"""
|
|
627
968
|
if shutdown_hours is not None:
|
|
628
969
|
pulumi.set(__self__, "shutdown_hours", shutdown_hours)
|
|
970
|
+
if suspension_hours is not None:
|
|
971
|
+
pulumi.set(__self__, "suspension_hours", suspension_hours)
|
|
629
972
|
if tasks is not None:
|
|
630
973
|
pulumi.set(__self__, "tasks", tasks)
|
|
631
974
|
|
|
632
|
-
@property
|
|
975
|
+
@_builtins.property
|
|
633
976
|
@pulumi.getter(name="shutdownHours")
|
|
634
977
|
def shutdown_hours(self) -> Optional[pulumi.Input['OceanNpSchedulingShutdownHoursArgs']]:
|
|
978
|
+
"""
|
|
979
|
+
An object used to specify times that the nodes in the virtual node group will be stopped.
|
|
980
|
+
"""
|
|
635
981
|
return pulumi.get(self, "shutdown_hours")
|
|
636
982
|
|
|
637
983
|
@shutdown_hours.setter
|
|
638
984
|
def shutdown_hours(self, value: Optional[pulumi.Input['OceanNpSchedulingShutdownHoursArgs']]):
|
|
639
985
|
pulumi.set(self, "shutdown_hours", value)
|
|
640
986
|
|
|
641
|
-
@property
|
|
987
|
+
@_builtins.property
|
|
988
|
+
@pulumi.getter(name="suspensionHours")
|
|
989
|
+
def suspension_hours(self) -> Optional[pulumi.Input['OceanNpSchedulingSuspensionHoursArgs']]:
|
|
990
|
+
return pulumi.get(self, "suspension_hours")
|
|
991
|
+
|
|
992
|
+
@suspension_hours.setter
|
|
993
|
+
def suspension_hours(self, value: Optional[pulumi.Input['OceanNpSchedulingSuspensionHoursArgs']]):
|
|
994
|
+
pulumi.set(self, "suspension_hours", value)
|
|
995
|
+
|
|
996
|
+
@_builtins.property
|
|
642
997
|
@pulumi.getter
|
|
643
998
|
def tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpSchedulingTaskArgs']]]]:
|
|
644
999
|
return pulumi.get(self, "tasks")
|
|
@@ -648,41 +1003,111 @@ class OceanNpSchedulingArgs:
|
|
|
648
1003
|
pulumi.set(self, "tasks", value)
|
|
649
1004
|
|
|
650
1005
|
|
|
1006
|
+
if not MYPY:
|
|
1007
|
+
class OceanNpSchedulingShutdownHoursArgsDict(TypedDict):
|
|
1008
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1009
|
+
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1010
|
+
"""
|
|
1011
|
+
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1012
|
+
"""
|
|
1013
|
+
elif False:
|
|
1014
|
+
OceanNpSchedulingShutdownHoursArgsDict: TypeAlias = Mapping[str, Any]
|
|
1015
|
+
|
|
651
1016
|
@pulumi.input_type
|
|
652
1017
|
class OceanNpSchedulingShutdownHoursArgs:
|
|
653
1018
|
def __init__(__self__, *,
|
|
654
|
-
is_enabled: Optional[pulumi.Input[bool]] = None,
|
|
655
|
-
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
|
+
"""
|
|
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
|
+
"""
|
|
656
1024
|
if is_enabled is not None:
|
|
657
1025
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
658
1026
|
if time_windows is not None:
|
|
659
1027
|
pulumi.set(__self__, "time_windows", time_windows)
|
|
660
1028
|
|
|
661
|
-
@property
|
|
1029
|
+
@_builtins.property
|
|
662
1030
|
@pulumi.getter(name="isEnabled")
|
|
663
|
-
def is_enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1031
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
664
1032
|
return pulumi.get(self, "is_enabled")
|
|
665
1033
|
|
|
666
1034
|
@is_enabled.setter
|
|
667
|
-
def is_enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1035
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
668
1036
|
pulumi.set(self, "is_enabled", value)
|
|
669
1037
|
|
|
670
|
-
@property
|
|
1038
|
+
@_builtins.property
|
|
671
1039
|
@pulumi.getter(name="timeWindows")
|
|
672
|
-
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
|
+
"""
|
|
1042
|
+
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1043
|
+
"""
|
|
673
1044
|
return pulumi.get(self, "time_windows")
|
|
674
1045
|
|
|
675
1046
|
@time_windows.setter
|
|
676
|
-
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]]]]):
|
|
677
1048
|
pulumi.set(self, "time_windows", value)
|
|
678
1049
|
|
|
679
1050
|
|
|
1051
|
+
if not MYPY:
|
|
1052
|
+
class OceanNpSchedulingSuspensionHoursArgsDict(TypedDict):
|
|
1053
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1054
|
+
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1055
|
+
"""
|
|
1056
|
+
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1057
|
+
"""
|
|
1058
|
+
elif False:
|
|
1059
|
+
OceanNpSchedulingSuspensionHoursArgsDict: TypeAlias = Mapping[str, Any]
|
|
1060
|
+
|
|
1061
|
+
@pulumi.input_type
|
|
1062
|
+
class OceanNpSchedulingSuspensionHoursArgs:
|
|
1063
|
+
def __init__(__self__, *,
|
|
1064
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1065
|
+
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
1066
|
+
"""
|
|
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
|
+
"""
|
|
1069
|
+
if is_enabled is not None:
|
|
1070
|
+
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
1071
|
+
if time_windows is not None:
|
|
1072
|
+
pulumi.set(__self__, "time_windows", time_windows)
|
|
1073
|
+
|
|
1074
|
+
@_builtins.property
|
|
1075
|
+
@pulumi.getter(name="isEnabled")
|
|
1076
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1077
|
+
return pulumi.get(self, "is_enabled")
|
|
1078
|
+
|
|
1079
|
+
@is_enabled.setter
|
|
1080
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1081
|
+
pulumi.set(self, "is_enabled", value)
|
|
1082
|
+
|
|
1083
|
+
@_builtins.property
|
|
1084
|
+
@pulumi.getter(name="timeWindows")
|
|
1085
|
+
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1086
|
+
"""
|
|
1087
|
+
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
1088
|
+
"""
|
|
1089
|
+
return pulumi.get(self, "time_windows")
|
|
1090
|
+
|
|
1091
|
+
@time_windows.setter
|
|
1092
|
+
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1093
|
+
pulumi.set(self, "time_windows", value)
|
|
1094
|
+
|
|
1095
|
+
|
|
1096
|
+
if not MYPY:
|
|
1097
|
+
class OceanNpSchedulingTaskArgsDict(TypedDict):
|
|
1098
|
+
cron_expression: pulumi.Input[_builtins.str]
|
|
1099
|
+
is_enabled: pulumi.Input[_builtins.bool]
|
|
1100
|
+
task_type: pulumi.Input[_builtins.str]
|
|
1101
|
+
parameters: NotRequired[pulumi.Input['OceanNpSchedulingTaskParametersArgsDict']]
|
|
1102
|
+
elif False:
|
|
1103
|
+
OceanNpSchedulingTaskArgsDict: TypeAlias = Mapping[str, Any]
|
|
1104
|
+
|
|
680
1105
|
@pulumi.input_type
|
|
681
1106
|
class OceanNpSchedulingTaskArgs:
|
|
682
1107
|
def __init__(__self__, *,
|
|
683
|
-
cron_expression: pulumi.Input[str],
|
|
684
|
-
is_enabled: pulumi.Input[bool],
|
|
685
|
-
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],
|
|
686
1111
|
parameters: Optional[pulumi.Input['OceanNpSchedulingTaskParametersArgs']] = None):
|
|
687
1112
|
pulumi.set(__self__, "cron_expression", cron_expression)
|
|
688
1113
|
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
@@ -690,34 +1115,34 @@ class OceanNpSchedulingTaskArgs:
|
|
|
690
1115
|
if parameters is not None:
|
|
691
1116
|
pulumi.set(__self__, "parameters", parameters)
|
|
692
1117
|
|
|
693
|
-
@property
|
|
1118
|
+
@_builtins.property
|
|
694
1119
|
@pulumi.getter(name="cronExpression")
|
|
695
|
-
def cron_expression(self) -> pulumi.Input[str]:
|
|
1120
|
+
def cron_expression(self) -> pulumi.Input[_builtins.str]:
|
|
696
1121
|
return pulumi.get(self, "cron_expression")
|
|
697
1122
|
|
|
698
1123
|
@cron_expression.setter
|
|
699
|
-
def cron_expression(self, value: pulumi.Input[str]):
|
|
1124
|
+
def cron_expression(self, value: pulumi.Input[_builtins.str]):
|
|
700
1125
|
pulumi.set(self, "cron_expression", value)
|
|
701
1126
|
|
|
702
|
-
@property
|
|
1127
|
+
@_builtins.property
|
|
703
1128
|
@pulumi.getter(name="isEnabled")
|
|
704
|
-
def is_enabled(self) -> pulumi.Input[bool]:
|
|
1129
|
+
def is_enabled(self) -> pulumi.Input[_builtins.bool]:
|
|
705
1130
|
return pulumi.get(self, "is_enabled")
|
|
706
1131
|
|
|
707
1132
|
@is_enabled.setter
|
|
708
|
-
def is_enabled(self, value: pulumi.Input[bool]):
|
|
1133
|
+
def is_enabled(self, value: pulumi.Input[_builtins.bool]):
|
|
709
1134
|
pulumi.set(self, "is_enabled", value)
|
|
710
1135
|
|
|
711
|
-
@property
|
|
1136
|
+
@_builtins.property
|
|
712
1137
|
@pulumi.getter(name="taskType")
|
|
713
|
-
def task_type(self) -> pulumi.Input[str]:
|
|
1138
|
+
def task_type(self) -> pulumi.Input[_builtins.str]:
|
|
714
1139
|
return pulumi.get(self, "task_type")
|
|
715
1140
|
|
|
716
1141
|
@task_type.setter
|
|
717
|
-
def task_type(self, value: pulumi.Input[str]):
|
|
1142
|
+
def task_type(self, value: pulumi.Input[_builtins.str]):
|
|
718
1143
|
pulumi.set(self, "task_type", value)
|
|
719
1144
|
|
|
720
|
-
@property
|
|
1145
|
+
@_builtins.property
|
|
721
1146
|
@pulumi.getter
|
|
722
1147
|
def parameters(self) -> Optional[pulumi.Input['OceanNpSchedulingTaskParametersArgs']]:
|
|
723
1148
|
return pulumi.get(self, "parameters")
|
|
@@ -727,14 +1152,24 @@ class OceanNpSchedulingTaskArgs:
|
|
|
727
1152
|
pulumi.set(self, "parameters", value)
|
|
728
1153
|
|
|
729
1154
|
|
|
1155
|
+
if not MYPY:
|
|
1156
|
+
class OceanNpSchedulingTaskParametersArgsDict(TypedDict):
|
|
1157
|
+
parameters_cluster_roll: NotRequired[pulumi.Input['OceanNpSchedulingTaskParametersParametersClusterRollArgsDict']]
|
|
1158
|
+
parameters_upgrade_config: NotRequired[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigArgsDict']]
|
|
1159
|
+
elif False:
|
|
1160
|
+
OceanNpSchedulingTaskParametersArgsDict: TypeAlias = Mapping[str, Any]
|
|
1161
|
+
|
|
730
1162
|
@pulumi.input_type
|
|
731
1163
|
class OceanNpSchedulingTaskParametersArgs:
|
|
732
1164
|
def __init__(__self__, *,
|
|
733
|
-
parameters_cluster_roll: Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersClusterRollArgs']] = None
|
|
1165
|
+
parameters_cluster_roll: Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersClusterRollArgs']] = None,
|
|
1166
|
+
parameters_upgrade_config: Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs']] = None):
|
|
734
1167
|
if parameters_cluster_roll is not None:
|
|
735
1168
|
pulumi.set(__self__, "parameters_cluster_roll", parameters_cluster_roll)
|
|
1169
|
+
if parameters_upgrade_config is not None:
|
|
1170
|
+
pulumi.set(__self__, "parameters_upgrade_config", parameters_upgrade_config)
|
|
736
1171
|
|
|
737
|
-
@property
|
|
1172
|
+
@_builtins.property
|
|
738
1173
|
@pulumi.getter(name="parametersClusterRoll")
|
|
739
1174
|
def parameters_cluster_roll(self) -> Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersClusterRollArgs']]:
|
|
740
1175
|
return pulumi.get(self, "parameters_cluster_roll")
|
|
@@ -743,16 +1178,62 @@ class OceanNpSchedulingTaskParametersArgs:
|
|
|
743
1178
|
def parameters_cluster_roll(self, value: Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersClusterRollArgs']]):
|
|
744
1179
|
pulumi.set(self, "parameters_cluster_roll", value)
|
|
745
1180
|
|
|
1181
|
+
@_builtins.property
|
|
1182
|
+
@pulumi.getter(name="parametersUpgradeConfig")
|
|
1183
|
+
def parameters_upgrade_config(self) -> Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs']]:
|
|
1184
|
+
return pulumi.get(self, "parameters_upgrade_config")
|
|
1185
|
+
|
|
1186
|
+
@parameters_upgrade_config.setter
|
|
1187
|
+
def parameters_upgrade_config(self, value: Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs']]):
|
|
1188
|
+
pulumi.set(self, "parameters_upgrade_config", value)
|
|
1189
|
+
|
|
1190
|
+
|
|
1191
|
+
if not MYPY:
|
|
1192
|
+
class OceanNpSchedulingTaskParametersParametersClusterRollArgsDict(TypedDict):
|
|
1193
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
1194
|
+
"""
|
|
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
|
+
"""
|
|
1197
|
+
batch_size_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
1198
|
+
"""
|
|
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
|
+
"""
|
|
1201
|
+
comment: NotRequired[pulumi.Input[_builtins.str]]
|
|
1202
|
+
"""
|
|
1203
|
+
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1204
|
+
"""
|
|
1205
|
+
respect_pdb: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1206
|
+
"""
|
|
1207
|
+
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1208
|
+
"""
|
|
1209
|
+
respect_restrict_scale_down: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1210
|
+
"""
|
|
1211
|
+
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1212
|
+
"""
|
|
1213
|
+
vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1214
|
+
"""
|
|
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
|
+
"""
|
|
1217
|
+
elif False:
|
|
1218
|
+
OceanNpSchedulingTaskParametersParametersClusterRollArgsDict: TypeAlias = Mapping[str, Any]
|
|
746
1219
|
|
|
747
1220
|
@pulumi.input_type
|
|
748
1221
|
class OceanNpSchedulingTaskParametersParametersClusterRollArgs:
|
|
749
1222
|
def __init__(__self__, *,
|
|
750
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
751
|
-
batch_size_percentage: Optional[pulumi.Input[int]] = None,
|
|
752
|
-
comment: Optional[pulumi.Input[str]] = None,
|
|
753
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None,
|
|
754
|
-
respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None,
|
|
755
|
-
vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
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
|
+
"""
|
|
756
1237
|
if batch_min_healthy_percentage is not None:
|
|
757
1238
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
758
1239
|
if batch_size_percentage is not None:
|
|
@@ -766,122 +1247,335 @@ class OceanNpSchedulingTaskParametersParametersClusterRollArgs:
|
|
|
766
1247
|
if vng_ids is not None:
|
|
767
1248
|
pulumi.set(__self__, "vng_ids", vng_ids)
|
|
768
1249
|
|
|
769
|
-
@property
|
|
1250
|
+
@_builtins.property
|
|
770
1251
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
771
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1252
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1253
|
+
"""
|
|
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
|
+
"""
|
|
772
1256
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
773
1257
|
|
|
774
1258
|
@batch_min_healthy_percentage.setter
|
|
775
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1259
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
776
1260
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
777
1261
|
|
|
778
|
-
@property
|
|
1262
|
+
@_builtins.property
|
|
779
1263
|
@pulumi.getter(name="batchSizePercentage")
|
|
780
|
-
def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1264
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1265
|
+
"""
|
|
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
|
+
"""
|
|
1268
|
+
return pulumi.get(self, "batch_size_percentage")
|
|
1269
|
+
|
|
1270
|
+
@batch_size_percentage.setter
|
|
1271
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1272
|
+
pulumi.set(self, "batch_size_percentage", value)
|
|
1273
|
+
|
|
1274
|
+
@_builtins.property
|
|
1275
|
+
@pulumi.getter
|
|
1276
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1277
|
+
"""
|
|
1278
|
+
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1279
|
+
"""
|
|
1280
|
+
return pulumi.get(self, "comment")
|
|
1281
|
+
|
|
1282
|
+
@comment.setter
|
|
1283
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1284
|
+
pulumi.set(self, "comment", value)
|
|
1285
|
+
|
|
1286
|
+
@_builtins.property
|
|
1287
|
+
@pulumi.getter(name="respectPdb")
|
|
1288
|
+
def respect_pdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1289
|
+
"""
|
|
1290
|
+
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1291
|
+
"""
|
|
1292
|
+
return pulumi.get(self, "respect_pdb")
|
|
1293
|
+
|
|
1294
|
+
@respect_pdb.setter
|
|
1295
|
+
def respect_pdb(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1296
|
+
pulumi.set(self, "respect_pdb", value)
|
|
1297
|
+
|
|
1298
|
+
@_builtins.property
|
|
1299
|
+
@pulumi.getter(name="respectRestrictScaleDown")
|
|
1300
|
+
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1301
|
+
"""
|
|
1302
|
+
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1303
|
+
"""
|
|
1304
|
+
return pulumi.get(self, "respect_restrict_scale_down")
|
|
1305
|
+
|
|
1306
|
+
@respect_restrict_scale_down.setter
|
|
1307
|
+
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1308
|
+
pulumi.set(self, "respect_restrict_scale_down", value)
|
|
1309
|
+
|
|
1310
|
+
@_builtins.property
|
|
1311
|
+
@pulumi.getter(name="vngIds")
|
|
1312
|
+
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1313
|
+
"""
|
|
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
|
+
"""
|
|
1316
|
+
return pulumi.get(self, "vng_ids")
|
|
1317
|
+
|
|
1318
|
+
@vng_ids.setter
|
|
1319
|
+
def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1320
|
+
pulumi.set(self, "vng_ids", value)
|
|
1321
|
+
|
|
1322
|
+
|
|
1323
|
+
if not MYPY:
|
|
1324
|
+
class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgsDict(TypedDict):
|
|
1325
|
+
apply_roll: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1326
|
+
roll_parameters: NotRequired[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgsDict']]
|
|
1327
|
+
scope_version: NotRequired[pulumi.Input[_builtins.str]]
|
|
1328
|
+
elif False:
|
|
1329
|
+
OceanNpSchedulingTaskParametersParametersUpgradeConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
1330
|
+
|
|
1331
|
+
@pulumi.input_type
|
|
1332
|
+
class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs:
|
|
1333
|
+
def __init__(__self__, *,
|
|
1334
|
+
apply_roll: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1335
|
+
roll_parameters: Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs']] = None,
|
|
1336
|
+
scope_version: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1337
|
+
if apply_roll is not None:
|
|
1338
|
+
pulumi.set(__self__, "apply_roll", apply_roll)
|
|
1339
|
+
if roll_parameters is not None:
|
|
1340
|
+
pulumi.set(__self__, "roll_parameters", roll_parameters)
|
|
1341
|
+
if scope_version is not None:
|
|
1342
|
+
pulumi.set(__self__, "scope_version", scope_version)
|
|
1343
|
+
|
|
1344
|
+
@_builtins.property
|
|
1345
|
+
@pulumi.getter(name="applyRoll")
|
|
1346
|
+
def apply_roll(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1347
|
+
return pulumi.get(self, "apply_roll")
|
|
1348
|
+
|
|
1349
|
+
@apply_roll.setter
|
|
1350
|
+
def apply_roll(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1351
|
+
pulumi.set(self, "apply_roll", value)
|
|
1352
|
+
|
|
1353
|
+
@_builtins.property
|
|
1354
|
+
@pulumi.getter(name="rollParameters")
|
|
1355
|
+
def roll_parameters(self) -> Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs']]:
|
|
1356
|
+
return pulumi.get(self, "roll_parameters")
|
|
1357
|
+
|
|
1358
|
+
@roll_parameters.setter
|
|
1359
|
+
def roll_parameters(self, value: Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs']]):
|
|
1360
|
+
pulumi.set(self, "roll_parameters", value)
|
|
1361
|
+
|
|
1362
|
+
@_builtins.property
|
|
1363
|
+
@pulumi.getter(name="scopeVersion")
|
|
1364
|
+
def scope_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1365
|
+
return pulumi.get(self, "scope_version")
|
|
1366
|
+
|
|
1367
|
+
@scope_version.setter
|
|
1368
|
+
def scope_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1369
|
+
pulumi.set(self, "scope_version", value)
|
|
1370
|
+
|
|
1371
|
+
|
|
1372
|
+
if not MYPY:
|
|
1373
|
+
class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgsDict(TypedDict):
|
|
1374
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
1375
|
+
"""
|
|
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
|
+
"""
|
|
1378
|
+
batch_size_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
1379
|
+
"""
|
|
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
|
+
"""
|
|
1382
|
+
comment: NotRequired[pulumi.Input[_builtins.str]]
|
|
1383
|
+
"""
|
|
1384
|
+
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1385
|
+
"""
|
|
1386
|
+
respect_pdb: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1387
|
+
"""
|
|
1388
|
+
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1389
|
+
"""
|
|
1390
|
+
respect_restrict_scale_down: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1391
|
+
"""
|
|
1392
|
+
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1393
|
+
"""
|
|
1394
|
+
elif False:
|
|
1395
|
+
OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgsDict: TypeAlias = Mapping[str, Any]
|
|
1396
|
+
|
|
1397
|
+
@pulumi.input_type
|
|
1398
|
+
class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs:
|
|
1399
|
+
def __init__(__self__, *,
|
|
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
|
+
"""
|
|
1412
|
+
if batch_min_healthy_percentage is not None:
|
|
1413
|
+
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
1414
|
+
if batch_size_percentage is not None:
|
|
1415
|
+
pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
|
|
1416
|
+
if comment is not None:
|
|
1417
|
+
pulumi.set(__self__, "comment", comment)
|
|
1418
|
+
if respect_pdb is not None:
|
|
1419
|
+
pulumi.set(__self__, "respect_pdb", respect_pdb)
|
|
1420
|
+
if respect_restrict_scale_down is not None:
|
|
1421
|
+
pulumi.set(__self__, "respect_restrict_scale_down", respect_restrict_scale_down)
|
|
1422
|
+
|
|
1423
|
+
@_builtins.property
|
|
1424
|
+
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1425
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1426
|
+
"""
|
|
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
|
+
"""
|
|
1429
|
+
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1430
|
+
|
|
1431
|
+
@batch_min_healthy_percentage.setter
|
|
1432
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1433
|
+
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
1434
|
+
|
|
1435
|
+
@_builtins.property
|
|
1436
|
+
@pulumi.getter(name="batchSizePercentage")
|
|
1437
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1438
|
+
"""
|
|
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
|
+
"""
|
|
781
1441
|
return pulumi.get(self, "batch_size_percentage")
|
|
782
1442
|
|
|
783
1443
|
@batch_size_percentage.setter
|
|
784
|
-
def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1444
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
785
1445
|
pulumi.set(self, "batch_size_percentage", value)
|
|
786
1446
|
|
|
787
|
-
@property
|
|
1447
|
+
@_builtins.property
|
|
788
1448
|
@pulumi.getter
|
|
789
|
-
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
1449
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1450
|
+
"""
|
|
1451
|
+
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1452
|
+
"""
|
|
790
1453
|
return pulumi.get(self, "comment")
|
|
791
1454
|
|
|
792
1455
|
@comment.setter
|
|
793
|
-
def comment(self, value: Optional[pulumi.Input[str]]):
|
|
1456
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
794
1457
|
pulumi.set(self, "comment", value)
|
|
795
1458
|
|
|
796
|
-
@property
|
|
1459
|
+
@_builtins.property
|
|
797
1460
|
@pulumi.getter(name="respectPdb")
|
|
798
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
1461
|
+
def respect_pdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1462
|
+
"""
|
|
1463
|
+
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1464
|
+
"""
|
|
799
1465
|
return pulumi.get(self, "respect_pdb")
|
|
800
1466
|
|
|
801
1467
|
@respect_pdb.setter
|
|
802
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
1468
|
+
def respect_pdb(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
803
1469
|
pulumi.set(self, "respect_pdb", value)
|
|
804
1470
|
|
|
805
|
-
@property
|
|
1471
|
+
@_builtins.property
|
|
806
1472
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
807
|
-
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
|
|
1473
|
+
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1474
|
+
"""
|
|
1475
|
+
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1476
|
+
"""
|
|
808
1477
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
809
1478
|
|
|
810
1479
|
@respect_restrict_scale_down.setter
|
|
811
|
-
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
|
|
1480
|
+
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
812
1481
|
pulumi.set(self, "respect_restrict_scale_down", value)
|
|
813
1482
|
|
|
814
|
-
@property
|
|
815
|
-
@pulumi.getter(name="vngIds")
|
|
816
|
-
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
817
|
-
return pulumi.get(self, "vng_ids")
|
|
818
|
-
|
|
819
|
-
@vng_ids.setter
|
|
820
|
-
def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
821
|
-
pulumi.set(self, "vng_ids", value)
|
|
822
1483
|
|
|
1484
|
+
if not MYPY:
|
|
1485
|
+
class OceanNpTaintArgsDict(TypedDict):
|
|
1486
|
+
effect: pulumi.Input[_builtins.str]
|
|
1487
|
+
"""
|
|
1488
|
+
Set taint effect.
|
|
1489
|
+
"""
|
|
1490
|
+
key: pulumi.Input[_builtins.str]
|
|
1491
|
+
"""
|
|
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
|
+
"""
|
|
1494
|
+
value: pulumi.Input[_builtins.str]
|
|
1495
|
+
"""
|
|
1496
|
+
Set taint value.
|
|
1497
|
+
"""
|
|
1498
|
+
elif False:
|
|
1499
|
+
OceanNpTaintArgsDict: TypeAlias = Mapping[str, Any]
|
|
823
1500
|
|
|
824
1501
|
@pulumi.input_type
|
|
825
1502
|
class OceanNpTaintArgs:
|
|
826
1503
|
def __init__(__self__, *,
|
|
827
|
-
effect: pulumi.Input[str],
|
|
828
|
-
key: pulumi.Input[str],
|
|
829
|
-
value: pulumi.Input[str]):
|
|
1504
|
+
effect: pulumi.Input[_builtins.str],
|
|
1505
|
+
key: pulumi.Input[_builtins.str],
|
|
1506
|
+
value: pulumi.Input[_builtins.str]):
|
|
830
1507
|
"""
|
|
831
|
-
:param pulumi.Input[str] effect: Set taint effect.
|
|
832
|
-
: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"]
|
|
833
|
-
: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.
|
|
834
1511
|
"""
|
|
835
1512
|
pulumi.set(__self__, "effect", effect)
|
|
836
1513
|
pulumi.set(__self__, "key", key)
|
|
837
1514
|
pulumi.set(__self__, "value", value)
|
|
838
1515
|
|
|
839
|
-
@property
|
|
1516
|
+
@_builtins.property
|
|
840
1517
|
@pulumi.getter
|
|
841
|
-
def effect(self) -> pulumi.Input[str]:
|
|
1518
|
+
def effect(self) -> pulumi.Input[_builtins.str]:
|
|
842
1519
|
"""
|
|
843
1520
|
Set taint effect.
|
|
844
1521
|
"""
|
|
845
1522
|
return pulumi.get(self, "effect")
|
|
846
1523
|
|
|
847
1524
|
@effect.setter
|
|
848
|
-
def effect(self, value: pulumi.Input[str]):
|
|
1525
|
+
def effect(self, value: pulumi.Input[_builtins.str]):
|
|
849
1526
|
pulumi.set(self, "effect", value)
|
|
850
1527
|
|
|
851
|
-
@property
|
|
1528
|
+
@_builtins.property
|
|
852
1529
|
@pulumi.getter
|
|
853
|
-
def key(self) -> pulumi.Input[str]:
|
|
1530
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
854
1531
|
"""
|
|
855
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"]
|
|
856
1533
|
"""
|
|
857
1534
|
return pulumi.get(self, "key")
|
|
858
1535
|
|
|
859
1536
|
@key.setter
|
|
860
|
-
def key(self, value: pulumi.Input[str]):
|
|
1537
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
861
1538
|
pulumi.set(self, "key", value)
|
|
862
1539
|
|
|
863
|
-
@property
|
|
1540
|
+
@_builtins.property
|
|
864
1541
|
@pulumi.getter
|
|
865
|
-
def value(self) -> pulumi.Input[str]:
|
|
1542
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
866
1543
|
"""
|
|
867
1544
|
Set taint value.
|
|
868
1545
|
"""
|
|
869
1546
|
return pulumi.get(self, "value")
|
|
870
1547
|
|
|
871
1548
|
@value.setter
|
|
872
|
-
def value(self, value: pulumi.Input[str]):
|
|
1549
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
873
1550
|
pulumi.set(self, "value", value)
|
|
874
1551
|
|
|
875
1552
|
|
|
1553
|
+
if not MYPY:
|
|
1554
|
+
class OceanNpUpdatePolicyArgsDict(TypedDict):
|
|
1555
|
+
should_roll: pulumi.Input[_builtins.bool]
|
|
1556
|
+
"""
|
|
1557
|
+
If set to true along with the cluster update, roll will be triggered.
|
|
1558
|
+
"""
|
|
1559
|
+
conditioned_roll: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1560
|
+
"""
|
|
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
|
+
"""
|
|
1563
|
+
roll_config: NotRequired[pulumi.Input['OceanNpUpdatePolicyRollConfigArgsDict']]
|
|
1564
|
+
"""
|
|
1565
|
+
While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
1566
|
+
"""
|
|
1567
|
+
elif False:
|
|
1568
|
+
OceanNpUpdatePolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
1569
|
+
|
|
876
1570
|
@pulumi.input_type
|
|
877
1571
|
class OceanNpUpdatePolicyArgs:
|
|
878
1572
|
def __init__(__self__, *,
|
|
879
|
-
should_roll: pulumi.Input[bool],
|
|
880
|
-
conditioned_roll: Optional[pulumi.Input[bool]] = None,
|
|
1573
|
+
should_roll: pulumi.Input[_builtins.bool],
|
|
1574
|
+
conditioned_roll: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
881
1575
|
roll_config: Optional[pulumi.Input['OceanNpUpdatePolicyRollConfigArgs']] = None):
|
|
882
1576
|
"""
|
|
883
|
-
:param pulumi.Input[bool] should_roll: If set to true along with the cluster update, roll will be triggered.
|
|
884
|
-
: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).
|
|
885
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.
|
|
886
1580
|
"""
|
|
887
1581
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
@@ -890,31 +1584,31 @@ class OceanNpUpdatePolicyArgs:
|
|
|
890
1584
|
if roll_config is not None:
|
|
891
1585
|
pulumi.set(__self__, "roll_config", roll_config)
|
|
892
1586
|
|
|
893
|
-
@property
|
|
1587
|
+
@_builtins.property
|
|
894
1588
|
@pulumi.getter(name="shouldRoll")
|
|
895
|
-
def should_roll(self) -> pulumi.Input[bool]:
|
|
1589
|
+
def should_roll(self) -> pulumi.Input[_builtins.bool]:
|
|
896
1590
|
"""
|
|
897
1591
|
If set to true along with the cluster update, roll will be triggered.
|
|
898
1592
|
"""
|
|
899
1593
|
return pulumi.get(self, "should_roll")
|
|
900
1594
|
|
|
901
1595
|
@should_roll.setter
|
|
902
|
-
def should_roll(self, value: pulumi.Input[bool]):
|
|
1596
|
+
def should_roll(self, value: pulumi.Input[_builtins.bool]):
|
|
903
1597
|
pulumi.set(self, "should_roll", value)
|
|
904
1598
|
|
|
905
|
-
@property
|
|
1599
|
+
@_builtins.property
|
|
906
1600
|
@pulumi.getter(name="conditionedRoll")
|
|
907
|
-
def conditioned_roll(self) -> Optional[pulumi.Input[bool]]:
|
|
1601
|
+
def conditioned_roll(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
908
1602
|
"""
|
|
909
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).
|
|
910
1604
|
"""
|
|
911
1605
|
return pulumi.get(self, "conditioned_roll")
|
|
912
1606
|
|
|
913
1607
|
@conditioned_roll.setter
|
|
914
|
-
def conditioned_roll(self, value: Optional[pulumi.Input[bool]]):
|
|
1608
|
+
def conditioned_roll(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
915
1609
|
pulumi.set(self, "conditioned_roll", value)
|
|
916
1610
|
|
|
917
|
-
@property
|
|
1611
|
+
@_builtins.property
|
|
918
1612
|
@pulumi.getter(name="rollConfig")
|
|
919
1613
|
def roll_config(self) -> Optional[pulumi.Input['OceanNpUpdatePolicyRollConfigArgs']]:
|
|
920
1614
|
"""
|
|
@@ -927,26 +1621,63 @@ class OceanNpUpdatePolicyArgs:
|
|
|
927
1621
|
pulumi.set(self, "roll_config", value)
|
|
928
1622
|
|
|
929
1623
|
|
|
1624
|
+
if not MYPY:
|
|
1625
|
+
class OceanNpUpdatePolicyRollConfigArgsDict(TypedDict):
|
|
1626
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
1627
|
+
"""
|
|
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
|
+
"""
|
|
1630
|
+
batch_size_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
1631
|
+
"""
|
|
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
|
+
"""
|
|
1634
|
+
comment: NotRequired[pulumi.Input[_builtins.str]]
|
|
1635
|
+
"""
|
|
1636
|
+
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1637
|
+
"""
|
|
1638
|
+
node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1639
|
+
"""
|
|
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
|
+
"""
|
|
1642
|
+
node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1643
|
+
"""
|
|
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
|
+
"""
|
|
1646
|
+
respect_pdb: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1647
|
+
"""
|
|
1648
|
+
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1649
|
+
"""
|
|
1650
|
+
respect_restrict_scale_down: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1651
|
+
"""
|
|
1652
|
+
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1653
|
+
"""
|
|
1654
|
+
vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1655
|
+
"""
|
|
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
|
+
"""
|
|
1658
|
+
elif False:
|
|
1659
|
+
OceanNpUpdatePolicyRollConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
1660
|
+
|
|
930
1661
|
@pulumi.input_type
|
|
931
1662
|
class OceanNpUpdatePolicyRollConfigArgs:
|
|
932
1663
|
def __init__(__self__, *,
|
|
933
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
934
|
-
batch_size_percentage: Optional[pulumi.Input[int]] = None,
|
|
935
|
-
comment: Optional[pulumi.Input[str]] = None,
|
|
936
|
-
node_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
937
|
-
node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
938
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None,
|
|
939
|
-
respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None,
|
|
940
|
-
vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
941
|
-
"""
|
|
942
|
-
: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.
|
|
943
|
-
: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%.
|
|
944
|
-
:param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
945
|
-
: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.
|
|
946
|
-
: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.
|
|
947
|
-
:param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
948
|
-
: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.
|
|
949
|
-
: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.
|
|
950
1681
|
"""
|
|
951
1682
|
if batch_min_healthy_percentage is not None:
|
|
952
1683
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -965,137 +1696,202 @@ class OceanNpUpdatePolicyRollConfigArgs:
|
|
|
965
1696
|
if vng_ids is not None:
|
|
966
1697
|
pulumi.set(__self__, "vng_ids", vng_ids)
|
|
967
1698
|
|
|
968
|
-
@property
|
|
1699
|
+
@_builtins.property
|
|
969
1700
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
970
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1701
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
971
1702
|
"""
|
|
972
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.
|
|
973
1704
|
"""
|
|
974
1705
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
975
1706
|
|
|
976
1707
|
@batch_min_healthy_percentage.setter
|
|
977
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1708
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
978
1709
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
979
1710
|
|
|
980
|
-
@property
|
|
1711
|
+
@_builtins.property
|
|
981
1712
|
@pulumi.getter(name="batchSizePercentage")
|
|
982
|
-
def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1713
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
983
1714
|
"""
|
|
984
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%.
|
|
985
1716
|
"""
|
|
986
1717
|
return pulumi.get(self, "batch_size_percentage")
|
|
987
1718
|
|
|
988
1719
|
@batch_size_percentage.setter
|
|
989
|
-
def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1720
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
990
1721
|
pulumi.set(self, "batch_size_percentage", value)
|
|
991
1722
|
|
|
992
|
-
@property
|
|
1723
|
+
@_builtins.property
|
|
993
1724
|
@pulumi.getter
|
|
994
|
-
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
1725
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
995
1726
|
"""
|
|
996
1727
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
997
1728
|
"""
|
|
998
1729
|
return pulumi.get(self, "comment")
|
|
999
1730
|
|
|
1000
1731
|
@comment.setter
|
|
1001
|
-
def comment(self, value: Optional[pulumi.Input[str]]):
|
|
1732
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1002
1733
|
pulumi.set(self, "comment", value)
|
|
1003
1734
|
|
|
1004
|
-
@property
|
|
1735
|
+
@_builtins.property
|
|
1005
1736
|
@pulumi.getter(name="nodeNames")
|
|
1006
|
-
def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1737
|
+
def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1007
1738
|
"""
|
|
1008
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.
|
|
1009
1740
|
"""
|
|
1010
1741
|
return pulumi.get(self, "node_names")
|
|
1011
1742
|
|
|
1012
1743
|
@node_names.setter
|
|
1013
|
-
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]]]]):
|
|
1014
1745
|
pulumi.set(self, "node_names", value)
|
|
1015
1746
|
|
|
1016
|
-
@property
|
|
1747
|
+
@_builtins.property
|
|
1017
1748
|
@pulumi.getter(name="nodePoolNames")
|
|
1018
|
-
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]]]]:
|
|
1019
1750
|
"""
|
|
1020
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.
|
|
1021
1752
|
"""
|
|
1022
1753
|
return pulumi.get(self, "node_pool_names")
|
|
1023
1754
|
|
|
1024
1755
|
@node_pool_names.setter
|
|
1025
|
-
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]]]]):
|
|
1026
1757
|
pulumi.set(self, "node_pool_names", value)
|
|
1027
1758
|
|
|
1028
|
-
@property
|
|
1759
|
+
@_builtins.property
|
|
1029
1760
|
@pulumi.getter(name="respectPdb")
|
|
1030
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
1761
|
+
def respect_pdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1031
1762
|
"""
|
|
1032
1763
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1033
1764
|
"""
|
|
1034
1765
|
return pulumi.get(self, "respect_pdb")
|
|
1035
1766
|
|
|
1036
1767
|
@respect_pdb.setter
|
|
1037
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
1768
|
+
def respect_pdb(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1038
1769
|
pulumi.set(self, "respect_pdb", value)
|
|
1039
1770
|
|
|
1040
|
-
@property
|
|
1771
|
+
@_builtins.property
|
|
1041
1772
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
1042
|
-
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
|
|
1773
|
+
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1043
1774
|
"""
|
|
1044
1775
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1045
1776
|
"""
|
|
1046
1777
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
1047
1778
|
|
|
1048
1779
|
@respect_restrict_scale_down.setter
|
|
1049
|
-
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
|
|
1780
|
+
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1050
1781
|
pulumi.set(self, "respect_restrict_scale_down", value)
|
|
1051
1782
|
|
|
1052
|
-
@property
|
|
1783
|
+
@_builtins.property
|
|
1053
1784
|
@pulumi.getter(name="vngIds")
|
|
1054
|
-
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1785
|
+
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1055
1786
|
"""
|
|
1056
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.
|
|
1057
1788
|
"""
|
|
1058
1789
|
return pulumi.get(self, "vng_ids")
|
|
1059
1790
|
|
|
1060
1791
|
@vng_ids.setter
|
|
1061
|
-
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]]]]):
|
|
1062
1793
|
pulumi.set(self, "vng_ids", value)
|
|
1063
1794
|
|
|
1064
1795
|
|
|
1796
|
+
if not MYPY:
|
|
1797
|
+
class OceanNpVirtualNodeGroupFiltersArgsDict(TypedDict):
|
|
1798
|
+
accelerated_networking: NotRequired[pulumi.Input[_builtins.str]]
|
|
1799
|
+
"""
|
|
1800
|
+
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
1801
|
+
"""
|
|
1802
|
+
architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1803
|
+
"""
|
|
1804
|
+
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
1805
|
+
"""
|
|
1806
|
+
disk_performance: NotRequired[pulumi.Input[_builtins.str]]
|
|
1807
|
+
"""
|
|
1808
|
+
The filtered vm sizes will support at least one of the classes from this list.
|
|
1809
|
+
"""
|
|
1810
|
+
exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1811
|
+
"""
|
|
1812
|
+
Vm sizes belonging to a series from the list will not be available for scaling.
|
|
1813
|
+
"""
|
|
1814
|
+
gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1815
|
+
"""
|
|
1816
|
+
The filtered gpu types will belong to one of the gpu types from this list.
|
|
1817
|
+
"""
|
|
1818
|
+
max_gpu: NotRequired[pulumi.Input[_builtins.float]]
|
|
1819
|
+
"""
|
|
1820
|
+
Maximum number of GPUs available.
|
|
1821
|
+
"""
|
|
1822
|
+
max_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
1823
|
+
"""
|
|
1824
|
+
Maximum amount of Memory (GiB).
|
|
1825
|
+
"""
|
|
1826
|
+
max_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
1827
|
+
"""
|
|
1828
|
+
Maximum number of vcpus available.
|
|
1829
|
+
"""
|
|
1830
|
+
min_disk: NotRequired[pulumi.Input[_builtins.int]]
|
|
1831
|
+
"""
|
|
1832
|
+
Minimum number of data disks available.
|
|
1833
|
+
"""
|
|
1834
|
+
min_gpu: NotRequired[pulumi.Input[_builtins.float]]
|
|
1835
|
+
"""
|
|
1836
|
+
Minimum number of GPUs available.
|
|
1837
|
+
"""
|
|
1838
|
+
min_memory_gib: NotRequired[pulumi.Input[_builtins.float]]
|
|
1839
|
+
"""
|
|
1840
|
+
Minimum amount of Memory (GiB).
|
|
1841
|
+
"""
|
|
1842
|
+
min_nics: NotRequired[pulumi.Input[_builtins.int]]
|
|
1843
|
+
"""
|
|
1844
|
+
Minimum number of network interfaces.
|
|
1845
|
+
"""
|
|
1846
|
+
min_vcpu: NotRequired[pulumi.Input[_builtins.int]]
|
|
1847
|
+
"""
|
|
1848
|
+
Minimum number of vcpus available.
|
|
1849
|
+
"""
|
|
1850
|
+
series: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1851
|
+
"""
|
|
1852
|
+
Vm sizes belonging to a series from the list will be available for scaling.
|
|
1853
|
+
"""
|
|
1854
|
+
vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
1855
|
+
"""
|
|
1856
|
+
The filtered vm types will belong to one of the vm types from this list.
|
|
1857
|
+
"""
|
|
1858
|
+
elif False:
|
|
1859
|
+
OceanNpVirtualNodeGroupFiltersArgsDict: TypeAlias = Mapping[str, Any]
|
|
1860
|
+
|
|
1065
1861
|
@pulumi.input_type
|
|
1066
1862
|
class OceanNpVirtualNodeGroupFiltersArgs:
|
|
1067
1863
|
def __init__(__self__, *,
|
|
1068
|
-
accelerated_networking: Optional[pulumi.Input[str]] = None,
|
|
1069
|
-
architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1070
|
-
disk_performance: Optional[pulumi.Input[str]] = None,
|
|
1071
|
-
exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1072
|
-
gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1073
|
-
max_gpu: Optional[pulumi.Input[float]] = None,
|
|
1074
|
-
max_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
1075
|
-
max_vcpu: Optional[pulumi.Input[int]] = None,
|
|
1076
|
-
min_disk: Optional[pulumi.Input[int]] = None,
|
|
1077
|
-
min_gpu: Optional[pulumi.Input[float]] = None,
|
|
1078
|
-
min_memory_gib: Optional[pulumi.Input[float]] = None,
|
|
1079
|
-
min_nics: Optional[pulumi.Input[int]] = None,
|
|
1080
|
-
min_vcpu: Optional[pulumi.Input[int]] = None,
|
|
1081
|
-
series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1082
|
-
vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1083
|
-
"""
|
|
1084
|
-
:param pulumi.Input[str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
1085
|
-
: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.
|
|
1086
|
-
:param pulumi.Input[str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
|
|
1087
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling.
|
|
1088
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
|
|
1089
|
-
:param pulumi.Input[float] max_gpu: Maximum number of GPUs available.
|
|
1090
|
-
:param pulumi.Input[float] max_memory_gib: Maximum amount of Memory (GiB).
|
|
1091
|
-
:param pulumi.Input[int] max_vcpu: Maximum number of vcpus available.
|
|
1092
|
-
:param pulumi.Input[int] min_disk: Minimum number of data disks available.
|
|
1093
|
-
:param pulumi.Input[float] min_gpu: Minimum number of GPUs available.
|
|
1094
|
-
:param pulumi.Input[float] min_memory_gib: Minimum amount of Memory (GiB).
|
|
1095
|
-
:param pulumi.Input[int] min_nics: Minimum number of network interfaces.
|
|
1096
|
-
:param pulumi.Input[int] min_vcpu: Minimum number of vcpus available.
|
|
1097
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] series: Vm sizes belonging to a series from the list will be available for scaling.
|
|
1098
|
-
: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.
|
|
1099
1895
|
"""
|
|
1100
1896
|
if accelerated_networking is not None:
|
|
1101
1897
|
pulumi.set(__self__, "accelerated_networking", accelerated_networking)
|
|
@@ -1128,199 +1924,220 @@ class OceanNpVirtualNodeGroupFiltersArgs:
|
|
|
1128
1924
|
if vm_types is not None:
|
|
1129
1925
|
pulumi.set(__self__, "vm_types", vm_types)
|
|
1130
1926
|
|
|
1131
|
-
@property
|
|
1927
|
+
@_builtins.property
|
|
1132
1928
|
@pulumi.getter(name="acceleratedNetworking")
|
|
1133
|
-
def accelerated_networking(self) -> Optional[pulumi.Input[str]]:
|
|
1929
|
+
def accelerated_networking(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1134
1930
|
"""
|
|
1135
1931
|
In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
|
|
1136
1932
|
"""
|
|
1137
1933
|
return pulumi.get(self, "accelerated_networking")
|
|
1138
1934
|
|
|
1139
1935
|
@accelerated_networking.setter
|
|
1140
|
-
def accelerated_networking(self, value: Optional[pulumi.Input[str]]):
|
|
1936
|
+
def accelerated_networking(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1141
1937
|
pulumi.set(self, "accelerated_networking", value)
|
|
1142
1938
|
|
|
1143
|
-
@property
|
|
1939
|
+
@_builtins.property
|
|
1144
1940
|
@pulumi.getter
|
|
1145
|
-
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1941
|
+
def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1146
1942
|
"""
|
|
1147
1943
|
The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
|
|
1148
1944
|
"""
|
|
1149
1945
|
return pulumi.get(self, "architectures")
|
|
1150
1946
|
|
|
1151
1947
|
@architectures.setter
|
|
1152
|
-
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1948
|
+
def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1153
1949
|
pulumi.set(self, "architectures", value)
|
|
1154
1950
|
|
|
1155
|
-
@property
|
|
1951
|
+
@_builtins.property
|
|
1156
1952
|
@pulumi.getter(name="diskPerformance")
|
|
1157
|
-
def disk_performance(self) -> Optional[pulumi.Input[str]]:
|
|
1953
|
+
def disk_performance(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1158
1954
|
"""
|
|
1159
1955
|
The filtered vm sizes will support at least one of the classes from this list.
|
|
1160
1956
|
"""
|
|
1161
1957
|
return pulumi.get(self, "disk_performance")
|
|
1162
1958
|
|
|
1163
1959
|
@disk_performance.setter
|
|
1164
|
-
def disk_performance(self, value: Optional[pulumi.Input[str]]):
|
|
1960
|
+
def disk_performance(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1165
1961
|
pulumi.set(self, "disk_performance", value)
|
|
1166
1962
|
|
|
1167
|
-
@property
|
|
1963
|
+
@_builtins.property
|
|
1168
1964
|
@pulumi.getter(name="excludeSeries")
|
|
1169
|
-
def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1965
|
+
def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1170
1966
|
"""
|
|
1171
1967
|
Vm sizes belonging to a series from the list will not be available for scaling.
|
|
1172
1968
|
"""
|
|
1173
1969
|
return pulumi.get(self, "exclude_series")
|
|
1174
1970
|
|
|
1175
1971
|
@exclude_series.setter
|
|
1176
|
-
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]]]]):
|
|
1177
1973
|
pulumi.set(self, "exclude_series", value)
|
|
1178
1974
|
|
|
1179
|
-
@property
|
|
1975
|
+
@_builtins.property
|
|
1180
1976
|
@pulumi.getter(name="gpuTypes")
|
|
1181
|
-
def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1977
|
+
def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1182
1978
|
"""
|
|
1183
1979
|
The filtered gpu types will belong to one of the gpu types from this list.
|
|
1184
1980
|
"""
|
|
1185
1981
|
return pulumi.get(self, "gpu_types")
|
|
1186
1982
|
|
|
1187
1983
|
@gpu_types.setter
|
|
1188
|
-
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]]]]):
|
|
1189
1985
|
pulumi.set(self, "gpu_types", value)
|
|
1190
1986
|
|
|
1191
|
-
@property
|
|
1987
|
+
@_builtins.property
|
|
1192
1988
|
@pulumi.getter(name="maxGpu")
|
|
1193
|
-
def max_gpu(self) -> Optional[pulumi.Input[float]]:
|
|
1989
|
+
def max_gpu(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1194
1990
|
"""
|
|
1195
1991
|
Maximum number of GPUs available.
|
|
1196
1992
|
"""
|
|
1197
1993
|
return pulumi.get(self, "max_gpu")
|
|
1198
1994
|
|
|
1199
1995
|
@max_gpu.setter
|
|
1200
|
-
def max_gpu(self, value: Optional[pulumi.Input[float]]):
|
|
1996
|
+
def max_gpu(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1201
1997
|
pulumi.set(self, "max_gpu", value)
|
|
1202
1998
|
|
|
1203
|
-
@property
|
|
1999
|
+
@_builtins.property
|
|
1204
2000
|
@pulumi.getter(name="maxMemoryGib")
|
|
1205
|
-
def max_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
2001
|
+
def max_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1206
2002
|
"""
|
|
1207
2003
|
Maximum amount of Memory (GiB).
|
|
1208
2004
|
"""
|
|
1209
2005
|
return pulumi.get(self, "max_memory_gib")
|
|
1210
2006
|
|
|
1211
2007
|
@max_memory_gib.setter
|
|
1212
|
-
def max_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
2008
|
+
def max_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1213
2009
|
pulumi.set(self, "max_memory_gib", value)
|
|
1214
2010
|
|
|
1215
|
-
@property
|
|
2011
|
+
@_builtins.property
|
|
1216
2012
|
@pulumi.getter(name="maxVcpu")
|
|
1217
|
-
def max_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
2013
|
+
def max_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1218
2014
|
"""
|
|
1219
2015
|
Maximum number of vcpus available.
|
|
1220
2016
|
"""
|
|
1221
2017
|
return pulumi.get(self, "max_vcpu")
|
|
1222
2018
|
|
|
1223
2019
|
@max_vcpu.setter
|
|
1224
|
-
def max_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
2020
|
+
def max_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1225
2021
|
pulumi.set(self, "max_vcpu", value)
|
|
1226
2022
|
|
|
1227
|
-
@property
|
|
2023
|
+
@_builtins.property
|
|
1228
2024
|
@pulumi.getter(name="minDisk")
|
|
1229
|
-
def min_disk(self) -> Optional[pulumi.Input[int]]:
|
|
2025
|
+
def min_disk(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1230
2026
|
"""
|
|
1231
2027
|
Minimum number of data disks available.
|
|
1232
2028
|
"""
|
|
1233
2029
|
return pulumi.get(self, "min_disk")
|
|
1234
2030
|
|
|
1235
2031
|
@min_disk.setter
|
|
1236
|
-
def min_disk(self, value: Optional[pulumi.Input[int]]):
|
|
2032
|
+
def min_disk(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1237
2033
|
pulumi.set(self, "min_disk", value)
|
|
1238
2034
|
|
|
1239
|
-
@property
|
|
2035
|
+
@_builtins.property
|
|
1240
2036
|
@pulumi.getter(name="minGpu")
|
|
1241
|
-
def min_gpu(self) -> Optional[pulumi.Input[float]]:
|
|
2037
|
+
def min_gpu(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1242
2038
|
"""
|
|
1243
2039
|
Minimum number of GPUs available.
|
|
1244
2040
|
"""
|
|
1245
2041
|
return pulumi.get(self, "min_gpu")
|
|
1246
2042
|
|
|
1247
2043
|
@min_gpu.setter
|
|
1248
|
-
def min_gpu(self, value: Optional[pulumi.Input[float]]):
|
|
2044
|
+
def min_gpu(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1249
2045
|
pulumi.set(self, "min_gpu", value)
|
|
1250
2046
|
|
|
1251
|
-
@property
|
|
2047
|
+
@_builtins.property
|
|
1252
2048
|
@pulumi.getter(name="minMemoryGib")
|
|
1253
|
-
def min_memory_gib(self) -> Optional[pulumi.Input[float]]:
|
|
2049
|
+
def min_memory_gib(self) -> Optional[pulumi.Input[_builtins.float]]:
|
|
1254
2050
|
"""
|
|
1255
2051
|
Minimum amount of Memory (GiB).
|
|
1256
2052
|
"""
|
|
1257
2053
|
return pulumi.get(self, "min_memory_gib")
|
|
1258
2054
|
|
|
1259
2055
|
@min_memory_gib.setter
|
|
1260
|
-
def min_memory_gib(self, value: Optional[pulumi.Input[float]]):
|
|
2056
|
+
def min_memory_gib(self, value: Optional[pulumi.Input[_builtins.float]]):
|
|
1261
2057
|
pulumi.set(self, "min_memory_gib", value)
|
|
1262
2058
|
|
|
1263
|
-
@property
|
|
2059
|
+
@_builtins.property
|
|
1264
2060
|
@pulumi.getter(name="minNics")
|
|
1265
|
-
def min_nics(self) -> Optional[pulumi.Input[int]]:
|
|
2061
|
+
def min_nics(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1266
2062
|
"""
|
|
1267
2063
|
Minimum number of network interfaces.
|
|
1268
2064
|
"""
|
|
1269
2065
|
return pulumi.get(self, "min_nics")
|
|
1270
2066
|
|
|
1271
2067
|
@min_nics.setter
|
|
1272
|
-
def min_nics(self, value: Optional[pulumi.Input[int]]):
|
|
2068
|
+
def min_nics(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1273
2069
|
pulumi.set(self, "min_nics", value)
|
|
1274
2070
|
|
|
1275
|
-
@property
|
|
2071
|
+
@_builtins.property
|
|
1276
2072
|
@pulumi.getter(name="minVcpu")
|
|
1277
|
-
def min_vcpu(self) -> Optional[pulumi.Input[int]]:
|
|
2073
|
+
def min_vcpu(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1278
2074
|
"""
|
|
1279
2075
|
Minimum number of vcpus available.
|
|
1280
2076
|
"""
|
|
1281
2077
|
return pulumi.get(self, "min_vcpu")
|
|
1282
2078
|
|
|
1283
2079
|
@min_vcpu.setter
|
|
1284
|
-
def min_vcpu(self, value: Optional[pulumi.Input[int]]):
|
|
2080
|
+
def min_vcpu(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1285
2081
|
pulumi.set(self, "min_vcpu", value)
|
|
1286
2082
|
|
|
1287
|
-
@property
|
|
2083
|
+
@_builtins.property
|
|
1288
2084
|
@pulumi.getter
|
|
1289
|
-
def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2085
|
+
def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1290
2086
|
"""
|
|
1291
2087
|
Vm sizes belonging to a series from the list will be available for scaling.
|
|
1292
2088
|
"""
|
|
1293
2089
|
return pulumi.get(self, "series")
|
|
1294
2090
|
|
|
1295
2091
|
@series.setter
|
|
1296
|
-
def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2092
|
+
def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1297
2093
|
pulumi.set(self, "series", value)
|
|
1298
2094
|
|
|
1299
|
-
@property
|
|
2095
|
+
@_builtins.property
|
|
1300
2096
|
@pulumi.getter(name="vmTypes")
|
|
1301
|
-
def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2097
|
+
def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1302
2098
|
"""
|
|
1303
2099
|
The filtered vm types will belong to one of the vm types from this list.
|
|
1304
2100
|
"""
|
|
1305
2101
|
return pulumi.get(self, "vm_types")
|
|
1306
2102
|
|
|
1307
2103
|
@vm_types.setter
|
|
1308
|
-
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]]]]):
|
|
1309
2105
|
pulumi.set(self, "vm_types", value)
|
|
1310
2106
|
|
|
1311
2107
|
|
|
2108
|
+
if not MYPY:
|
|
2109
|
+
class OceanNpVirtualNodeGroupHeadroomArgsDict(TypedDict):
|
|
2110
|
+
cpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2111
|
+
"""
|
|
2112
|
+
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
2113
|
+
"""
|
|
2114
|
+
gpu_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2115
|
+
"""
|
|
2116
|
+
Amount of GPU to allocate for headroom unit.
|
|
2117
|
+
"""
|
|
2118
|
+
memory_per_unit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2119
|
+
"""
|
|
2120
|
+
Configure the amount of memory (MiB) to allocate the headroom.
|
|
2121
|
+
"""
|
|
2122
|
+
num_of_units: NotRequired[pulumi.Input[_builtins.int]]
|
|
2123
|
+
"""
|
|
2124
|
+
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
2125
|
+
"""
|
|
2126
|
+
elif False:
|
|
2127
|
+
OceanNpVirtualNodeGroupHeadroomArgsDict: TypeAlias = Mapping[str, Any]
|
|
2128
|
+
|
|
1312
2129
|
@pulumi.input_type
|
|
1313
2130
|
class OceanNpVirtualNodeGroupHeadroomArgs:
|
|
1314
2131
|
def __init__(__self__, *,
|
|
1315
|
-
cpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1316
|
-
gpu_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1317
|
-
memory_per_unit: Optional[pulumi.Input[int]] = None,
|
|
1318
|
-
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):
|
|
1319
2136
|
"""
|
|
1320
|
-
: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.
|
|
1321
|
-
:param pulumi.Input[int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
|
|
1322
|
-
:param pulumi.Input[int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
|
|
1323
|
-
: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.
|
|
1324
2141
|
"""
|
|
1325
2142
|
if cpu_per_unit is not None:
|
|
1326
2143
|
pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
|
|
@@ -1331,55 +2148,64 @@ class OceanNpVirtualNodeGroupHeadroomArgs:
|
|
|
1331
2148
|
if num_of_units is not None:
|
|
1332
2149
|
pulumi.set(__self__, "num_of_units", num_of_units)
|
|
1333
2150
|
|
|
1334
|
-
@property
|
|
2151
|
+
@_builtins.property
|
|
1335
2152
|
@pulumi.getter(name="cpuPerUnit")
|
|
1336
|
-
def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2153
|
+
def cpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1337
2154
|
"""
|
|
1338
2155
|
Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
|
|
1339
2156
|
"""
|
|
1340
2157
|
return pulumi.get(self, "cpu_per_unit")
|
|
1341
2158
|
|
|
1342
2159
|
@cpu_per_unit.setter
|
|
1343
|
-
def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2160
|
+
def cpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1344
2161
|
pulumi.set(self, "cpu_per_unit", value)
|
|
1345
2162
|
|
|
1346
|
-
@property
|
|
2163
|
+
@_builtins.property
|
|
1347
2164
|
@pulumi.getter(name="gpuPerUnit")
|
|
1348
|
-
def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2165
|
+
def gpu_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1349
2166
|
"""
|
|
1350
2167
|
Amount of GPU to allocate for headroom unit.
|
|
1351
2168
|
"""
|
|
1352
2169
|
return pulumi.get(self, "gpu_per_unit")
|
|
1353
2170
|
|
|
1354
2171
|
@gpu_per_unit.setter
|
|
1355
|
-
def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2172
|
+
def gpu_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1356
2173
|
pulumi.set(self, "gpu_per_unit", value)
|
|
1357
2174
|
|
|
1358
|
-
@property
|
|
2175
|
+
@_builtins.property
|
|
1359
2176
|
@pulumi.getter(name="memoryPerUnit")
|
|
1360
|
-
def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
|
|
2177
|
+
def memory_per_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1361
2178
|
"""
|
|
1362
2179
|
Configure the amount of memory (MiB) to allocate the headroom.
|
|
1363
2180
|
"""
|
|
1364
2181
|
return pulumi.get(self, "memory_per_unit")
|
|
1365
2182
|
|
|
1366
2183
|
@memory_per_unit.setter
|
|
1367
|
-
def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
|
|
2184
|
+
def memory_per_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1368
2185
|
pulumi.set(self, "memory_per_unit", value)
|
|
1369
2186
|
|
|
1370
|
-
@property
|
|
2187
|
+
@_builtins.property
|
|
1371
2188
|
@pulumi.getter(name="numOfUnits")
|
|
1372
|
-
def num_of_units(self) -> Optional[pulumi.Input[int]]:
|
|
2189
|
+
def num_of_units(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1373
2190
|
"""
|
|
1374
2191
|
The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
|
|
1375
2192
|
"""
|
|
1376
2193
|
return pulumi.get(self, "num_of_units")
|
|
1377
2194
|
|
|
1378
2195
|
@num_of_units.setter
|
|
1379
|
-
def num_of_units(self, value: Optional[pulumi.Input[int]]):
|
|
2196
|
+
def num_of_units(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1380
2197
|
pulumi.set(self, "num_of_units", value)
|
|
1381
2198
|
|
|
1382
2199
|
|
|
2200
|
+
if not MYPY:
|
|
2201
|
+
class OceanNpVirtualNodeGroupLinuxOsConfigArgsDict(TypedDict):
|
|
2202
|
+
sysctls: NotRequired[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgsDict']]]]
|
|
2203
|
+
"""
|
|
2204
|
+
System Controls
|
|
2205
|
+
"""
|
|
2206
|
+
elif False:
|
|
2207
|
+
OceanNpVirtualNodeGroupLinuxOsConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
2208
|
+
|
|
1383
2209
|
@pulumi.input_type
|
|
1384
2210
|
class OceanNpVirtualNodeGroupLinuxOsConfigArgs:
|
|
1385
2211
|
def __init__(__self__, *,
|
|
@@ -1390,7 +2216,7 @@ class OceanNpVirtualNodeGroupLinuxOsConfigArgs:
|
|
|
1390
2216
|
if sysctls is not None:
|
|
1391
2217
|
pulumi.set(__self__, "sysctls", sysctls)
|
|
1392
2218
|
|
|
1393
|
-
@property
|
|
2219
|
+
@_builtins.property
|
|
1394
2220
|
@pulumi.getter
|
|
1395
2221
|
def sysctls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgs']]]]:
|
|
1396
2222
|
"""
|
|
@@ -1403,90 +2229,217 @@ class OceanNpVirtualNodeGroupLinuxOsConfigArgs:
|
|
|
1403
2229
|
pulumi.set(self, "sysctls", value)
|
|
1404
2230
|
|
|
1405
2231
|
|
|
2232
|
+
if not MYPY:
|
|
2233
|
+
class OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgsDict(TypedDict):
|
|
2234
|
+
vm_max_map_count: NotRequired[pulumi.Input[_builtins.int]]
|
|
2235
|
+
"""
|
|
2236
|
+
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
2237
|
+
"""
|
|
2238
|
+
elif False:
|
|
2239
|
+
OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgsDict: TypeAlias = Mapping[str, Any]
|
|
2240
|
+
|
|
1406
2241
|
@pulumi.input_type
|
|
1407
2242
|
class OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgs:
|
|
1408
2243
|
def __init__(__self__, *,
|
|
1409
|
-
vm_max_map_count: Optional[pulumi.Input[int]] = None):
|
|
2244
|
+
vm_max_map_count: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1410
2245
|
"""
|
|
1411
|
-
: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.
|
|
1412
2247
|
"""
|
|
1413
2248
|
if vm_max_map_count is not None:
|
|
1414
2249
|
pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
|
|
1415
2250
|
|
|
1416
|
-
@property
|
|
2251
|
+
@_builtins.property
|
|
1417
2252
|
@pulumi.getter(name="vmMaxMapCount")
|
|
1418
|
-
def vm_max_map_count(self) -> Optional[pulumi.Input[int]]:
|
|
2253
|
+
def vm_max_map_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1419
2254
|
"""
|
|
1420
2255
|
Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
|
|
1421
2256
|
"""
|
|
1422
2257
|
return pulumi.get(self, "vm_max_map_count")
|
|
1423
2258
|
|
|
1424
2259
|
@vm_max_map_count.setter
|
|
1425
|
-
def vm_max_map_count(self, value: Optional[pulumi.Input[int]]):
|
|
2260
|
+
def vm_max_map_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1426
2261
|
pulumi.set(self, "vm_max_map_count", value)
|
|
1427
2262
|
|
|
1428
2263
|
|
|
2264
|
+
if not MYPY:
|
|
2265
|
+
class OceanNpVirtualNodeGroupSchedulingArgsDict(TypedDict):
|
|
2266
|
+
shutdown_hours: NotRequired[pulumi.Input['OceanNpVirtualNodeGroupSchedulingShutdownHoursArgsDict']]
|
|
2267
|
+
"""
|
|
2268
|
+
An object used to specify times that the nodes in the virtual node group will be stopped.
|
|
2269
|
+
"""
|
|
2270
|
+
elif False:
|
|
2271
|
+
OceanNpVirtualNodeGroupSchedulingArgsDict: TypeAlias = Mapping[str, Any]
|
|
2272
|
+
|
|
2273
|
+
@pulumi.input_type
|
|
2274
|
+
class OceanNpVirtualNodeGroupSchedulingArgs:
|
|
2275
|
+
def __init__(__self__, *,
|
|
2276
|
+
shutdown_hours: Optional[pulumi.Input['OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs']] = None):
|
|
2277
|
+
"""
|
|
2278
|
+
:param pulumi.Input['OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs'] shutdown_hours: An object used to specify times that the nodes in the virtual node group will be stopped.
|
|
2279
|
+
"""
|
|
2280
|
+
if shutdown_hours is not None:
|
|
2281
|
+
pulumi.set(__self__, "shutdown_hours", shutdown_hours)
|
|
2282
|
+
|
|
2283
|
+
@_builtins.property
|
|
2284
|
+
@pulumi.getter(name="shutdownHours")
|
|
2285
|
+
def shutdown_hours(self) -> Optional[pulumi.Input['OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs']]:
|
|
2286
|
+
"""
|
|
2287
|
+
An object used to specify times that the nodes in the virtual node group will be stopped.
|
|
2288
|
+
"""
|
|
2289
|
+
return pulumi.get(self, "shutdown_hours")
|
|
2290
|
+
|
|
2291
|
+
@shutdown_hours.setter
|
|
2292
|
+
def shutdown_hours(self, value: Optional[pulumi.Input['OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs']]):
|
|
2293
|
+
pulumi.set(self, "shutdown_hours", value)
|
|
2294
|
+
|
|
2295
|
+
|
|
2296
|
+
if not MYPY:
|
|
2297
|
+
class OceanNpVirtualNodeGroupSchedulingShutdownHoursArgsDict(TypedDict):
|
|
2298
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2299
|
+
"""
|
|
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
|
+
"""
|
|
2302
|
+
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2303
|
+
"""
|
|
2304
|
+
The times that the shutdown hours will apply. Required if isEnabled is true.
|
|
2305
|
+
"""
|
|
2306
|
+
elif False:
|
|
2307
|
+
OceanNpVirtualNodeGroupSchedulingShutdownHoursArgsDict: TypeAlias = Mapping[str, Any]
|
|
2308
|
+
|
|
2309
|
+
@pulumi.input_type
|
|
2310
|
+
class OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs:
|
|
2311
|
+
def __init__(__self__, *,
|
|
2312
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2313
|
+
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
2314
|
+
"""
|
|
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
|
+
"""
|
|
2318
|
+
if is_enabled is not None:
|
|
2319
|
+
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
2320
|
+
if time_windows is not None:
|
|
2321
|
+
pulumi.set(__self__, "time_windows", time_windows)
|
|
2322
|
+
|
|
2323
|
+
@_builtins.property
|
|
2324
|
+
@pulumi.getter(name="isEnabled")
|
|
2325
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2326
|
+
"""
|
|
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
|
+
"""
|
|
2329
|
+
return pulumi.get(self, "is_enabled")
|
|
2330
|
+
|
|
2331
|
+
@is_enabled.setter
|
|
2332
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2333
|
+
pulumi.set(self, "is_enabled", value)
|
|
2334
|
+
|
|
2335
|
+
@_builtins.property
|
|
2336
|
+
@pulumi.getter(name="timeWindows")
|
|
2337
|
+
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2338
|
+
"""
|
|
2339
|
+
The times that the shutdown hours will apply. Required if isEnabled is true.
|
|
2340
|
+
"""
|
|
2341
|
+
return pulumi.get(self, "time_windows")
|
|
2342
|
+
|
|
2343
|
+
@time_windows.setter
|
|
2344
|
+
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2345
|
+
pulumi.set(self, "time_windows", value)
|
|
2346
|
+
|
|
2347
|
+
|
|
2348
|
+
if not MYPY:
|
|
2349
|
+
class OceanNpVirtualNodeGroupTaintArgsDict(TypedDict):
|
|
2350
|
+
effect: pulumi.Input[_builtins.str]
|
|
2351
|
+
"""
|
|
2352
|
+
Set taint effect.
|
|
2353
|
+
"""
|
|
2354
|
+
key: pulumi.Input[_builtins.str]
|
|
2355
|
+
"""
|
|
2356
|
+
Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
|
|
2357
|
+
"""
|
|
2358
|
+
value: pulumi.Input[_builtins.str]
|
|
2359
|
+
"""
|
|
2360
|
+
Set taint value.
|
|
2361
|
+
"""
|
|
2362
|
+
elif False:
|
|
2363
|
+
OceanNpVirtualNodeGroupTaintArgsDict: TypeAlias = Mapping[str, Any]
|
|
2364
|
+
|
|
1429
2365
|
@pulumi.input_type
|
|
1430
2366
|
class OceanNpVirtualNodeGroupTaintArgs:
|
|
1431
2367
|
def __init__(__self__, *,
|
|
1432
|
-
effect: pulumi.Input[str],
|
|
1433
|
-
key: pulumi.Input[str],
|
|
1434
|
-
value: pulumi.Input[str]):
|
|
2368
|
+
effect: pulumi.Input[_builtins.str],
|
|
2369
|
+
key: pulumi.Input[_builtins.str],
|
|
2370
|
+
value: pulumi.Input[_builtins.str]):
|
|
1435
2371
|
"""
|
|
1436
|
-
:param pulumi.Input[str] effect: Set taint effect.
|
|
1437
|
-
:param pulumi.Input[str] key: Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
|
|
1438
|
-
: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.
|
|
1439
2375
|
"""
|
|
1440
2376
|
pulumi.set(__self__, "effect", effect)
|
|
1441
2377
|
pulumi.set(__self__, "key", key)
|
|
1442
2378
|
pulumi.set(__self__, "value", value)
|
|
1443
2379
|
|
|
1444
|
-
@property
|
|
2380
|
+
@_builtins.property
|
|
1445
2381
|
@pulumi.getter
|
|
1446
|
-
def effect(self) -> pulumi.Input[str]:
|
|
2382
|
+
def effect(self) -> pulumi.Input[_builtins.str]:
|
|
1447
2383
|
"""
|
|
1448
2384
|
Set taint effect.
|
|
1449
2385
|
"""
|
|
1450
2386
|
return pulumi.get(self, "effect")
|
|
1451
2387
|
|
|
1452
2388
|
@effect.setter
|
|
1453
|
-
def effect(self, value: pulumi.Input[str]):
|
|
2389
|
+
def effect(self, value: pulumi.Input[_builtins.str]):
|
|
1454
2390
|
pulumi.set(self, "effect", value)
|
|
1455
2391
|
|
|
1456
|
-
@property
|
|
2392
|
+
@_builtins.property
|
|
1457
2393
|
@pulumi.getter
|
|
1458
|
-
def key(self) -> pulumi.Input[str]:
|
|
2394
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
1459
2395
|
"""
|
|
1460
2396
|
Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
|
|
1461
2397
|
"""
|
|
1462
2398
|
return pulumi.get(self, "key")
|
|
1463
2399
|
|
|
1464
2400
|
@key.setter
|
|
1465
|
-
def key(self, value: pulumi.Input[str]):
|
|
2401
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
1466
2402
|
pulumi.set(self, "key", value)
|
|
1467
2403
|
|
|
1468
|
-
@property
|
|
2404
|
+
@_builtins.property
|
|
1469
2405
|
@pulumi.getter
|
|
1470
|
-
def value(self) -> pulumi.Input[str]:
|
|
2406
|
+
def value(self) -> pulumi.Input[_builtins.str]:
|
|
1471
2407
|
"""
|
|
1472
2408
|
Set taint value.
|
|
1473
2409
|
"""
|
|
1474
2410
|
return pulumi.get(self, "value")
|
|
1475
2411
|
|
|
1476
2412
|
@value.setter
|
|
1477
|
-
def value(self, value: pulumi.Input[str]):
|
|
2413
|
+
def value(self, value: pulumi.Input[_builtins.str]):
|
|
1478
2414
|
pulumi.set(self, "value", value)
|
|
1479
2415
|
|
|
1480
2416
|
|
|
2417
|
+
if not MYPY:
|
|
2418
|
+
class OceanNpVirtualNodeGroupUpdatePolicyArgsDict(TypedDict):
|
|
2419
|
+
should_roll: pulumi.Input[_builtins.bool]
|
|
2420
|
+
"""
|
|
2421
|
+
If set to true along with the vng update, roll will be triggered.
|
|
2422
|
+
"""
|
|
2423
|
+
conditioned_roll: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2424
|
+
"""
|
|
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
|
+
"""
|
|
2427
|
+
roll_config: NotRequired[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgsDict']]
|
|
2428
|
+
"""
|
|
2429
|
+
While used, you can control whether the group should perform a deployment after an update to the configuration.
|
|
2430
|
+
"""
|
|
2431
|
+
elif False:
|
|
2432
|
+
OceanNpVirtualNodeGroupUpdatePolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
2433
|
+
|
|
1481
2434
|
@pulumi.input_type
|
|
1482
2435
|
class OceanNpVirtualNodeGroupUpdatePolicyArgs:
|
|
1483
2436
|
def __init__(__self__, *,
|
|
1484
|
-
should_roll: pulumi.Input[bool],
|
|
1485
|
-
conditioned_roll: Optional[pulumi.Input[bool]] = None,
|
|
2437
|
+
should_roll: pulumi.Input[_builtins.bool],
|
|
2438
|
+
conditioned_roll: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1486
2439
|
roll_config: Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs']] = None):
|
|
1487
2440
|
"""
|
|
1488
|
-
:param pulumi.Input[bool] should_roll: If set to true along with the vng update, roll will be triggered.
|
|
1489
|
-
: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).
|
|
1490
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.
|
|
1491
2444
|
"""
|
|
1492
2445
|
pulumi.set(__self__, "should_roll", should_roll)
|
|
@@ -1495,31 +2448,31 @@ class OceanNpVirtualNodeGroupUpdatePolicyArgs:
|
|
|
1495
2448
|
if roll_config is not None:
|
|
1496
2449
|
pulumi.set(__self__, "roll_config", roll_config)
|
|
1497
2450
|
|
|
1498
|
-
@property
|
|
2451
|
+
@_builtins.property
|
|
1499
2452
|
@pulumi.getter(name="shouldRoll")
|
|
1500
|
-
def should_roll(self) -> pulumi.Input[bool]:
|
|
2453
|
+
def should_roll(self) -> pulumi.Input[_builtins.bool]:
|
|
1501
2454
|
"""
|
|
1502
2455
|
If set to true along with the vng update, roll will be triggered.
|
|
1503
2456
|
"""
|
|
1504
2457
|
return pulumi.get(self, "should_roll")
|
|
1505
2458
|
|
|
1506
2459
|
@should_roll.setter
|
|
1507
|
-
def should_roll(self, value: pulumi.Input[bool]):
|
|
2460
|
+
def should_roll(self, value: pulumi.Input[_builtins.bool]):
|
|
1508
2461
|
pulumi.set(self, "should_roll", value)
|
|
1509
2462
|
|
|
1510
|
-
@property
|
|
2463
|
+
@_builtins.property
|
|
1511
2464
|
@pulumi.getter(name="conditionedRoll")
|
|
1512
|
-
def conditioned_roll(self) -> Optional[pulumi.Input[bool]]:
|
|
2465
|
+
def conditioned_roll(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1513
2466
|
"""
|
|
1514
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).
|
|
1515
2468
|
"""
|
|
1516
2469
|
return pulumi.get(self, "conditioned_roll")
|
|
1517
2470
|
|
|
1518
2471
|
@conditioned_roll.setter
|
|
1519
|
-
def conditioned_roll(self, value: Optional[pulumi.Input[bool]]):
|
|
2472
|
+
def conditioned_roll(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1520
2473
|
pulumi.set(self, "conditioned_roll", value)
|
|
1521
2474
|
|
|
1522
|
-
@property
|
|
2475
|
+
@_builtins.property
|
|
1523
2476
|
@pulumi.getter(name="rollConfig")
|
|
1524
2477
|
def roll_config(self) -> Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs']]:
|
|
1525
2478
|
"""
|
|
@@ -1532,26 +2485,63 @@ class OceanNpVirtualNodeGroupUpdatePolicyArgs:
|
|
|
1532
2485
|
pulumi.set(self, "roll_config", value)
|
|
1533
2486
|
|
|
1534
2487
|
|
|
2488
|
+
if not MYPY:
|
|
2489
|
+
class OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgsDict(TypedDict):
|
|
2490
|
+
batch_min_healthy_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2491
|
+
"""
|
|
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
|
+
"""
|
|
2494
|
+
batch_size_percentage: NotRequired[pulumi.Input[_builtins.int]]
|
|
2495
|
+
"""
|
|
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
|
+
"""
|
|
2498
|
+
comment: NotRequired[pulumi.Input[_builtins.str]]
|
|
2499
|
+
"""
|
|
2500
|
+
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
2501
|
+
"""
|
|
2502
|
+
node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2503
|
+
"""
|
|
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
|
+
"""
|
|
2506
|
+
node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2507
|
+
"""
|
|
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
|
+
"""
|
|
2510
|
+
respect_pdb: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2511
|
+
"""
|
|
2512
|
+
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
2513
|
+
"""
|
|
2514
|
+
respect_restrict_scale_down: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2515
|
+
"""
|
|
2516
|
+
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
2517
|
+
"""
|
|
2518
|
+
vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2519
|
+
"""
|
|
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
|
+
"""
|
|
2522
|
+
elif False:
|
|
2523
|
+
OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
2524
|
+
|
|
1535
2525
|
@pulumi.input_type
|
|
1536
2526
|
class OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs:
|
|
1537
2527
|
def __init__(__self__, *,
|
|
1538
|
-
batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
|
|
1539
|
-
batch_size_percentage: Optional[pulumi.Input[int]] = None,
|
|
1540
|
-
comment: Optional[pulumi.Input[str]] = None,
|
|
1541
|
-
node_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1542
|
-
node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1543
|
-
respect_pdb: Optional[pulumi.Input[bool]] = None,
|
|
1544
|
-
respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None,
|
|
1545
|
-
vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1546
|
-
"""
|
|
1547
|
-
: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.
|
|
1548
|
-
: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%.
|
|
1549
|
-
:param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1550
|
-
: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.
|
|
1551
|
-
: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.
|
|
1552
|
-
:param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1553
|
-
: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.
|
|
1554
|
-
: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.
|
|
1555
2545
|
"""
|
|
1556
2546
|
if batch_min_healthy_percentage is not None:
|
|
1557
2547
|
pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
|
|
@@ -1570,100 +2560,168 @@ class OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs:
|
|
|
1570
2560
|
if vng_ids is not None:
|
|
1571
2561
|
pulumi.set(__self__, "vng_ids", vng_ids)
|
|
1572
2562
|
|
|
1573
|
-
@property
|
|
2563
|
+
@_builtins.property
|
|
1574
2564
|
@pulumi.getter(name="batchMinHealthyPercentage")
|
|
1575
|
-
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2565
|
+
def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1576
2566
|
"""
|
|
1577
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.
|
|
1578
2568
|
"""
|
|
1579
2569
|
return pulumi.get(self, "batch_min_healthy_percentage")
|
|
1580
2570
|
|
|
1581
2571
|
@batch_min_healthy_percentage.setter
|
|
1582
|
-
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2572
|
+
def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1583
2573
|
pulumi.set(self, "batch_min_healthy_percentage", value)
|
|
1584
2574
|
|
|
1585
|
-
@property
|
|
2575
|
+
@_builtins.property
|
|
1586
2576
|
@pulumi.getter(name="batchSizePercentage")
|
|
1587
|
-
def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2577
|
+
def batch_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1588
2578
|
"""
|
|
1589
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%.
|
|
1590
2580
|
"""
|
|
1591
2581
|
return pulumi.get(self, "batch_size_percentage")
|
|
1592
2582
|
|
|
1593
2583
|
@batch_size_percentage.setter
|
|
1594
|
-
def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2584
|
+
def batch_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1595
2585
|
pulumi.set(self, "batch_size_percentage", value)
|
|
1596
2586
|
|
|
1597
|
-
@property
|
|
2587
|
+
@_builtins.property
|
|
1598
2588
|
@pulumi.getter
|
|
1599
|
-
def comment(self) -> Optional[pulumi.Input[str]]:
|
|
2589
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1600
2590
|
"""
|
|
1601
2591
|
Add a comment description for the roll. The comment is limited to 256 chars and optional.
|
|
1602
2592
|
"""
|
|
1603
2593
|
return pulumi.get(self, "comment")
|
|
1604
2594
|
|
|
1605
2595
|
@comment.setter
|
|
1606
|
-
def comment(self, value: Optional[pulumi.Input[str]]):
|
|
2596
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1607
2597
|
pulumi.set(self, "comment", value)
|
|
1608
2598
|
|
|
1609
|
-
@property
|
|
2599
|
+
@_builtins.property
|
|
1610
2600
|
@pulumi.getter(name="nodeNames")
|
|
1611
|
-
def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2601
|
+
def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1612
2602
|
"""
|
|
1613
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.
|
|
1614
2604
|
"""
|
|
1615
2605
|
return pulumi.get(self, "node_names")
|
|
1616
2606
|
|
|
1617
2607
|
@node_names.setter
|
|
1618
|
-
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]]]]):
|
|
1619
2609
|
pulumi.set(self, "node_names", value)
|
|
1620
2610
|
|
|
1621
|
-
@property
|
|
2611
|
+
@_builtins.property
|
|
1622
2612
|
@pulumi.getter(name="nodePoolNames")
|
|
1623
|
-
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]]]]:
|
|
1624
2614
|
"""
|
|
1625
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.
|
|
1626
2616
|
"""
|
|
1627
2617
|
return pulumi.get(self, "node_pool_names")
|
|
1628
2618
|
|
|
1629
2619
|
@node_pool_names.setter
|
|
1630
|
-
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]]]]):
|
|
1631
2621
|
pulumi.set(self, "node_pool_names", value)
|
|
1632
2622
|
|
|
1633
|
-
@property
|
|
2623
|
+
@_builtins.property
|
|
1634
2624
|
@pulumi.getter(name="respectPdb")
|
|
1635
|
-
def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
|
|
2625
|
+
def respect_pdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1636
2626
|
"""
|
|
1637
2627
|
During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
|
|
1638
2628
|
"""
|
|
1639
2629
|
return pulumi.get(self, "respect_pdb")
|
|
1640
2630
|
|
|
1641
2631
|
@respect_pdb.setter
|
|
1642
|
-
def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
|
|
2632
|
+
def respect_pdb(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1643
2633
|
pulumi.set(self, "respect_pdb", value)
|
|
1644
2634
|
|
|
1645
|
-
@property
|
|
2635
|
+
@_builtins.property
|
|
1646
2636
|
@pulumi.getter(name="respectRestrictScaleDown")
|
|
1647
|
-
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
|
|
2637
|
+
def respect_restrict_scale_down(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1648
2638
|
"""
|
|
1649
2639
|
During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
|
|
1650
2640
|
"""
|
|
1651
2641
|
return pulumi.get(self, "respect_restrict_scale_down")
|
|
1652
2642
|
|
|
1653
2643
|
@respect_restrict_scale_down.setter
|
|
1654
|
-
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
|
|
2644
|
+
def respect_restrict_scale_down(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1655
2645
|
pulumi.set(self, "respect_restrict_scale_down", value)
|
|
1656
2646
|
|
|
1657
|
-
@property
|
|
2647
|
+
@_builtins.property
|
|
1658
2648
|
@pulumi.getter(name="vngIds")
|
|
1659
|
-
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2649
|
+
def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1660
2650
|
"""
|
|
1661
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.
|
|
1662
2652
|
"""
|
|
1663
2653
|
return pulumi.get(self, "vng_ids")
|
|
1664
2654
|
|
|
1665
2655
|
@vng_ids.setter
|
|
1666
|
-
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]]]]):
|
|
1667
2657
|
pulumi.set(self, "vng_ids", value)
|
|
1668
2658
|
|
|
1669
2659
|
|
|
2660
|
+
if not MYPY:
|
|
2661
|
+
class OceanNpVngTemplateSchedulingArgsDict(TypedDict):
|
|
2662
|
+
vng_template_shutdown_hours: NotRequired[pulumi.Input['OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgsDict']]
|
|
2663
|
+
elif False:
|
|
2664
|
+
OceanNpVngTemplateSchedulingArgsDict: TypeAlias = Mapping[str, Any]
|
|
2665
|
+
|
|
2666
|
+
@pulumi.input_type
|
|
2667
|
+
class OceanNpVngTemplateSchedulingArgs:
|
|
2668
|
+
def __init__(__self__, *,
|
|
2669
|
+
vng_template_shutdown_hours: Optional[pulumi.Input['OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgs']] = None):
|
|
2670
|
+
if vng_template_shutdown_hours is not None:
|
|
2671
|
+
pulumi.set(__self__, "vng_template_shutdown_hours", vng_template_shutdown_hours)
|
|
2672
|
+
|
|
2673
|
+
@_builtins.property
|
|
2674
|
+
@pulumi.getter(name="vngTemplateShutdownHours")
|
|
2675
|
+
def vng_template_shutdown_hours(self) -> Optional[pulumi.Input['OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgs']]:
|
|
2676
|
+
return pulumi.get(self, "vng_template_shutdown_hours")
|
|
2677
|
+
|
|
2678
|
+
@vng_template_shutdown_hours.setter
|
|
2679
|
+
def vng_template_shutdown_hours(self, value: Optional[pulumi.Input['OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgs']]):
|
|
2680
|
+
pulumi.set(self, "vng_template_shutdown_hours", value)
|
|
2681
|
+
|
|
2682
|
+
|
|
2683
|
+
if not MYPY:
|
|
2684
|
+
class OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgsDict(TypedDict):
|
|
2685
|
+
is_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2686
|
+
time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
2687
|
+
"""
|
|
2688
|
+
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
2689
|
+
"""
|
|
2690
|
+
elif False:
|
|
2691
|
+
OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgsDict: TypeAlias = Mapping[str, Any]
|
|
2692
|
+
|
|
2693
|
+
@pulumi.input_type
|
|
2694
|
+
class OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgs:
|
|
2695
|
+
def __init__(__self__, *,
|
|
2696
|
+
is_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2697
|
+
time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
2698
|
+
"""
|
|
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
|
+
"""
|
|
2701
|
+
if is_enabled is not None:
|
|
2702
|
+
pulumi.set(__self__, "is_enabled", is_enabled)
|
|
2703
|
+
if time_windows is not None:
|
|
2704
|
+
pulumi.set(__self__, "time_windows", time_windows)
|
|
2705
|
+
|
|
2706
|
+
@_builtins.property
|
|
2707
|
+
@pulumi.getter(name="isEnabled")
|
|
2708
|
+
def is_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2709
|
+
return pulumi.get(self, "is_enabled")
|
|
2710
|
+
|
|
2711
|
+
@is_enabled.setter
|
|
2712
|
+
def is_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2713
|
+
pulumi.set(self, "is_enabled", value)
|
|
2714
|
+
|
|
2715
|
+
@_builtins.property
|
|
2716
|
+
@pulumi.getter(name="timeWindows")
|
|
2717
|
+
def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2718
|
+
"""
|
|
2719
|
+
The times that the shutdown hours will apply. Required if `is_enabled` is true.
|
|
2720
|
+
"""
|
|
2721
|
+
return pulumi.get(self, "time_windows")
|
|
2722
|
+
|
|
2723
|
+
@time_windows.setter
|
|
2724
|
+
def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2725
|
+
pulumi.set(self, "time_windows", value)
|
|
2726
|
+
|
|
2727
|
+
|